Open Source Build Systems in Java

Ant is a Java-based build tool. In theory, it is kind of like Make, without Make’s wrinkles and with the full portability of pure Java code.

Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project’s build, reporting and documentation from a central piece of information.

Maven’s primary goal is to allow a developer to comprehend the complete state of a development effort in the shortest period of time. In order to attain this goal there are several areas of concern that Maven attempts to deal with:

• Making the build process easy
• Providing a uniform build system
• Providing quality project information
• Providing guidelines for best practices development
• Allowing transparent migration to new features

Apache Buildr is a build system for Java-based applications, including support for Scala, Groovy and a growing number of JVM languages and tools. We wanted something that’s simple and intuitive to use, so we only need to tell it what to do, and it takes care of the rest. But also something we can easily extend for those one-off tasks, with a language that’s a joy to use. And of course, we wanted it to be fast, reliable and have outstanding dependency management.

Ivy is a free java based dependency manager, with powerful features such as transitive dependencies, ant integration, maven repository compatibility, continuous integration, html reports and many more.

Rant stands for Remote Ant. It is a distributed build system that allows an Ant build file to launch builds on other systems and receive exceptions should they occur.

GenJar is a specialized Ant task that builds jar files based on class dependencies rather than simply the contents of a directory.

ProtoJ is a pure java build, installation and deployment system that hands control over to you. Simply add the ProtoJ jar file to your project along with its dependencies and you are ready to take advantage of the full power of the ProtoJ domain objects. As a testament to the stability of the project, it actually uses its own code to build and test itself. That’s right, we eat our own dog food here! Not only that, Ant technology is used at the very heart of ProtoJ so you can rest assured that the nuts and bolts are rock solid.

Proximity (px-core) is a generic fetch-and-cache engine with various extra capabilities like indexing. The Px-Core module is driven by Maven bindings (px-core-maven) to implement a Maven Proxy application behaviour. Proximity is in function somewhere between http-proxy and proactive-mirror. Proximity is not HTTP Proxy. One of it’s primary use is as Java web application to serve as maven proxy on our company’s intranet. As for reducing outgoing traffic (caching central and other maven repos), aggregating more repositories (reducing project config) with acting as one logical repository and for publishing in-house and other external maven artifacts which are not uploadable to ibiblio (like commercial projects, J2EE Jars, etc...).

Easyant is a build system, that is based on Apache Ant and Apache Ivy.

Easyant goals are :

• to leverage popularity and flexibility of Ant.
• to integrate Apache Ivy, such that the build system combines a ready-to-use dependency manager.
• to simplify standard build types, such as building web applications, JARs etc, by providing ready to use builds.
• to provide conventions and guidelines.
• to make plugging-in of fresh functionalities easy as writing simple Ant scripts as Easyant plugins.

Invicta is an open-source build management tool. Using simple project definition files, it generates powerful build scripts (Apache ANT’s), while hiding their complexity.

Ant Hill is an Ant library meant to perform remote invocation of build targets via XMPP (Jabber) protocol. To be more specific Ant Hill provides a mechanism to implement Remote Target Invocation. The client / server approach allows to work on clusters and coordinate a large number of machines. Ant Hill has been written to be extensible, it is possible to define quickly new Remote Commands. Ant Hill provides error reporting through Remote Exception Propagation and several debugging features.

LuntBuild is a powerful build automation and management tool. Continuous integration or daily build can be easily setup through a clean web interface. Generated builds are well managed through functions such as search, categorization, promotion, patching, deletion, etc. It also acts as a central build artifacts download area for your whole team.

Schmant is a build tool for building software artifacts. It uses the scripting support in Java 6 for running build scripts, so build scripts can be written in any supported script language. Schmant provides a set of tasks for common build script tasks, such as compiling Java code, building JAR files, exporting code from Subversion repositories and performing text substitution in files. Schmant aims to be feature-compatible with and much easier to use than Apache Ant.

Savant is a build and dependency management tool written in Java. Savant can be used in two different ways:

