A-A-P logo     



tools useful for A-A-P

The intention for A-A-P is to use existing tools as much as possible. To find out which tools can be used this overview has been compiled.
    Some tools cannot be used directly, but function as an example or can be invoked by A-A-P (e.g., commercial tools and programs which are not portable). Unless noted otherwise, tools are open-source.
    If you find a tool that would be useful for A-A-P but is not listed here, or when information is incorrect, send a message to Bram AT
    Note: this list is not intended to be complete. Information that is irrelevant for A-A-P is omitted.

Script languages       Build       Install       Issue Tracking       Version control       Browse       IDEs       Various


To create a program from sources it has to be compiled. And to be able to do that, it may need to be configured for a specific system. Several tools exist to do this automatically.

For A-A-P the intention is to be able to build a program on many different systems. There appear to be only a few existing tools that do this. The following list of existing tools can be used as examples, and also to fall back to a system-specific tool once the system has been determined.

For compiling many different compilers exist, these are not listed here. A list of configuration tools can be found here A nice article on configuring can be found here (SapCat was an entry to the Software Carpentry contest).

Another (shorter) list of build tools can be found at dmoz.

Note that the remarks about each tool here are incomplete and biased towards the goals for A-A-P. Your opinions may differ! Also note that some projects are in active development and this page is not regularly updated, thus some information may be outdated. Let me know when something needs to be updated!

The overview is roughly sorted: most interesting things first.

