Make++ (or makepp) is a drop-in replacement for GNU make which has a number of features that guarantee more reliable builds and allow simpler build files. It supports almost all of the syntax that GNU make supports, and can be used with makefiles produced by utilities such as automake. And you can embed perl code in your makefile, you can write make functions in perl, and you can write include file scanners and other extensions to makepp in perl. makepp at present works only on Unix systems, since it currently depends on fork() and Unix filename and directory conventions. Suggestions for porting and code contributions are welcome. makepp is written entirely in perl. It requires version 5.005 of perl or better. It's distributed under the terms of the perl Artistic License. For the latest distribution, manual pages, and information about mailing lists, please see the makepp home page, http://LNC.usc.edu/~holt/makepp. Makepp is also available from CPAN in the directory $CPAN/authors/id/H/HO/HOLT/. Features: o Makepp supports almost all makefile syntax that GNU make supports. Makepp is compatible enough with GNU make and stable enough to compile large packages, such as KDE 2.0. (For details, see the manual section on old makefiles). o Makepp automatically scans C/C++ sources for include files. The implementation is flexible enough that support for other languages can be easily added by writing a perl function. o Makepp remembers the build command, and rebuilds if the command has changed, even if none of the files have changed. This is useful if you change command line options (e.g., adding -DDEBUG or -g)--you don't have to do "make clean". o By default, makepp rebuilds if any dependency files have changed (even if they are still older than the target). For example, if you replace a file with an older version, makepp knows to recompile. This also means that makepp is not bothered by clock synchronization problems. (If necessary, you can tell it to recompile only if the target is older than a dependency.) o Makepp has a better system for handling makefiles spread across several directories. makepp loads several makefiles simultaneously (keeping the variables and default directories separate), and it will realize automatically that a file needed by one makefile is built by a different makefile. Recursive invocations of make are no longer necessary (but are still supported for backward compatibility). o Makepp won't mix output from separate processes when running compilation commands in parallel. o Makepp writes a log file explaining all of its build decisions, showing what each file depended on and what changed to cause each rule to be executed. This makes debugging your makefiles much easier. o Wildcards refer not only to files which already exist but also to files which don't exist yet but which can be made. Thus you can specify libmine.so: *.o and the compilation will work properly even if none of the .o files exist yet. o You can tell makepp not to recompile if only comments or whitespace in C/C++ sources have changed. This is especially important for header files which are automatically generated by other programs and are included in many modules. Even if the date has changed because the file was remade, makepp won't recompile if the file (excluding comments) hasn't changed. o Makepp can automatically separate your source and object directories, even if your makefile is not written that way. (This is like VPATH but is completely transparent, even for include files.) Makepp can also build separate copies of your program with different compilation options or on different architectures, automatically keeping the output files separate--you don't have to modify your makefiles at all. o You can ask makepp to infer what object files are necessary for your program if your source files follow the simple convention that the implementation of all the classes and functions in a .h file is contained in a .cxx, .cc, .C, or .cpp file of the same name. This can often avoid the use of .a files. o Makepp won't be confused by multiple names for the same file. It realizes that xyz.o, ./xyz.o, and ../objects/xyz.o are the same file, and if you load a makefile in a subdirectory, it will recognize that references in that subdirectory to ../xyz.o refer to the same file as xyz.o in the main build directory. It also won't be confused by soft links in directory names. o Makepp supports filenames with special characters like space or ":". Just put any filenames with special characters in single or double quotes. o Makepp supports more easily understood synonymns for the cryptic symbols $@, $<, $^, etc. o You can define your own text processing functions in perl if the default ones are not sophisticated or convenient enough. You can also embed perl code to manipulate the make variables directly in your makefile. What's the difference between makepp and the Make module (and the associated pmake program)? The key difference, and the reason I could not simply extend the existing Make module, is that makepp uses completely different algorithms and data structures internally. The main reason for writing makepp was to simplify builds that use several different makefiles, and combining rules from different makefiles into a single make process required a very different internal architecture. For a discussion of this and the other internal differences, see the section in the manual on this at http://LNC.usc.edu/~holt/makepp/build_algorithm.html. In addition to this difference, makepp has a lot more features than pmake and the make module, many of which are feasible only because of the differences in data structures and algorithms. Makepp also emulates GNU make much more precisely because it is better developed. Why not cons? cook? bake? icmake? jam? These are good make utilities too, with some of the same features, especially those relating to reliable builds. I wrote makepp because (at the time) cons wasn't flexible enough. makepp is likely to work with existing makefiles, because it tries hard to emulate all the features of the standard make implementations while nonetheless being safer. It has been tested successfully on several large systems of makefiles, including large projects controlled by autoconf and automake. And you don't have to learn any new syntax or write any new files to use makepp; you can probably use your old makefiles (with possibly only minor modifications). On the other hand, you can take advantage of makepp's additional features to simply your makefiles.