"I think that djb redo will turn out to be the Git of build systems."

Of course, I'm completely biased :) I have my own build system called fbuild (http://github.com/erickt/fbuild) that's conceptually similar to fabricate/memoize. There's also mem (http://srp.github.com/mem/getting-started.html) and wonderbuild (http://retropaganda.info/~bohan/work/sf/psycle/branches/boha... -- although that link appears to be broken at the moment) if you're interested in some other projects that have similar roots.

I believe the key insight that we all independently made is that we can use the procedural execution stack for the dependency tree, and cache the function arguments and results to avoid work duplication. I believe this helps someone reason about what's going on in the build system compared to the declarative make systems because you can easily trace the inputs and outputs of some dependency.

Furthermore, you can do some pretty interesting things with this model if you push this idea. It's pretty simple to do integrated configuration and building. For instance in fbuild, I can do (fbuild uses python3 for it's host language):

    import fbuild.builders.c
    import fbuild.config.c.linux

    def build(ctx):
        # make a c compiler.
        builder = fbuild.builders.c.guess_static(ctx)

        # check if the system supports epoll
        if fbuild.config.c.linux.sys_epoll_h(builder).header:
            use_epoll = True
        else:
            use_epoll = False

        builder.build_exe('foo', ['foo.c'],
            defines=['USE_EPOLL' if use_epoll else 'USE_SELECT'])

In fact, they have an example of using gcc to generate header-file dependencies for C. A command-line tool that ran a command and spat out what files it accessed (via strace, dynamic library imposition, or even crazier methods like interpreting the binary) would hook into this system fairly seamlessly.

Now, there is a third important property, which is clarity. But clarity for a new-comer is less important than a clarity for a person that uses build system daily.

I investigated several alternatives to make for our C++ game framework and settled to Waf. It's quite complex and side-effect of that has caused that we haven't integrated many of our tools to build system, just because doing so requires deep understanding of Waf model. Which I haven't acquired, well, mainly because of laziness.

Thus, clarity can affect both correctness and speed in practical situations of lazy people like myself.

What I like about redo is the simplicity. Based on my initial experiences, it seems that aside multiple output files problem, it doesn't get in to your way.

If nothing else, they should never be merged because they are trying to provide a POSIX utility, which should always be: "Do one thing and do it well"