It's available elsewhere and seems reasonably similar to FreeBSD's version of make. The rationale behind using it was being able to do cross platform builds with bmake while getting away with the system version of make on FreeBSD.
That actually sounds pretty good. When I first ran into cross-platform make problems, my solution was sort of similar: just install gnu make everywhere. Which sounds easy, but it turns out that gnu make is not always easy to install, and there are places where GPL'ed software is very unwelcome or very hard to install (proprietary OSes). I like your solution of using a relatively simple make (the BSD make, here in the bmake version), which can probably be compiled and installed pretty much everywhere.
What I do today, for the few personal projects that actually need interestingly complex make files: I write most of the bulk of the makefile in a very simple fashion, specifying mostly dependencies and what source goes into what executable. Then I have two main make files, called GNUmakefile and BSDmakefile,
which set up make-dependent syntax and rules, and determine which OS is running (the syntax for if statements and include is highly make-dialect dependent). They then include OS-dependent make files (such as Makefile.FreeBSD and Makefile.Darwin and Makefile.FreeBSD.11.3) which do nothing by set variables that depend on the OS (like /usr/local versus /usr versus /opt), and in one case I also have Makefile.<hostname> for software that depends on which computer it is on. Finally, all of them include the bulk file I described first. You end up with a dozen files, but each file is very simple and clean, and many of them are very short. And the one that is very long (the dependency / rule file) is super simple. I'm not sure I would recommend this technique to others though, you need to be pretty OCD to do maintenance on it.
For small projects, I typically don't bother with make at all. Modern computers are so fast, I have a tiny "install" script, which simple deleted all object files and executables, and starts from scratch, with the compile/link/install commands typed right in there. If it crashes, you fix the source code until it starts working. And since the compiles are so far, the inefficiency of recompiling things needlessly doesn't matter.
Edit: I've looked into Bazel and... Good lord, i am speechless. Don't get me wrong if someone feels that's the right fit for their project more power to them ...
Yes, installing Bazel is not for the faint of heart. It also requires being pretty good in Python, since the make files use Python syntax and semantics. I think it makes a great tool for very large projects. For something that's 10 files and 1000 lines ... there is a german saying about "shooting at sparrows with cannons" (small bird, large gun). I'm also not sure how well Bazel interacts with outside software that is versioned in itself instead of using the "monorepo" development philosophy.
As you can see, there are many ways to skin the cat.