A tool that helps C++ programmers to generate their build files. It inspects the source code to find out how it should be build. This one is special in that it can generate an Aap recipe.
Still new. Aimed at beginning programmers.
FreeBSD ports
This might also be called an install tool, but since it's mostly about building from source, this is in the build tools list.
Will download files that are required. Handles dependencies between packages. Works very well.
Not portable: Uses BSD-specific Makefiles and several Unix tools.
Can be used as an example and as a fall-back system on FreeBSD. Need to check that A-A-P can do everything that FreeBSD ports can do.
Derived tools:
Like the FreeBSD ports system, used for Gentoo Linux. Uses bash shell scripts ("ebuild") and Python. Supports a sandbox for safe installation, multiple versions in parallel and package management.
A version is available. Looks interesting, but because of bash it's not portable.
Linux version of FreeBSD ports system.
A version is available. Appears inactive: no change since May 2001.
Gooey for FreeBSD ports system. Uses GTK+.
Only planned, nothing is available yet.
Linux port of FreeBSD ports system.
Not available yet.
Automatic configuration for C programs on Unix. Is based on shell scripts and the m4 macro language. Won't work on anything but Unix. Writing autoconf scripts can be very tricky. The syntax is awkward and it's easy to run into problems. But once it's done it works very well. What's missing is a good way to automatically extract required tests from source code.
The A-A-P configuration tool should be able to do all that autoconf can do, eventually. Until that happens, and for existing autoconf scripts, A-A-P should be able to handle projects with autoconf scripts in a nice way.
Related tools:
Generates files.
Hides the complexity of using shared libraries behind a consistent, portable interface.
Make-like tool in Python. Uses signatures instead of timestamps. Automatic dependency analysis. Support for parallel builds. Can use a central repository for source code or pre-built targets.
Uses Python for build scripts. Although Python is nice, it is a general-purpose language and not optimal for describing software builds.
Very interesting. Might be able to use some of the code.
Make-like tool. Implemented in Perl. Portable. Very similar to SCons, but using Perl instead of Python.
Make-like tool in Python. The file format is also Python. Supports C/C++ with gcc and nasm assembly.
Although it is at version 1.0 it looks like it has only started. Very few features, doesn't do much more than what can be done with plain Python.
Source 2 Binary
Make-like tool in Python, much like SCons but less advanced.
Only in the alpha stage.
Makefile generator. Input is an XML file, output is a Makefile for one of the many make variants. Can also do something with autoconf for Unix.
Used for WxWindows. Still in an early stage of development.
tmake and qmake
Portable makefile generation tool, by Trolltech. Free. Tmake converts a tmake project file to a Makefile. Qmake is a newer version and handles dependencies. Written in Perl. Does not appear to do automatic configuration. tmake can be downloaded, qmake is part of Qt 3.0.
Can very well be used as an example, since it's portable over many systems.
Make-like tool by Perforce. Free. Portable. Written in C. Uses its own interpreted language (a bit cryptic).
Can at least be used as an example. Possibly to start off with.
Make-like tool based on Boost.Jam, with ideas from Jam. Free. Portable. Written in C. Uses its own interpreted language.
Version "v1" is available. They are working on version "v2", apparently a complete rewrite. The jamfile specifies dependencies like in a Makefile, but with a slightly different syntax that makes it easier to write portable build scripts. There are several interesting items. Many things actually look similar to an A-A-P recipe.
make++ aka makepp
An improved version of GNU make. For Unix only. Can use signatures instead of time stamps. Supports using repositories.
Has a few nice ideas. Very interesting if A-A-P recipes are going to be compatible with make.
A make replacement with extra features. Can use fingerprints (signatures) instead of modification time. Can do parallel and remote builds. Includes a tool to determine dependencies in C files. Uses the terms "recipe" and "cookbook". Uses autoconf, for Unix only.
Cook has been around for a while, it contains a lot of good ideas. Its syntax is sane, but half LISPish half TCL feel.
A tool to generate "Makefile" from "Imakefile", including dependencies. Different versions available for several kinds of source code (C, Fortran, Modula 2). Implemented in Perl. Easier to use than imake.
A-A-P should should be able to do everything that makemake can do.
imake and xmkmf
A tool to generate "Makefile" from "Imakefile", including dependencies. xmkmf is a script that starts imake. Based on the C preprocessor. Part of the X window distribution. A bit complicated to use.
A-A-P should should be able to do everything that imake can do.
Generates makefiles. Written in Lisp. Part of Artefaktur Component Development Kit (ACDK). user-unfriendly documentation.
This is a special kind of build system: It defines configuration actions. But it's use is quite generic and includes defining dependencies.
Some of the ideas in cfengine can be useful for the A-A-P recipe, such as rules for making symbolic links and updating files from a remote source. But it is not a generic build tool, thus cannot be used as-is.
Autobundle/Autobuild/Daily Build System
Unix only, based on autoconf/automake. Autobundle is used to build packages from components. Autobuild for configuring and building software.
Does not appear to include things that are interesting for A-A-P.
Project build manager, uses python.
It's mentioned on sourceforge as being stable, but I can't find it anywhere.
Java based build tool, like make, but uses classes and XML. Portable over systems, but requires Java.
Writing a build file in XML file is clumsy. XML is nice for computers to parse and produce, not for humans. Flow control is even more clumsy, XML is not a scripting language.
Can be used for ideas how recipes work.
Related tools:
Automated build and test utilities. Builds upon Ant.
Good idea: automate building and testing as much as possible.
Rant - Remote Ant
Allows building on a remote system from an Ant script. Uses SOAP.
Improvement of ant with file-based targets and an easier-to-type scripting language.
Not available yet.
Generator for ant scripts.
Not available yet.
another anthill
Extension to the Apache-Ant project. Performs scheduled builds: Get latest version from version control system, increment build nr, build and store results. Implemented in Java.
Some ideas look interesting.
Integrated distribution of Ant that contains a preconfigured group of open source tools typically used with ant.
Doesn't look very interesting.
A collection of build utilities. Can be used together with Ant.
Currently appears to do nothing more than increasing the build number.
Ant for .Net and C#.
Make replacement written in Java. Portable, uses build-in commands instead of shell commands. File format still looks a bit like a Makefile.
Has a few interesting ideas, but invents its own language.
Uses the C preprocessor. Checks contents of files for changes. Nice paper about it here.
It's old, GNU make apparently replaces it.
Runs builds on a scheduler basis. Integrates with Rational clearcase et al. Written in Visual Basic. Runs on MS-Windows NT (at least).
Only interesting as an example for scheduled builds.
KDE program to configure/compile without a terminal. Uses Qt. Understands configure scripts.
Of limited use, can't do more than configure and make.
A shell script that allows or easy building from sources. Does the untar/configure/make things with a few mouse clicks.
Still in an early development stage. Depends on lots of other tools to do the actual work. Not portable since it's a shell script.
Easier way to manage projects through the use of GNU make. Calls itself "The superior Build System", but it's unclear why.
Unclear how useful this is.
Combination of make and Tcl. Good documentation.
Perhaps some ideas can be used for A-A-P.
Make replacement in Tcl. Good documentation.
Perhaps some ideas can be used for A-A-P.
Portable build script, written in Perl Works on MS-DOS, OS/2, Unix, et al. Uses its own build script language, which is rather limited.
The detection of compilers and system could be used for A-A-P.
Make replacement with quite a few good ideas. The user manual is well written. Uses its own build script language. Does not appear to be widely used, no web page. Written in C (without comments) and uses shell scripts, Unix only.
The ideas are interesting for A-A-P, but not the implementation.
Make replacement with quite a few good ideas. Originally for the Amoeba system. Uses its own build script language. Does not appear to be widely used, no web page. It's part of the Amoeba system, doesn't appear to be available separately.
The ideas are interesting for A-A-P, but not the implementation.
Build tool that attempts to minimize the effort required to build libraries, and binaries by managing OS, compiler, and environment portability issues for the developer.
Doesn't look very interesting.
Sire (previously Jake)
Replacement for Make. Uses a free format syntax which should be easier to use. Supports build scripts in stead of commands. Including Python. Implemented in C++.
Looks interesting.
A variation of make that has a few extra features. Written in C. Might not do more than GNU make.
Might be used for code snippets.
A variation of make that looks like a C program
Doesn't look useful.
GUI for GNU make. Uses GTK.
The makefile parser might be interesting.
PVM Gmake
GNU make with extensions for parallel building.
Documentation isn't very clear, looks like a hacker project.
Inspects C, C++ and Java sources for dependencies and generates a dependency file to be included in a makefile. There does not seem to be recent development.
Doesn't look very interesting.
PVM Gmake
Remote make facility.
Probably not useful for A-A-P.
Framework for building tools. Based on XML. Implemented in Python, C++, Java and Common Lisp. Currently mostly for extracting info from source files.
The front-ends to parse different languages might be interesting.
Framework for project building in Java, PHP, et al. Supports sharing data between a team over the internet. Still in an early development stage.
Perhaps some ideas can be used for A-A-P.
Nmake from Lucent
Not to be confused with MS nmake! Lucent is now called Alcatel-Lucent.
Features distributed and parallel execution, automatic dependency generation, language for flow control. Still uses shell commands. Compiles makefiles to minimize work (as if that were important...).
This is a commercial program. An open source fork can be found here: It's part of the ast-base package.
Opus make
An extended make program with all kinds of extra features.
This is a commercial program.
Make tool in Java.
Doesn't look very useful for A-A-P.
C++ program building without makefile.
Doesn't look very useful for A-A-P.
Console based build for C++/C programs. Aims to be compiler and platform independent.
Doesn't look very useful for A-A-P.
  The A-A-P pages:
Zimbu award
     Recipe examples
     Aap manual
     Agide tutorial
     Aap version log
     Agide version log
     ported apps
maillists and chat
plan and tasks
     SourceForge pages
     Aap todo list
     Agide todo list
     use cases
     design decisions
tools overview
     script languages
     build tools
     Install tools
     issue tracking
     version control
     browse tools
     various tools

Zimbu! - browse the Keyword Map of
funded by:


Send comments on this page to Webmaster AT            Hosted by SourceForge Logo            Also known as