I'm a big fan of Ninja: it applies the philosophy of "do one thing and do it well" to build systems. It takes in a dependency graph and a list of build rules, and it builds stuff in parallel.

Like Make, you can use it to build a lot of different kinds of things, and it doesn't care what programming language you're using.

Unlike Make, it doesn't give you its own idiosyncratic, messy, easily-misused programming language for defining your dependency graph. The dependency graph is just an input that comes from somewhere else. You can make it in a reasonable programming language, or apparently now you can make it out of a Makefile using Kati.

Because it's not trying to support decades of Makefile hacks, Ninja can do things that would be dangerous to do in Make, such as a single build step that reads M files and writes N files without any extra locking or bookkeeping.

I just saw an HN post about this: https://news.ycombinator.com/item?id=9854223

mk and Ninja (the target to which Kati compiles) appear to be almost equivalent to each other, except that mk has patterns ("here is how to compile any .c file into a .o file") and Ninja requires that each target be written explicitly ("here is how to compile foo.c into foo.o", once per file).

This is okay, because mk is meant to be written by humans and Ninja is meant to be a target for compilers like Kati and cmake.

Some people on bigger projects are tired of waiting for their builds and test results, so they wrote something better and faster. => ninja

On bigger projects waiting 60min or 10min or 2min makes a difference.

kati so far converts traditional makefile recipes into ninja builds.

Not sure this is the answer (I actually doubt it), but possibly because Make works poorly, and requires painful setup on Windows?