JVM Build Tools: Ant, Maven & Gradle

This content was generated with the assistance of AI and should be verified against the official documentation before being relied on in production.

The reference material consulted while preparing these pages is listed in the section bibliography.

This section is a reference for the three build tools of the Java Virtual Machine world: Apache Ant, Apache Maven and Gradle. Build automation is the practice of describing how source code becomes a tested, packaged and published artifact once, in a file the tool can run, so that every developer and every CI server builds the same way. Dependency management is the companion practice of naming the libraries a project needs by coordinates, resolving them (and everything they need) from repositories, choosing one version when several are requested, and publishing the project’s own artifacts for others to consume. Ant describes the build as a graph of targets made of tasks, Maven as a fixed lifecycle of phases that plugin goals attach to, and Gradle as a graph of tasks that plugins and build scripts add and wire up. The pages here cover each tool from its first command to its extension points, and a set of shared pages put the three side by side.

The three tools

Tool What it is Build model Configuration files Current version and Java needed to run

Apache Ant

An XML-driven build tool and a Java library of tasks, born in 2000 (first stand-alone release 1.1 on 19 July 2000). It has no built-in conventions and no dependency management of its own.

Imperative: named targets that depend on each other, each made of tasks, run in dependency order.

build.xml (plus imported files and build.properties); dependencies through Apache Ivy (ivy.xml, ivysettings.xml) or the Maven Resolver Ant Tasks.

Ant 1.10.18 (6 September 2026), Ivy 2.6.0, Resolver Ant Tasks 2.0.0. Java 8 or later.

Apache Maven

A declarative build and project-management tool: a project object model, a standard directory layout, a fixed lifecycle and a repository system with coordinates.

Declarative: the POM describes the project, the lifecycle phases are bound to plugin goals by the packaging, and convention supplies the rest.

pom.xml, settings.xml, and the .mvn directory (maven.config, jvm.config, extensions.xml).

Maven 3.10.0 and the previous series' 3.9.16 (Java 8 or later); Maven 4.0.0-rc-7 is a release candidate (Java 17).

Gradle

A build tool with a programmable task graph, a rich plugin ecosystem, incremental builds, a build cache and variant-aware dependency management.

Programmable: build scripts in the Kotlin or Groovy DSL configure plugins, which register tasks that Gradle wires into a graph and runs only when their inputs or outputs changed.

settings.gradle.kts and build.gradle.kts (or the .gradle Groovy forms), gradle.properties, gradle/libs.versions.toml, and the wrapper files in gradle/wrapper.

Gradle 9.8.1 (and 8.14.6, the last 8.x release). A JVM from 17 to 27 to run it.

Each tool has its own landing page with the details: Apache Ant, Apache Maven and Gradle. How they differ, and when to use which, is the topic of Comparing Ant, Maven & Gradle; the shared ideas (build graphs, conventions, caching) are in Build Automation Fundamentals and Dependency Management Fundamentals.

Release baseline

This section documents Apache Ant 1.10.18 (released on 6 September 2026) with Apache Ivy 2.6.0 (July 2026) and the Maven Resolver Ant Tasks 2.0.0 (August 2026) for dependencies, Apache Maven 3.10.0 (September 2026) with 3.9.16 as the previous stable minor line, and Gradle 9.8.1 with 8.14.6 as the last 8.x release, all checked on 2026-10-16. Maven 4.0.0-rc-7 is a release candidate: the download page still labels it a preview and no 4.0.0 release exists, so the Maven 4 pages say so and every Maven 4 feature is described against the release candidate. Unreleased work (an Ant 1.10.19 section in the Ant change log, Gradle 9.9 milestones) is not documented. Every page states what differs on the other maintained lines of its tool and how the tool’s support policy treats older releases. The examples were run on JDK 26 on macOS, using the tool releases named above, and the output shown on a page is the real output of the run; examples that could not be run (for instance publishing to the real Maven Central, which needs credentials) are labelled "not run here" on their page. The tool-by-tool release tables are on Ant: Versions & Release History, Maven: Versions & Release History and Gradle: Versions, Compatibility & Release History.

The tidepool scenario

The examples share one small, original project: tidepool, a toolkit that predicts tide heights for coastal stations from harmonic constituents. The same project is built with all three tools, so a page can show the same task in each of them and the pages build on one another. It has three modules:

  • tidepool-model, a library with the Java records Station, Constituent and TideEvent and the value type Height.

  • tidepool-engine, a library that depends on tidepool-model and on Apache Commons CSV to read the sample file data/stations.csv; it shows api versus implementation in Gradle, compile versus runtime scope in Maven and Ivy configurations.

  • tidepool-cli, an application with a main class that uses picocli (an annotation processor, which exercises processor paths in all three tools); it is packaged as an executable JAR, an uber JAR and a distribution archive.

