What is Quokka?

Quokka is a software build system, focusing on reproducible, modular builds with fine-grained dependency management. Quokka is implemented using Java and initially focuses on supporting Java-based projects and tools.

For Java developers, quokka provides an Ant-based alternative to Maven. For Maven users, see the Side by Side Comparison for building a web application and the Quokka vs Maven Guide.

Key Features

Modular Builds
Build tasks such as compilation, or source code formatting are packaged into plugins. Each project can be tailored to include specific plugins as required.

Build configurations (including plugins, dependencies and other resources) can be bundled into a dependency set for re-use amongst projects. For example, a dependency set could be defined to add Checksytle processing to your project, along with your tailored checkstyle configuration file. Projects can include any number of such dependency sets, and sets may nest other sets within them, providing varying degrees of reuse.
Fine-grained Dependency Management
Quokka allows any number of paths of dependencies to be defined for use within a project. Selected paths can also be exported to the repository for reuse within other projects. If your project depends on another project, quokka can automatically include dependencies of your dependencies recursively. In such cases you have full control down to any level as to which dependencies are included using Path Specifications.
Quokka projects can be extended using plugins, as well as ad hoc targets using standard Ant files or scripts via the Scripting plugin. The plugin architecture allows plugins to interact with one another. For example, the life cycle plugin defines an abstract test target which is implemented by both the jUnit and TestNG plugins - you just pick the implementation for your project. Furthermore, explicit SPIs have been defined to extend quokka programatically, including the Plugin and Repository SPIs.
Reproducible Builds
Quokka combines several features to make builds reproducible. Reproducible means that if a given revision of your project built with quokka in the past, it should be possible to build it today with exactly the same result. The following features make this possible:
  • Bootstrapping: A project can be configured to use a specific version of quokka and jvm. Quokka will then fork the required environment automatically (see Bootstrapping)
  • Versioned global repository: Once an artifact, such as a .jar, is stored in the global repository, it and any metadata associated with it can never change. If corrections are required, they will be stored as a separate revision. This guarantees a reference to a given dependency will not change over time.
  • Project repository: For even greater safety, some or all artifacts can be stored with the project in version control in a local project repository.
  • Plugins do not automatically upgrade themselves: Unlike Maven, quokka plugins do not automatically upgrade themselves. You must specify the version of a plugin to use and it remains constant. Likewise, snapshots never upgrade themselves automatically.
  • Release plugin: The Release plugin provides additional checks upon releasing and tagging your code, including ensuring that bootstrapping is configured and there are no snapshot dependencies.

Additional Features

  • Profiles: Profiles can be used to enable certain features, or change configurations for a given project. Profiles might include "dev" and "prod" for configuring a .war file for development and production environments respectively. There are also automatic profiles based on the JDK version and operating system.
  • IDE integration: Quokka is implemented as a transparent extension to ANT. There have been no modifications to ANT at all to implement quokka. As such, existing IDE integration for ANT works with quokka by default (or can be configured to do so). See IDE Integration
  • Extensions: A wide range of extensions are available for quokka already, with the list growing rapidly. See the extensions page for more information on available plugins, archetypes and XML catalogues.

Where to next?

Check out the Getting Started guide for information on installing and running quokka for the first time.


Oct 14

Quokka 0.3 Released This release is considered to be virtually feature complete. Work will now focus on expanding the range of plugins available and bug fixes. Major changes is this release include:

  • Rewrote override and conflict handling. Overrides can now be applied to particular paths or path specifications.
  • Refactored repositories: added override support, extended shorthand notation, added support for snapshot updates, added 'paths' type, added exclusion support, moved path resolution into a separate module. Added core repository configured to the installation lib directory.
  • Added property support within quokka build files
  • Added a side by side comparison guide to Maven
  • Defined the process for uploading artifacts to the global repository
  • Added Maven plugin: currently supports importing artifacts from maven repositories.
  • Added JEE plugin: currently supports packaging of war files.
  • Added Jetty plugin: supports running of web applications via an embedded Jetty server instance.
  • Added JavaCC plugin: generates parsers from grammar files.
  • Added Scripting plugin: allows ad hoc targets to be written in variety of scripting languages.
  • Added Source plugin: allows bundling of source code and installation in the repository.
  • Added war archetype: archetype for building web applications.
  • Improved bootstrapping: Allow any jvm-args to be specified, allow bootstrapping options to be defined in a separate file
  • Enhanced profiles: Added logical expressions for selecting profiles and automatic profiles for operating systems.
  • Improved help: better plugin help, added help for ids and targets
  • Improved usability by reducing the namespace size for quokka properties and targets
  • Improved archetypes: Allow the artifact to be downloaded from a given repository
  • Improved Javadoc plugin: Added it as a proper developer report and added aggregation
  • Added console mode to reduce startup overhead
  • Improved test coverage for key code paths and validated project, repository and plugin dtds
  • Improved XML serialisation for XML generated by quokka plugins
  • Fixed eol & mime types for source files
Sep 1

Quokka 0.2 Released This release was internal only and not released to the public

Jan 30

Quokka 0.1 Released The initial release is now available from the downloads page for early adopters.