Apache Ant

Apache Ant is a software tool for automating software build processes which originated from the Apache Tomcat project in early 2000 as a replacement for the Make build tool of Unix. It is similar to Make, but is implemented using the Java language and requires the Java platform. Unlike Make, which uses the Makefile format, Ant uses XML to describe the code build process and its dependencies.
Released under an Apache License by the Apache Software Foundation, Ant is an open-source project.


Ant was conceived by James Duncan Davidson while preparing Sun Microsystems's reference JSP and Servlet engine, later Apache Tomcat, for release as open-source. A proprietary version of Make was used to build it on the Solaris platform, but in the open-source world, there was no way of controlling which platform was used to build Tomcat; so Ant was created as a simple platform-independent tool to build Tomcat from directives in an XML "build file". Ant was officially released as a stand-alone product on July 19, 2000.
Several proposals for an Ant version 2 have been made, such as AntEater by James Duncan Davidson, Myrmidon by Peter Donald and Mutant by Conor MacNeill, none of which were able to find large acceptance with the developer community.
At one time, Ant was the build tool used by most Java development projects. For example, most open source Java developers included build.xml files with their distribution. Because Ant made it trivial to integrate JUnit tests with the build process, Ant made it easy for willing developers to adopt test-driven development, and even extreme programming.


WOProject-Ant is just one of many examples of a task extension written for Ant. These extensions are installed by copying their .jar files into ant's lib directory. Once this is done, these task extensions can be invoked directly in the typical build.xml file. The WOProject extensions allow WebObjects developers to use ant in building their frameworks and apps, instead of using Apple's Xcode suite.
Antcontrib provides a collection of tasks such as conditional statements and operations on properties as well as other useful tasks.
Ant-contrib.unkrig.de implements tasks and types for networking, Swing user interfaces, JSON processing and other.
Other task extensions exist for Perforce,.NET Framework, EJB, and filesystem manipulations.


Below is listed a sample build.xml file for a simple Java "Hello, world" application. It defines four targets - clean, clobber, compile and jar, each of which has an associated description. The jar target lists the compile target as a dependency. This tells Ant that before it can start the jar target it must first complete the compile target.

Java source code to class files">

Jar file for the application">

Within each target are the actions that Ant must take to build that target; these are performed using built-in tasks. For example, to build the compile target Ant must first create a directory called classes and then invoke the Java compiler. Therefore, the tasks used are mkdir and javac. These perform a similar task to the command-line utilities of the same name.
Another task used in this example is named jar:

This Ant task has the same name as the common Java command-line utility, JAR, but is really a call to the Ant program's built-in JAR/ZIP file support. This detail is not relevant to most end users, who just get the JAR they wanted, with the files they asked for.
Many Ant tasks delegate their work to external programs, either native or Java. They use Ant's own and tasks to set up the command lines, and handle all the details of mapping from information in the build file to the program's arguments and interpreting the return value. Users can see which tasks do this, by trying to execute the task on a system without the underlying program on the path, or without a full Java Development Kit installed.


One of the primary aims of Ant was to be more portable than Make. In Make, the actions required to create a target are specified as platform-specific shell commands, whereas Ant provides a large amount of built-in functionality that is designed to behave the same on all platforms. For example, in the sample build.xml file above, the clean target deletes the classes directory and everything in it. In a Makefile this would typically be done with the command:
rm -rf classes/
rm is a Unix-specific command unavailable in some other environments. Microsoft Windows, for example, would use:
rmdir /S /Q classes
In an Ant build file the same goal would be accomplished using a built-in command:

Additionally, Ant does not differentiate between forward slash or backslash for directories and semicolon or colon for path separators. It converts each to the symbol appropriate to the platform on which it executes.


There exist third-party Ant extensions that provide much of the missing functionality. Also, the Eclipse integrated development environment can build and execute Ant scripts, while the NetBeans IDE uses Ant for its internal build system. As both these IDEs are very popular development platforms, they can simplify Ant use significantly.