Around the modules the scenario adds unit tests in each module with JUnit Jupiter, an integration test of the command line program against data/stations.csv, shared build logic (an Ant common.xml imported by each module, a Maven parent POM and bill of materials, a Gradle convention plugin in build-logic), one custom build extension written once per tool (the Ant task checkstations, the Maven plugin goal tidepool:check-stations and the Gradle plugin tidepool.station-check, each validating the stations file), and publishing to a local file repository under build/repo or to a repository on localhost. A page whose concept fits the scenario poorly uses a minimal standalone example instead (for instance Ant selectors or Maven archetypes). No example uses a real credential or a real remote server.

How the books were used

Three books were consulted as references for concept coverage and structure: Erik Hatcher and Steve Loughran’s Java Development with Ant (Manning, 2002), written for Ant 1.5; Maria Odea Ching and Brett Porter’s Apache Maven 2 Effective Implementation (Packt, 2009), written for Maven 2.2; and Benjamin Muschko’s Gradle in Action (Manning, 2014), written for Gradle 1.7. None of them is the source of any example: every example is written against the current official documentation, the official documentation wins wherever they differ, and no text, code listing or figure is copied from a book. Each page states in prose where the books are outdated for the concepts it touches. The headline items are these.

  • Ant: Ant 1.10 needs Java 8 or later; import, include, macrodef and antlibs (Ant 1.6 and later) replace antcall-heavy builds and most of Ant-Contrib; JUnit 5 and later need junitlauncher; javah, rmic and apt no longer work; the Nashorn engine is gone from the JDK; XDoclet, Cactus, Axis 1, CruiseControl and Tomcat 4 deployment are obsolete; and the book has no dependency management, which today means Ivy or the Maven Resolver Ant Tasks.

  • Maven: Maven 2 reached end of life in 2014; Continuum and Archiva are retired Apache projects; plugin versions must be pinned; plain HTTP repositories have been blocked since Maven 3.8.1; EMMA and Cobertura are replaced by JaCoCo, FindBugs by SpotBugs and Clirr by japicmp or Revapi; OSSRH was shut down on 30 June 2025 in favour of the Central Portal; and Maven 4 brings the consumer POM and model version 4.1.0.

  • Gradle: the << task definition and the compile, runtime and testCompile configurations were removed, as were the maven plugin with uploadArchives and the jetty plugin; apply plugin: gave way to the plugins block, the Kotlin DSL is the default of gradle init, version catalogs and convention plugins replaced ad-hoc versions and allprojects blocks; the book has no toolchains, build cache, configuration cache or test suites; and JCenter and Bintray are gone.

The collected legacy-to-modern replacements are on Ant: Deprecations & Migration, Maven: Versions & Release History and Upgrading Gradle. The books are cited only through their publishers' pages in the bibliography.

New here? Read in this order

The pages can be read in any order; these paths are the suggested ones.

If you have never used a build tool

  1. Build Automation Fundamentals — what a build is and the ideas all three tools share.

  2. Dependency Management Fundamentals — coordinates, transitive dependencies and conflicts.

  3. Comparing Ant, Maven & Gradle — the three tools side by side, and how to choose.

  4. The getting-started page of the tool you picked (the Maven, Gradle or Ant paths below).

Choosing a tool

  1. Comparing Ant, Maven & Gradle — the comparison table, the same project built three times, and the verdict.

  2. Build Automation Fundamentals — the build graph, conventions and caching behind the differences.

  3. Repositories & Publishing Across Tools — what you need to publish and consume binaries with each tool.

  4. CI & IDE Integration — running each tool on a CI server and in an IDE.

Apache Ant

  1. Apache Ant — what Ant is and when it still fits.

  2. Installation and Running Ant.

  3. Build File Structure and Targets & Extension Points.

  4. Properties and Paths, Filesets & Patterns.

  5. Compiling Java, Testing with JUnit & junitlauncher and Packaging Archives.

  6. Ivy Overview and Maven Resolver Ant Tasks — dependencies for Ant.

  7. Multi-File Builds: import, include & subant and Macros & Presets.

  8. Deprecations & Migration — what an old Ant build needs updating.

Apache Maven

  1. Apache Maven — what Maven is and the support policy.

  2. Philosophy, Coordinates & Directory Layout, then Installation and Getting Started.

  3. POM Fundamentals and Build Lifecycle.

  4. Plugins & Their Configuration.

  5. Dependencies, Scopes & Mediation and Dependency Management & BOMs.

  6. Multi-Module Builds & the Reactor.

  7. Testing with Surefire and Packaging JARs, WARs & Manifests.

  8. Publishing to Maven Central and Releasing.

  9. Maven 4: What’s New and Migrating to Maven 4 — the release candidate.