• As a stand-alone build tool that wraps Apache Ant and provides a number of cool new features such as plugins that are versioned and downloadable
• As a set of tasks which can be used within Apache Ant build files

Savant is simple to setup and even simpler to use.

This application is based on the make utility which is part of most Unix systems, but is designed to support the task of writing platform independe

Antmod is a build management, release management, and repository management tool. Its implementation is an Ant-based extensible engine for retrieving, versioning, building, and deploying code to and from Subversion or CVS. It standardizes build files for Java projects and provides build plugins for various tasks. It also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects. It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.

JAM consists of a collection of Ant scripts designed to perform common Java/J2EE build tasks such as compilation, packaging, testing, deployment and J2EE application server control. JAM combines Maven’s high-level project description and repository features (via a Maven-to-Ant bridge) with the low-level capabilities of Ant. By assembling JAM modules, one is able to quickly create sophisticated IDE-independent build scripts. JAM supports various J2EE application servers, XDoclet invocation, JUnit unit testing, Apache Cactus integration testing, UML-based code generation and other technologies.

buildobjects is an object based general purpose build tool

buildobjects provides a number of java classes that allow you to code your build process in a truly object oriented fashion. It is not forcing you into a certain way of structuring your code and projects. Instead it aims at providing useful building blocks.

The rationale for using java was the availability of the full tool support to the build script. So when using buildobjects you get completetion, search for usage, and a fully featured debugger.

Bee is a Java-based build tool. Bee inherited some principles of Make. Bee provides more procedure languages constructions, so generally can be used for script programming. It’s highly extendable and base DTD can be easily changed, so it allows to create own dialects of Bee.

CPMake is a make utility written in Java to make anything (C, C++, Java, C#, XSL ...)
CPMake works similar to GNU make in that is uses rules and dependencies to build a project. CPMake uses Java scripting languages (BeanShell, Rhino, Jython and Groovy) for the build files to give increased flexability and the ability to customize the make file to your project.

CPMake Benefits:

• Make files work on any platform that supports Java.
• CPMake has built in dependency tracking for C/C++ and Java projects.
• Build files have access to all of the Java classes.
• Easy to debug build files.
• Multi threaded processing of build file.
• Cross platform paths. Use ‘\’ or ‘/’ Java doesn’t care.

Autojar helps creating jar files of minimal size from different inputs like own classes, external archives etc. It starts from one or more given classes (e.g., an applet), recursively searches the bytecode for references to other classes, extracts these classes from the input archives, and copies them to the output. The resulting archive will only contain the classes that are really needed. Thus one can keep size and loading time of applets low or make applications independent of installed libraries. In a similar way, autojar can search directories and archives for other resources (like image files), extract them and copy them to the output. Although autojar can’t know exactly which classes get loaded dynamically, it can search the bytecode for invocations of Class.forName() and warn about it. In some cases (constant class name), it can even find out which classes are to be loaded, and add them automatically to the output.

Jar Jar Links is a utility that makes it easy to repackage Java libraries and embed them into your own distribution. This is useful for two reasons:

• You can easily ship a single jar file with no external dependencies.
• You can avoid problems where your library depends on a specific version of a library, which may conflict with the dependencies of another library.

APB is a simple, yet powerfull, project build system that inherits some ideas from Ant and Maven while trying to avoid the use of complex XML files to define the metadata of the project. Project Definition is done in Java so you have the full power of Java plus the benefit of using your favorite IDE to edit the configuration files.

Here are some of the features APB provides out-of-the-box:

• Simple project definition based on default layouts, but with flexibility to accomodate your preferred one.
• Model based builds: APB is able to build projects based on metadata about the project.
• Full extensibility using Java
• Dependency management
• Full project lifecycle, including compilation, packaging and testing.
• Coverage support during testing
• Documentation generation
• Generation of project files for common IDEs (Currently Intellij Idea)
• Ant tasks to integrate APB projects into foreign contexts.
• Command line invocation including shell-completion