Gradle Release Notes

We are excited to announce Gradle 9.2.0 (released 2025-10-29).

This release introduces support for running Gradle on Windows ARM (ARM64) devices, making it easier to build on ARM-based systems.

It also improves the publishing API with new ways to define and publish custom software components.

Additionally, there are error and warning reporting improvements, including better suggestions when dependency verification fails, and new task grouping for Antlr.

The Daemon toolchain feature has been promoted to stable.

We would like to thank the following community members for their contributions to this release of Gradle: Adam, Björn Kautler, hasunzo, HYEON, Hyunjoon Park, HYUNJUN SON, Jendrik Johannes, Kirill Gavrilov, Madalin Valceleanu, Martin Bonnin, Matthew Haughton, Mikhail Polivakha, Na Minhyeok, Philip Wedemann, Philipp Schneider, Róbert Papp, Simon Marquis, TheGoesen, Vincent Potucek, Xin Wang.

Be sure to check out the public roadmap for insight into what's planned for future releases.

Upgrade instructions
New features and usability improvements
Windows on ARM support
Performance Improvements
Publishing improvements
Error and warning reporting improvements
Antlr task grouping improvements
Promoted features
Daemon toolchain is now stable
Fixed issues
Known issues
External contributions
Reporting problems

Upgrade instructions

Switch your build to use Gradle 9.2.0 by updating the wrapper in your project:

./gradlew wrapper --gradle-version=9.2.0 && ./gradlew wrapper

See the Gradle 9.x upgrade guide to learn about deprecations, breaking changes, and other considerations when upgrading to Gradle 9.2.0.

For Java, Groovy, Kotlin, and Android compatibility, see the full compatibility notes.

New features and usability improvements

Windows on ARM support

Gradle now supports running builds on Windows on ARM (ARM64/AArch64) devices.

This makes it possible to run Gradle on Windows virtual machines hosted on ARM-based systems.

NOTE: Due to compatibility issues on Windows AArch64, the rich console is not available. Both the default behavior and --console=rich fall back to plain console output.

Limitations are listed in Known issues

Performance Improvements

Shorter time to first task execution

Gradle 9.2.0 is more efficient at building its internal work graph. This means tasks, like running a test, for example, will start executing sooner compared to previous Gradle versions.

The effect is more apparent when there's a Configuration Cache hit since (re)building the work graph is a very significant part of the work leading to task execution.

The observed improvement will vary depending on the size, complexity and inputs associated with the work graph. Our experiments have shown up to 40% shorter times to first task execution in large builds with thousands of modules and complex dependency graphs.

Here are the numbers for different scenarios we have measured, with charts comparing 10 --dry-run executions against Gradle 9.1.0:

34% on the gradle/gradle build running codeQuality, a work graph with 10868 tasks across 217 projects
42% on a synthetic large Java build running compileJava, a work graph with 8190 tasks across 8190 projects
11% on a synthetic Android build running assembleDebug, a work graph with 21499 tasks across 526 projects

Lower memory usage

Due to optimized data structures, Gradle 9.2.0 uses less memory compared to Gradle 9.1.0. In our experiments, the improvements vary from 7% to 12% less memory required for the same workloads.

Publishing improvements

Gradle provides APIs for plugin authors and build engineers to define and customize the software components their project produces when publishing them.

New `PublishingExtension.getSoftwareComponentFactory()` method

Gradle now exposes the SoftwareComponentFactory service directly through the publishing extension. This makes it easier to create and publish custom components.

In most builds, a publishable component is already available. For example, the Java plugins automatically provide a java component. But if you’re authoring a plugin and want to publish something custom without depending on the Java plugins, this new method provides a straightforward way to do so:

plugins {
    id("maven-publish")
}

val consumableConfiguration: Configuration = getAConfiguration()

publishing {
    val myCustomComponent = softwareComponentFactory.adhoc("myCustomComponent")
    myCustomComponent.addVariantsFromConfiguration(consumableConfiguration) {}

    publications {
        create<MavenPublication>("maven") {
            from(myCustomComponent)
        }
    }
}

New provider-based methods for publishing configurations

Two new methods have been added to AdhocComponentWithVariants that accept providers of consumable configurations:

These complement the existing overloads that require an already realized configuration.

By accepting providers, configurations can now stay lazy and are only realized when needed for publishing:

plugins {
    id("base")
    id("maven-publish")
}

group = "org.example"
version = "1.0"

val myTask = tasks.register<Jar>("myTask")
val variantDependencies = configurations.dependencyScope("variantDependencies")
val myNewVariant: NamedDomainObjectProvider<ConsumableConfiguration> = configurations.consumable("myNewVariant") {
    extendsFrom(variantDependencies.get())
    outgoing {
        artifact(myTask)
    }
    attributes {
        attribute(Category.CATEGORY_ATTRIBUTE, objects.named<Category>("foo"))
    }
}

publishing {
    val component = softwareComponentFactory.adhoc("component")
    // New overload accepts a provider instead of a realized configuration
    component.addVariantsFromConfiguration(myNewVariant) {}

    repositories {
        maven {
            url = uri("<your repo url>")
        }
    }
    publications {
        create<MavenPublication>("myPublication") {
            from(component)
        }
    }
}

With this approach, myNewVariant is only realized if the myPublication publication is actually published.

Error and warning reporting improvements

Gradle provides a rich set of error and warning messages to help you understand and resolve problems in your build.

Improved suggestion when dependency verification fails

Gradle’s dependency verification helps you mitigate security risks by ensuring downloaded artifacts match expected checksums or are signed with trusted keys.

When you disable key servers in gradle/verification-metadata.xml using <key-servers enabled="false"/> and a verification failure occurs due to missing keys, Gradle now adds the --export-keys parameter to suggested commands:

Dependency Verification Fails Suggestion

Antlr task grouping improvements

Antlr-related tasks such as generateGrammarSource and generateTestGrammarSource are now grouped under Antlr in Gradle’s task listings.

Previously, these tasks appeared in the default Other tasks group, which only shows when running ./gradlew tasks --all.
By assigning them to the Antlr group, they are easier to discover:

$ ./gradlew tasks

Antlr tasks
-----------
plugin:generateGrammarSource - Processes the main Antlr grammars.
plugin:generateTestGrammarSource - Processes the test Antlr grammars.

Gradle Release Notes

Table Of Contents