Gradle

  1. Gradle — what Gradle is and the versions at a glance.

  2. Core Concepts and Installation, then Gradle Wrapper.

  3. Command-Line Interface and Build Lifecycle.

  4. Settings & Build Scripts and Kotlin DSL.

  5. Tasks and Java Projects.

  6. Declaring Dependencies & Configurations and Version Catalogs.

  7. Multi Project Builds and Convention Plugins & Sharing Build Logic.

  8. Testing JVM Projects and Publishing.

  9. Incremental Build, Build Cache and Configuration Cache & Isolated Projects.

Migrating an existing build

  1. Migrating Between Tools — Ant to Maven, Ant to Gradle, Maven to Gradle and Ivy to the Resolver Ant Tasks.

  2. Ant: Deprecations & Migration for an Ant build that must keep running on a current JDK.

  3. Migrating from Maven to Gradle and Gradle Ant Integration.

  4. Migrating to Maven 4 and Upgrading Gradle for moving to a newer release of the same tool.

Publishing and securing a build

  1. Repositories & Publishing Across Tools.

  2. Supply Chain Security.

  3. Ecosystem & Learning Resources and Cheat Sheet for quick lookup.

mindmap root((JVM Build Tools)) Shared pages Build automation fundamentals Dependency management fundamentals Repositories and publishing Comparing the three tools Migrating between tools Supply chain security CI and IDE integration Apache Ant Targets and tasks Properties and filesets Compile test package Macros import and antlibs Custom tasks and scripting Ivy and Resolver Ant Tasks Apache Maven POM and coordinates Lifecycle and plugins Dependencies and BOMs Multi module reactor Testing and packaging Central and releasing Maven 4 release candidate Gradle Settings and build scripts Tasks and lazy model Plugins and convention plugins Dependency resolution and catalogs Incremental build and caches Publishing and toolchains Ecosystem Learning resources Cheat sheet Bibliography

What’s covered

Shared pages

  • Build Automation Fundamentals — Why builds are automated and what every JVM build tool has in common — on-demand, triggered and scheduled builds, the build graph as Ant targets, Maven phases and goals and Gradle tasks.

  • Dependency Management Fundamentals — How Ant with Ivy and the Maven Resolver Ant Tasks, Maven 3.10 and Gradle 9.8 name, find, mediate and pin dependencies — coordinates, direct and transitive dependencies, scopes versus configurations.

  • Repositories & Publishing Across Tools — What Ant, Maven and Gradle share when they publish and consume binaries — the Maven repository layout, maven-metadata.xml, checksums and signatures.

  • Comparing Ant, Maven & Gradle — Apache Ant 1.10.18 with Ivy 2.6.0, Apache Maven 3.10.0 and Gradle 9.8.1 compared side by side — the three build models (imperative targets, declarative lifecycle, programmable task graph).

  • Migrating Between Tools — How to move a JVM build between Apache Ant, Apache Maven and Gradle without breaking it — Ant to Maven (directory layout, dependencies, maven-antrun-plugin as a bridge).

  • Supply Chain Security — Supply-chain security for Ant, Maven and Gradle builds — the trust model of a build file, verifying tool distributions and wrappers (SHA-512, SHA-256, PGP, wrapper validation).

  • CI & IDE Integration — Run Ant, Maven and Gradle builds headless on a CI server and from an IDE: non-interactive flags, exit codes and XML reports, dependency and configuration caching.

Apache Ant

  • Apache Ant — Ant in one page: what it is, when to use it today, how Ivy and the Maven Resolver Ant Tasks add dependency management, the versions at a glance and the Ant reading path.

Getting started

  • Versions & Release History — Apache Ant release lines 1.6 to 1.10.18 with dates and the changes that matter, the Java version each line needs at run time, how newer JDKs removed features Ant had to follow, the security advisories.

  • Installation — Installing Apache Ant 1.10.18: system requirements, downloading and verifying the binary archive (SHA-512, PGP, SBOM), the directory layout, JAVA_HOME, ANT_HOME and PATH, configuration files.

  • Running Ant — The Ant 1.10.18 command line, option by option — ant [options] [target …​], build file selection with -f and -find, properties with -D and -propertyfile, logging levels, logfiles.

The build file

  • Build File Structure — How an Apache Ant 1.10.18 build file is put together — the project element and its name, default and basedir attributes, description, targets and tasks, attributes and nested elements.

  • Targets & Extension Points — Apache Ant 1.10.18 targets in depth — depends and the resolution order, each target running once per dependency chain, if and unless on targets, description and ant -p, the default target.

  • Properties — How Apache Ant properties work — immutability and first definition wins, command-line precedence, property expansion and dollar escaping, the property task and all its attributes, built-in properties.

  • Paths, Filesets & Patterns — How Apache Ant 1.10.18 describes sets of files and class paths — path-like structures, pathelement, pathconvert, manifestclasspath, includeantruntime and build.sysclasspath.

  • Selectors — Ant selectors — choosing the files of a fileset by content, date, size, depth, name, comparison with another tree, cache, ownership and permissions; the container selectors and, or, not.

  • Resource Collections — Ant resources and resource collections — the resource abstraction of Ant 1.7 (file, javaresource, javaconstant, zipentry, tarentry, compressed resources, url, string, propertyresource).

Datatypes and core tasks

  • Filters & Mappers — Apache Ant 1.10.18 filtersets and @token@ replacement, the filter task.

  • Conditions & Control Flow — Apache Ant 1.10.18 conditions and control flow — the condition task and every core condition (not, and, or, xor, available, uptodate, os, equals, isset, checksum, http, socket, filesmatch, matches, javaversion, antversion and more).

  • Compiling Java — Compiling Java with Apache Ant 1.10.18 — the javac task attribute by attribute (srcdir, destdir, release versus source and target, includeantruntime, debug, encoding, compiler values including modern and javac10+, fork, modulepath, modulesourcepath, nativeheaderdir, compilerarg and annotation processors).

  • Packaging Archives — Packaging with Apache Ant 1.10.18 — the jar task (manifest, service, indexjars, multi-release JARs), the manifest and manifestclasspath tasks, runnable and uber JARs, war and ear.

  • File Operations — Ant’s file tasks in detail — copy with filtering, encodings and mappers, move, delete and its default-excludes trap, mkdir, sync, touch, concat, fixcrlf, replace, replaceregexp, tempfile, truncate.

  • Running Programs — How an Ant build runs Java and native programs — the java task with classname, jar, module and sourcefile, fork, spawn, clonevm, jvmarg, sysproperty, timeout, failonerror and assertions.

  • Testing with JUnit & junitlauncher — Running unit tests from Apache Ant 1.10.18 — the junitlauncher task for JUnit 5 and 6 (required jars, the recommended ANT_HOME/lib setup, test and testclasses, listeners and the legacy-xml format, includeTags and excludeTags, includeEngines, fork and forkMode, haltOnFailure and failureProperty).

  • Documentation & XML — Generate API documentation and process XML with Apache Ant 1.10.18: the javadoc task (packages, modules, groups, custom tags, failonwarning and its single-digit warning-count bug), xslt, xmlvalidate.

  • Network & Remote Tasks — Download files, talk to FTP, SSH, SMTP and SQL servers from an Apache Ant 1.10.18 build: get (usetimestamp, retries, authenticateOnRedirect), setproxy, sshexec, scp, sshsession, ftp, mail and sql.

  • Utility Tasks — The small Apache Ant 1.10.18 tasks every build file uses: echo and log levels, input and input handlers (and what -noinput really does), record, tstamp with reproducible dates, checksum, buildnumber.

Structuring and extending builds

  • Multi-File Builds: import, include & subant — How to split an Apache Ant build over several files — import and include (target overriding, prefixes, ant.file.project properties, optional, as).

  • Macros & Presets — Reusable build logic inside one Apache Ant project — macrodef with attribute, element, text, implicit elements, the at-brace expansion versus the dollar-brace expansion and doubleexpanding, backtrace.

  • Scripting — Scripting inside Apache Ant 1.10.18 build files — the script task, scriptdef, scriptcondition, scriptselector, scriptfilter and scriptmapper, BSF versus JSR 223 and the manager attribute.

  • Listeners, Loggers & Input Handlers — How Apache Ant reports what a build does and asks the user questions — build events, BuildListener versus BuildLogger, the -listener -logger -logfile -emacs and -inputhandler switches.

  • Writing Custom Tasks — Writing your own task for Apache Ant 1.10.18 — a Java class that extends Task, attribute setters and type conversion, nested text and nested elements (create, add and addConfigured), filesets.

  • Custom Types, Conditions & Selectors — Extending Apache Ant with your own datatypes — typedef and componentdef with every attribute, custom conditions, selectors in their three styles, container selectors, resource collections, mappers.

  • Antlibs & Namespaces — Antlibs and XML namespaces in Apache Ant 1.10.18 — how core, optional and third-party tasks reach a build file, the antlib.xml descriptor, antlib: namespace URIs and ant:current.

  • Embedding Ant — Running Apache Ant 1.10.18 from Java code — Project, ProjectHelper.configureProject, executeTarget, DefaultLogger and BuildListener, using a single task without a build file, Main.startAnt.

Dependency management for Ant

  • Ivy Overview — What Apache Ivy 2.6.0 is, its status and release history, the terminology (organisation, module, revision, configuration), the configure-resolve-retrieve-report-publish cycle.

  • Ivy: Module Descriptors & Configurations — The Ivy module descriptor ivy.xml in depth: info and extends, configurations (visibility, extends, transitive, defaultconf, defaultconfmapping, confmappingoverride, include), publications.

  • Ivy: Settings & Resolvers — The Apache Ivy 2.6.0 settings file in depth: ivysettings.xml, variables and properties, include, caches and TTL, lock strategies, credentials.

  • Ivy: Conflicts & Versions — How Apache Ivy 2.6.0 decides which revision wins: the conflict managers (latest-revision, latest-time, latest-compatible, strict, all and the new nearest), force, override and exclude.

  • Ivy Ant Tasks — The Apache Ivy 2.6.0 Ant tasks one by one — settings and configure, resolve (log levels, inline mode, nested dependencies, failures, concurrency), retrieve (patterns, sync, type, mappers), cachepath.

  • Ivy: Publishing & Multi-Project Builds — Publishing modules with Apache Ivy 2.6.0 and building several of them in order — deliver and publish to a file repository, build numbers, buildlist with subant, inter-project dependencies.

  • Maven Resolver Ant Tasks — The Maven Resolver Ant Tasks 2.0.0 for Apache Ant 1.10.18 — the uber JAR and the antlib namespace, resolve, install, deploy, pom, createPom, dependencies, remote and local repositories, mirrors.

Practice

  • Deprecations & Migration — What Apache Ant 1.10.18 deprecated, removed or made impossible on newer JDKs — the Ant 1.9 to 1.10 upgrade guide, deprecated tasks and their replacements, javah, rmic, apt, image.

Apache Maven

  • Apache Maven — Maven in one page: what it is and is not, the support policy, the status of Maven 4, the Java needed per release line and the Maven reading path.

Getting started

  • Versions & Release History — Apache Maven release lines from 1.0 to 4.0.0-rc-7 with dates and the changes that matter, the Java version each line needs to run, the support policy and end-of-life lines.

  • Philosophy, Coordinates & Directory Layout — What Maven is for and what it deliberately is not, convention over configuration and the super POM, the standard directory layout and the target directory.

  • Installation — Installing Apache Maven 3.10.0: the JDK prerequisite, downloading and verifying the binary archive (SHA-512 and PGP signature), the distribution layout, PATH and mvn -v, JAVA_HOME and .mavenrc.

  • Getting Started — A first Maven project from start to finish on Maven 3.10.0 and JDK 26: generating my-app with archetype:generate and maven-archetype-quickstart, reading the generated POM, mvn compile, test.

  • Running Maven (CLI) — The Apache Maven command line — the mvn synopsis, phases versus goals versus plugin:version:goal, output control (-B, -q, -e, -X, -V, -l, -ntp, colour), system properties and profiles (-D, -P).

  • Configuring Maven — Configuring Apache Maven itself rather than a project: MAVEN_OPTS, MAVEN_ARGS, mavenrc files, the .mvn directory (maven.config, jvm.config, extensions.xml).

The POM, lifecycle and plugins

  • POM Fundamentals — What a Maven POM is, the minimal POM and what Maven fills in around it, the elements under project, coordinates and packaging (finalName), properties and their precedence, project model variables.

  • Inheritance, Aggregation & the Effective POM — How Apache Maven POMs relate to each other — the parent element and relativePath, the Super POM and its changes in Maven 3.10, what a child inherits and what it does not, URL path appending.

  • Build Lifecycle — The Apache Maven build lifecycles — the clean, default and site lifecycles and every phase, how phases bind to plugin goals.

  • Plugins & Their Configuration — How Apache Maven plugins work and how to configure them — build and reporting plugins, reading plugin help with the help goal, configuring simple values, complex objects, lists, maps and properties.

Dependency management

  • Dependencies, Scopes & Mediation — How Maven declares and resolves dependencies — the dependency element, the six scopes (compile, provided, runtime, test, system, import) and the scope transitivity table, transitive dependencies.

  • Dependency Management & BOMs — How Maven centralises dependency versions, scopes and exclusions with dependencyManagement, how a managed version beats mediation for transitive dependencies.

  • Versions, SNAPSHOTs & Ranges — How Apache Maven treats versions — release and SNAPSHOT versions, timestamped snapshots and the baseVersion, the version-level and artifact-level repository metadata.

  • Dependency Analysis & Convergence — How to inspect, audit and police a Maven dependency graph — dependency:tree with -Dverbose, -Dincludes and output formats, dependency:analyze and analyze-only, analyze-dep-mgt.

  • Installing Third-Party JARs & Relocation — How to get a JAR that is not on Maven Central into a Maven build — install:install-file into the local repository or a project-local repository.

Repositories, settings and profiles

  • Repositories, Mirrors & Repository Managers — Where Maven gets and keeps artifacts — the local repository and its _remote.repositories records, remote repositories and Central, repository order and ids, offline builds and cached failures.

  • settings.xml & Password Encryption — The Maven settings.xml file in full: user, installation and project (Maven 4) locations, localRepository, offline, pluginGroups, servers with aliases and repositoryOrigins, mirrors, proxies.

  • Profiles — How Apache Maven build profiles work — where profiles live (pom.xml and settings.xml), what a profile may change.

Multi-module builds

  • Multi-Module Builds & the Reactor — How Apache Maven builds several projects in one command — the reactor and its collect, sort, select and build steps, the sorting rules and cycle detection, selecting projects with -pl, -am, -amd.

  • CI-Friendly Versions — How to build Apache Maven projects whose version is a placeholder set from the command line — the revision, sha1 and changelist properties (since Maven 3.5.0), single-project and multi-module setups.

Building, testing and packaging

  • Resources & Filtering — How Apache Maven copies resources and test resources into target/classes, the Resources Plugin goals (resources, testResources, copy-resources), resource directories with targetPath.

  • Compiling & Toolchains — Compiling Java with Apache Maven — the maven-compiler-plugin 3.16.0 and its goals, maven.compiler.release versus source and target, compiler arguments and lint, parameter names, preview features.

  • Testing with Surefire — Running unit tests with the Apache Maven Surefire Plugin 3.6.0 — the test phase and the surefire:test goal, how the single JUnit Platform provider picks the Jupiter.

  • Integration Testing with Failsafe — Running integration tests with the Apache Maven Failsafe Plugin — why a second test plugin exists, the pre-integration-test, integration-test, post-integration-test and verify phases.

  • Packaging JARs, WARs & Manifests — Packaging with Apache Maven 3.10.0 — the maven-jar-plugin and maven-war-plugin.

  • Uber JARs with Shade & Assembly — How to ship a Maven project together with its dependencies — the Maven Shade Plugin (executable JAR, resource transformers including ServicesResourceTransformer, filters and signed JARs, class relocation, minimizeJar, the dependency-reduced POM, attached shaded artifacts) and the Maven Assembly Plugin (predefined descriptors jar-with-dependencies, bin, src and project, custom descriptors with fileSets, dependencySets and moduleSets, container descriptor handlers) — packaging tidepool as a distribution.

  • Site & Reporting — Generating a project web site and reports with the Apache Maven Site Plugin 3.22.0 — the site lifecycle, what mvn site produces with no configuration, src/site content in Markdown, APT, Xdoc and FML.

Releasing and publishing

  • Install, Deploy & Distribution Management — How a Maven build publishes what it built — the install and deploy phases, the Install and Deploy plugins and their goals, distributionManagement (repository, snapshotRepository, site, relocation).

  • Releasing — How a Maven project is released — the Maven Release Plugin with Git (the scm section, release:prepare and its 17 phases, dry runs, release.properties, the release and development commits, the tag, release:perform and the checkout it deploys from, rollback, branch and update-versions).

  • Publishing to Maven Central — How to publish a Maven project to Maven Central through the Central Publisher Portal — the requirements (namespace, POM metadata, sources and Javadoc JARs, checksums, GPG signatures).

  • Archetypes — What a Maven archetype is, generating a project with archetype:generate in interactive and batch mode, the catalogs (remote, local, internal) and how to filter the list, the archetypes Maven provides.

Tooling and internals

  • Maven Wrapper — The Apache Maven Wrapper (mvnw and mvnw.cmd): creating it with mvn wrapper:wrapper, what the scripts do and where they cache the Maven distribution.

  • Extensions — How Apache Maven extensions work and how they differ from plugins — core extensions (.mvn/extensions.xml, user-wide and installation-wide extensions.xml in Maven 3.10, maven.ext.class.path, lib/ext).

  • Build Performance: Cache, Parallel Builds & mvnd — Making Apache Maven builds faster — parallel reactor builds with -T and what makes them safe or pointless.

  • Maven Resolver — What Apache Maven Resolver is and how Maven drives it — the Resolver releases inside Maven 3.9, 3.10 and 4.

  • Enforcer — Enforcing build rules with the Apache Maven Enforcer Plugin 3.6.3 and the Enforcer Extension — binding enforcer:enforce to a phase.

  • Security & Reproducible Builds — What Apache Maven trusts and what it verifies — the security model, the published vulnerabilities, the HTTP blocker and checksums.

  • Writing Plugins — Writing your own Apache Maven plugin — the maven-plugin packaging and the plugin descriptor, Mojos with @Mojo and @Parameter, parameter conversion and precedence.

Maven 4 (release candidate)

  • Maven 4: What’s New — What changes in Apache Maven 4 (release candidate 4.0.0-rc-7) compared with Maven 3.10.0 — Java 17 to run Maven, the build POM and consumer POM split, model version 4.1.0, subprojects.

  • Maven 4: POM Model & Consumer POM — The Apache Maven 4 (release candidate 4.0.0-rc-7) POM changes in depth — model version 4.1.0 and its XSD, what the new schema adds, deprecates and removes, subprojects.

  • Maven 4: Lifecycle — The Maven 4 (release candidate 4.0.0-rc-7) lifecycle compared with Maven 3.10.0 — the tree of phases, before: and after: hooks for every phase, the all and each phases.

  • Migrating to Maven 4 — A hands-on migration of a Maven 3 project to Maven 4 (release candidate 4.0.0-rc-7) in the three steps of the official guide — prepare on Maven 3.9 and 3.10, test on Maven 4.

Practice

Gradle

  • Gradle — Gradle in one page: what it is, who the documentation is written for, the versions at a glance, Gradle versus Develocity and the Gradle reading path.

Fundamentals

  • Versions, Compatibility & Release History — Gradle release history from 1.0 to 9.8.1 with dates and the changes that matter, the Java version each major line needs to run, the compatibility matrix for Java, Kotlin, Groovy and Android.

  • Core Concepts — The vocabulary of a Gradle build — build, project, root project and subprojects, build script, settings file, task and task graph, plugin.

  • Installation — Installing Gradle 9.8.1: when you do not need to, the JDK 17+ prerequisite, downloading and verifying the binary distribution (SHA-256), the distribution layout, PATH and GRADLE_HOME, SDKMAN!.

  • Gradle Wrapper — The Gradle Wrapper (gradlew, gradlew.bat and gradle/wrapper): adding it with the wrapper task and every option of --gradle-version, --distribution-type.

  • Command-Line Interface — The Gradle 9.8.1 command line — gradle [taskName…​] [--option-name…​], task selectors and project paths, name abbreviation, -x, --rerun and --rerun-tasks, --continue.

  • Build Environment & Properties — How a Gradle build is configured from outside its scripts: the four channels (command line, system properties, Gradle properties and environment variables).

  • Gradle Daemon — The Gradle Daemon in Gradle 9.8.1: why a long-lived build JVM exists, the client versus the daemon, --status, --stop, --no-daemon and org.gradle.daemon.

  • Directories & Logging — The directories Gradle uses in Gradle 9.8.1 and the log it writes: the Gradle User Home (caches, wrapper/dists, daemon, init.d, jdks, native).

  • Build Lifecycle — The Gradle build lifecycle — the initialization, configuration and execution phases and what runs in each, the order of settings and build script output.

Build authoring

  • Settings & Build Scripts — The two Gradle scripts every build is made of — settings.gradle(.kts) with pluginManagement, settings plugins, dependencyResolutionManagement and RepositoriesMode, rootProject.name and include.

  • Kotlin DSL — The Gradle Kotlin DSL (.gradle.kts scripts): script file names, implicit imports, type-safe model accessors and when they are available.

  • Groovy DSL & Migrating to Kotlin — The Gradle Groovy DSL (build.gradle) and how to move a build to the Kotlin DSL: the Groovy build-script primer (the Project object, properties, methods, blocks, delegation, closures, local variables).

Tasks and the lazy model

  • Tasks — Gradle tasks in depth — what a task is (actions, inputs, outputs, dependencies, a path and a type), listing tasks with tasks and help --task, groups and descriptions, hidden tasks.

  • Lazy Configuration & Providers — Gradle’s Provider API: Property and Provider, map/flatMap/zip/orElse/filter, connecting task inputs to outputs with automatic task dependencies, ListProperty, SetProperty, MapProperty.

  • Writing Custom Tasks — Writing your own task for Gradle 9.8.1 — a task class that extends DefaultTask, abstract classes and managed properties, the @TaskAction method.

  • Incremental Build — Gradle incremental build — how Gradle decides that a task is UP-TO-DATE, NO-SOURCE, FROM-CACHE or has to run, task inputs and outputs declared with annotations and with the runtime API.

  • Working with Files — Working with files in Gradle — locating files with file(), layout.projectDirectory and layout.buildDirectory.

  • Worker API & Build Services — Gradle Worker API and shared build services written against Gradle 9.8.1 — WorkerExecutor, WorkAction and WorkParameters, the noIsolation.

Plugins and build structure

  • Plugins Overview — How Gradle plugins work and where they come from — core plugins and the plugin reference, community plugins and the Gradle Plugin Portal with its marker artifacts, local plugins.

  • Convention Plugins & Sharing Build Logic — How a multi-project Gradle 9.8.1 build shares its configuration without copying it — the problem with copied build scripts and allprojects/subprojects blocks.

  • Binary Plugins — Writing a binary Gradle plugin for Gradle 9.8.1 — the Plugin<Project> class, the java-gradle-plugin (plugin development) plugin and the plugin descriptor, plugin ids.

  • Testing & Publishing Plugins — Testing and publishing a Gradle plugin on Gradle 9.8.1 — the three test levels, unit tests with ProjectBuilder.

  • Multi Project Builds — How a Gradle build is split into a root project and subprojects — the settings include and project paths, project dependencies with api and implementation.

  • Composite Builds — Composite builds in Gradle 9.8.1 — includeBuild in the settings file and --include-build on the command line, automatic dependency substitution by group and name.

Dependency management

  • Declaring Dependencies & Configurations — How a Gradle build declares what it depends on and where each dependency is used — module, project and file dependencies and their notations.

  • Repositories & Content Filtering — Where Gradle looks for dependencies and plugins — Maven Central, Google and the Plugin Portal shorthands, custom Maven and Ivy repositories.

  • Version Catalogs — Gradle version catalogs on Gradle 9.8.1 — the gradle/libs.versions.toml file with its versions, libraries, bundles and plugins tables, rich versions.

  • Platforms, Constraints & Rich Versions — How Gradle 9.8.1 decides which version of a module to use — version syntax and ordering, rich versions (require, strictly, prefer, reject and the !! shorthand).

  • Dependency Resolution, Conflicts & Capabilities — How Gradle turns declared dependencies into a classpath — graph resolution and artifact resolution.

  • Variant-Aware Resolution & Module Metadata — Variant-aware dependency resolution in Gradle 9.8.1 — components, variants, attributes and capabilities, the outgoing variants and resolvable configurations reports.

  • Resolution Rules & Substitution — Gradle 9.8.1 resolution rules — forcing versions with force and eachDependency, dependency substitution (module to module, module to project, project to module, conditional rules), exclusions.

  • Dependency Locking, Verification & Caching — Gradle dependency locking, dependency verification and the dependency cache — gradle.lockfile and --write-locks, lock modes and --update-locks.

JVM builds, testing and publishing

  • Java Projects — Building Java with Gradle — the java-base, java, java-library and application plugins and what each adds, source sets and the standard layout (and how to change it).

  • Toolchains — Java toolchains in Gradle 9.8.1: why a build should say which JDK it needs, java.toolchain.languageVersion, vendor, implementation and nativeImageCapable.

  • Testing JVM Projects — Testing JVM code with Gradle 9.8.1: the Test task and how it forks a JVM, the JUnit Platform with useJUnitJupiter, JUnit 4 through Vintage, TestNG and Spock, filtering with --tests and tags.

  • Publishing — Publishing JVM libraries with Gradle 9.8.1 — the maven-publish plugin (publications from components, the generated POM, versionMapping, relocation, custom artifacts, repositories and credentials, publishToMavenLocal).

Performance

  • Build Cache — The Gradle build cache on Gradle 9.8.1 — what it is and how it differs from up-to-date checks, the configuration cache and the dependency cache, enabling it (--build-cache, org.gradle.caching=true).

  • Configuration Cache & Isolated Projects — The Gradle configuration cache and Isolated Projects on Gradle 9.8.1 — how a cache hit skips the configuration phase.

  • Performance Profiling & Build Scans — Making Gradle 9.8.1 builds faster and knowing why they are slow: measure first (the --profile HTML report, Build Scans, the Gradle Profiler).

Integration, migration and upkeep

  • Ant Integration — Using Apache Ant from Gradle 9.8.1 and moving an Ant build to Gradle step by step — the ant object (AntBuilder) in the Groovy and Kotlin DSLs, Ant tasks and types.

  • Migrating from Maven — Moving a multi-module Maven build to Gradle 9.8.1 step by step — the manual’s migration order, gradle init on a pom.xml and what it gets wrong in a multi-module build.

  • Init Scripts & the Tooling API — Init scripts and the Tooling API in Gradle 9.8.1: where init scripts are found and in which order, writing one (the Gradle object, settingsEvaluated, allprojects, initscript classpath).

  • Upgrading Gradle — Upgrading a Gradle build from Gradle 8.14 to 9.8.1 and onwards: the official procedure (deprecations with --warning-mode and --scan, updating plugins, the wrapper task).

  • Best Practices & Troubleshooting — Gradle best practices and troubleshooting on Gradle 9.8.1: the official best-practices index with the release that introduced each practice and the page of this site that explains it.

Ecosystem, learning and quick reference

  • Ecosystem — plugins, repository managers, CI and IDE products, related tools and where to keep learning (official tutorials, training and books), each labelled as official or third party.

  • Cheat Sheet — a one-page side-by-side cheat sheet of the commands, files and vocabulary of the three tools.

Bibliography

Every source used to write this section is listed here, each linked to its official site; the list was collected from the Source: lines, the == References sections, the tables and the other links of the pages of this section, plus the one standard (RFC 9580) that pages name without linking, and each page lists the subset it derives from under its own == References heading. Entries are grouped by project and, inside a project, by documentation set; a label is the path of the page below the documentation set’s address (a CVE, an RFC or a Gradle release is labelled by its number). Official documentation is the source of every example; the books and third-party projects are marked as such.

Apache Ant

Start with the Apache Ant home page, the Ant manual and the Apache Ivy home page; the Maven Resolver Ant Tasks are documented by the Maven project.

Apache Maven and Maven Central

Start with the Apache Maven home page, the Guides index and the Sonatype Central documentation.

Gradle

Start with the Gradle User Manual, the releases page and the Gradle Plugin Portal.

Specifications and standards

Each is cited where a page uses it.

Books

Consulted for concept coverage and structure only; none is the source of any example, and each targets a release far older than the baseline of this section.

Third-party projects

Cited on the pages that use them and on the ecosystem page; none is documented further.