# Gradle

The Gradle Blog

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Let's Talk About Black October

DevFeed: [Let's Talk About Black October](<https://devfeed.tech/articles/let-s-talk-about-black-october-117811.md>)

Original publisher: [Read original article](<https://blog.gradle.org/lets-talk-about-black-october>)

Author: Laura Kassovic

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [code security](<https://devfeed.tech/topics/code-security.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [software supply-chain attack](<https://devfeed.tech/topics/software-supply-chain-attack.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [black-october](<https://devfeed.tech/tags/black-october.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Black October was a cluster of unrelated disclosures, but the eMudhra certificate compromise exposed JVM builds because tested JDKs trusted forged chains and carry their own `cacerts` trust store. Gradle itself needed no patch; Gradle's CI blocked compromised certificates across JDKs, OS bundles, and machine images. The article says to update JDKs and verify the fix, identify the JDK and trust store used by builds and images, and enable dependency verification and locking. It also details a separate Brotli risk: `brotli4j` before 1.24.0 bundles vulnerable native code; locate it in project and build dependencies, then upgrade it or the supplying plugin. Dependency verification metadata should be reviewed because bootstrapping trusts current downloads. The article notes that GitHub-hosted Linux and macOS runners remained exposed at publication, while Windows rejected the forged chain.

### Source excerpt

For four days in October, our security channels read like the montage at the start of a disaster movie. Between October 19 and 22, 2026, so many serious disclosures went public that people started calling the whole month Black October. Black October is a media label, and a slightly misleading one, because it suggests a single attack or a single bug. It was a pile-up of unrelated vulnerabilities, several of which had been sitting in code for months or years, that happened to land in the same week. Most of it had nothing to do with Gradle, but one piece affects any build that runs on a JVM, which is every Gradle build ever. This post covers what happened, what it looked like from inside Gradle (including the places where we were exposed), and what we'd check before the next pile-up arrives. What actually happened during Black October? Here's the short tour: Disclosure What it was Why build engineers should care PHP2Shell Two remote code execution flaws in the PHP runtime (CVE-2026-109618 and CVE-2026-109619). Amazon's honeypots saw the first exploit attempt on October 17, and PHP shipped fixes on October 21. Not a JVM problem, but the cleanest example of the patch race. Node2Shell An out-of-bounds write in the Brotli C decoder (CVE-2026-111497), affecting Brotli 1.0.3 through 1.2.0. Node.js bundles it, and so do Java wrappers like brotli4j. Vulnerable native code can ride in on a dependency you never picked. eMudhra CA compromise Eight intermediate CA certificates whose private keys were generated so badly that anyone can recover them from the certificates. One of the keys was literally the number 4. They chain to roots your JDK trusts. Linux kernel list leak Unpatched kernel bugs posted to the public kernel mailing list instead of the private security list. Disclosure itself became a point of failure. LiteLLM on PyPI A malicious release (1.107.0) published through the project's own release pipeline with a credential stealer. It was live for about two hours. The build

## Side Quest: How Gradle Is Removing Ant

DevFeed: [Side Quest: How Gradle Is Removing Ant](<https://devfeed.tech/articles/side-quest-how-gradle-is-removing-ant-109457.md>)

Original publisher: [Read original article](<https://blog.gradle.org/side-quest-removing-ant>)

Author: Laura Kassovic

Published: 2026-10-29T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [Hackathon](<https://devfeed.tech/topics/hackathon.md>)

Tags: [built-in](<https://devfeed.tech/tags/built-in.md>), [cost](<https://devfeed.tech/tags/cost.md>), [days](<https://devfeed.tech/tags/days.md>), [deprecation](<https://devfeed.tech/tags/deprecation.md>), [distribution](<https://devfeed.tech/tags/distribution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [flexible](<https://devfeed.tech/tags/flexible.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [guide](<https://devfeed.tech/tags/guide.md>), [hackathon](<https://devfeed.tech/tags/hackathon.md>), [migration](<https://devfeed.tech/tags/migration.md>), [native](<https://devfeed.tech/tags/native.md>), [need](<https://devfeed.tech/tags/need.md>), [october](<https://devfeed.tech/tags/october.md>), [team](<https://devfeed.tech/tags/team.md>)

### AI overview

Gradle 9.9.0 deprecates its built-in Ant API, with removal and the end of Ant classes on build script classpaths planned for Gradle 10. Ant currently ships with every Gradle distribution; the article cites Configuration Cache incompatibility, Groovy coupling, and maintenance effort as costs. Builds that never call Ant or import its classes need no changes. Others can use Gradle equivalents, invoke tools directly, replace supported filters with `filter(Transformer)`, add Ant to build logic, or run Ant in a separate process. Migration details matter: Gradle `Copy` copies files regardless of destination timestamps, `Exec` fails on nonzero exit by default, and declared task inputs and outputs enable caching. The proposed filter replacement works line by line and has limits for multiline tokens and filters such as `HeadFilter` or `TailFilter`. Gradle's own Ant-backed PMD, CodeNarc, and Checkstyle plugins are separate cleanup work, not tied to Gradle 10.

### Source excerpt

In October, the Gradle team spent a week together in Istanbul, and one of those days was a hackathon. One group picked a side quest with a deceptively short description: remove Ant from the Gradle distribution. Then we looked at gradle/gradle and we counted. Ant turned out to back 58 imports across 12 different Gradle features. So "remove Ant" became a deprecation in Gradle 9.9.0, a removal planned for Gradle 10, and a long new section in our upgrade guide. TL;DR: Gradle 9.9.0 deprecates the built-in Ant integration, and we plan to remove it in Gradle 10. Gradle 10 also stops putting Ant classes on your build script classpath. Why: a modern Gradle build shouldn't need Ant, and carrying it holds Gradle back. If your build calls ant, the migration section covers how to move off it. Gradle's own internal Ant usage, like the PMD, CodeNarc, and Checkstyle plugins, goes away separately and isn't tied to Gradle 10. Why is Gradle removing Ant? Gradle's Ant integration was largely about ease of migration. If your build was in Ant, you could bring it into Gradle and move it over piece by piece. That isn't really a concern anymore. We've asked whether Gradle should keep its Ant support for years, and this deprecation is our answer. A proper Gradle build shouldn't need Ant for anything, and if we spot Ant in a build today, we recommend moving off it. Where does Ant fit in "fast, flexible, scalable, comprehensible"? It doesn't. We judge features against what Gradle is supposed to be, and native Ant integration isn't on that list. Our job is to give you a platform where you can integrate Ant if you need it. The migration paths below do exactly that. What does keeping Ant cost? Ant ships in every Gradle distribution, whether your build uses it or not. It sits in the Gradle API JAR and on your build script classpath. When you run gradle --version, Gradle prints the Ant version next to its own: ------------------------------------------------------------ Gradle 9.8.2 ---------------

## Agent Skills for Gradle Best Practices and Wrapper Upgrades

DevFeed: [Agent Skills for Gradle Best Practices and Wrapper Upgrades](<https://devfeed.tech/articles/agent-skills-for-gradle-best-practices-and-wrapper-upgrades-63458.md>)

Original publisher: [Read original article](<https://blog.gradle.org/introducing-gradle-skills>)

Author: Laura Kassovic

Published: 2026-09-30T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [hardened ai agent skills](<https://devfeed.tech/topics/hardened-ai-agent-skills.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [agents](<https://devfeed.tech/tags/agents.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [skills](<https://devfeed.tech/tags/skills.md>)

### AI overview

Gradle has released an official agent plugin with skills for auditing builds against Gradle best practices and upgrading Gradle wrappers. The article describes their workflows and evaluations, reporting improved results across tested models, including better wrapper upgrade checks and rollback behavior.

### Source excerpt

In August, we told you Gradle was going agentic. Today, we're shipping an official plugin that contains the first two Gradle skills. Version 1.0.0 is a starting point, and we have a lot more already in progress. TL;DR: We shipped two skills: gradle-best-practices and gradle-wrapper-upgrade. Install the gradle-skills agent plugin to get all skills and new ones we add later. We tested each skill on seven models from five vendors across three agent harnesses. Agents do better with the gradle-best-practices and gradle-wrapper-upgrade skills than without: cheaper models approached frontier-model results, and four models passed every upgrade check. Next up: A patch for these skills, new skills, and agent-friendly documentation. Quick refresher if you missed the first post. Agents are now Gradle users we have to design for, right alongside the person at the keyboard. A skill is a small package of instructions that teaches an agent to do one job well, so the agent follows a known procedure instead of guessing from whatever it half-remembers. What did we ship? We shipped a plugin containing two skills, located at github.com/gradle/gradle-skills: Skill What it does Ask it to... gradle-best-practices Audits your build against the official best practices, writes a prioritized report, and proposes fixes "Check my build" or "Apply best practices to my build" gradle-wrapper-upgrade Upgrades an existing Gradle wrapper, pins the checksum, verifies the result, and rolls back if the build no longer configures successfully "Upgrade the Gradle wrapper" or "How do I upgrade the wrapper?" How do I install the skills? We recommend installing our plugin, which gets you all of the skills now and every skill we add later. For example, in Claude Code: /plugin marketplace add gradle/gradle-skills /plugin install gradle-skills@gradle-skills You can also install through skills.sh, which covers Claude Code, Codex, Gemini, Cursor, and any other agent that reads the Agent Skills format: npx skills add

## Testing Astra 6 v Fable 5.1 on a Gradle docs bug

DevFeed: [Testing Astra 6 v Fable 5.1 on a Gradle docs bug](<https://devfeed.tech/articles/testing-astra-6-v-fable-5-1-on-a-gradle-docs-bug-24700.md>)

Original publisher: [Read original article](<https://blog.gradle.org/two-agents-one-gradle-bug>)

Author: Laura Kassovic

Published: 2026-09-09T04:00:00Z

Content type: opinion

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [gpt-6-astra](<https://devfeed.tech/topics/gpt-6-astra.md>), [codex](<https://devfeed.tech/topics/codex.md>), [Fable](<https://devfeed.tech/topics/fable.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [api](<https://devfeed.tech/tags/api.md>), [astra](<https://devfeed.tech/tags/astra.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bug](<https://devfeed.tech/tags/bug.md>), [cli](<https://devfeed.tech/tags/cli.md>), [coding](<https://devfeed.tech/tags/coding.md>), [cost](<https://devfeed.tech/tags/cost.md>), [docs](<https://devfeed.tech/tags/docs.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [fable](<https://devfeed.tech/tags/fable.md>), [fable-5-1](<https://devfeed.tech/tags/fable-5-1.md>), [git](<https://devfeed.tech/tags/git.md>), [github](<https://devfeed.tech/tags/github.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The Gradle docs bug came from Dokka deriving Java interop links from the JDK 21 build toolchain, even though Gradle targets Java 17; Kotlin DSL references therefore pointed to Java 21 Javadoc instead of Java 17. The post compares claude-fable-5-1 via claude-code with gpt-6-astra via codex on the same issue and constraints. Both fixes passed an independent judge, but the author evaluates cost, speed, and maintainability as separate dimensions. The evidence is limited to one run per model, one judge, and one bug, so it does not support a broad benchmark conclusion.

### Source excerpt

On the afternoon of September 7th, claude-fable-5-1 was handed a git repository, a GitHub issue, and fifty turns to fix it. Just over three hours later, gpt-6-astra finished the same assignment in another worktree. Same issue. Same constraints. Different CLI wrapped around each model: claude-code for Fable, codex for Astra. Both Agents fixed the bug. Both results were graded as successes by an independent judge. But these results were quite different. You would be forgiven for wondering why an engineering blog is running a two-model bakeoff on a single documentation bug, in a year when everybody and their intern has published an AI coding benchmark. Here's the honest answer: we wanted to know which one actually did the better job, as a side quest of the Agentic Gradle project. But "better" was never going to mean pass-or-fail. Both of these agents passed; if that were the whole story, this post would be four sentences long. What actually separates a fix worth merging from a fix worth sending back is cost, speed, and whether the result is something we would want to maintain, and those three do not all point the same direction, as you are about to see. So: one bug, two agents, and a very literal stopwatch. Here is what this looks like when you actually read the agents' transcripts. Real talk up front: this is n=1. One run per model, one judge, one bug. That's a thin base for anything you'd call a leaderboard, and I'll say so again at the end, but it didn't stop me from landing on an opinion by the time I'd finished reading both transcripts. The bug, briefly Issue #34751, filed August 21st by our very own cobexer, is the kind of bug that is very easy to describe and mildly annoying to fix. In the Kotlin DSL API docs, a type like Attribute<Integer> linked to the Java 21 Javadoc. It should have linked to Java 17, because Gradle targets Java 17. The reason is almost embarrassingly mundane once you see it. Gradle is built with a JDK 21 toolchain but targets JDK 17, which i

## Introducing the Gradle Security Subscription

DevFeed: [Introducing the Gradle Security Subscription](<https://devfeed.tech/articles/introducing-the-gradle-security-subscription-24634.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-security-subscription>)

Author: Gradle Build Tool

Published: 2026-08-31T04:00:00Z

Content type: release

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Security](<https://devfeed.tech/topics/security.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>)

Tags: [gradle](<https://devfeed.tech/tags/gradle.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [releases](<https://devfeed.tech/tags/releases.md>), [security](<https://devfeed.tech/tags/security.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Gradle announces the Gradle Security Subscription, which provides security fixes under a service-level agreement, maintenance for Gradle versions beyond the open source end-of-life policy, and advance notice of newly discovered vulnerabilities. The article explains build-tool security risks and argues that the subscription does not change the open source community offering.

### Source excerpt

The Gradle Security Subscription is available today. It provides security fixes under a service-level agreement, security maintenance for Gradle versions beyond the open source end-of-life policy, and advance notice of newly discovered vulnerabilities ahead of public disclosure. Coverage details are on our subscription page. The rest of this post explains why the subscription is important and what changes for the open source community (in short, nothing). The toolchain as an attack surface In 1984, while accepting the Turing Award, Ken Thompson described a compiler he had modified to insert a backdoor into the programs it compiled. Reviewing the source of the affected program revealed nothing. And reviewing the source of the compiler revealed nothing either. His conclusion was that you cannot fully trust code you did not create entirely yourself. Four decades later, we find ourselves facing the same dilemma. Software composition analysis scans the dependencies a project declares. Static analysis scans the source a team writes. But neither examines the build tool that turns that source and those dependencies into the artifact that goes to production. This gap has been exploited repeatedly. In 2015, XcodeGhost distributed a modified version of Apple's IDE that inserted malicious code into every application compiled with it, reaching thousands of App Store applications whose developers had written nothing malicious. In 2020, SolarWinds released a compromised version of their IT software, but the attackers modified no source code. They gained access to the build environment and installed malware that monitored the compilation process, injecting a backdoor into the resulting binary as it was produced. Approximately 18,000 organizations installed the signed update, including the U.S. Departments of Treasury, State, Defense, and Homeland Security. There are two more recent incidents. The Codecov Bash Uploader compromise ran undetected for roughly two months in 2021, exfilt

## Gradle Is Going Agentic

DevFeed: [Gradle Is Going Agentic](<https://devfeed.tech/articles/gradle-is-going-agentic-24627.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-is-going-agentic>)

Author: Laura Kassovic

Published: 2026-08-19T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [context window](<https://devfeed.tech/topics/context-window.md>), [ai-experiments](<https://devfeed.tech/topics/ai-experiments.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [build](<https://devfeed.tech/tags/build.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [cache](<https://devfeed.tech/tags/cache.md>), [catalog](<https://devfeed.tech/tags/catalog.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [context](<https://devfeed.tech/tags/context.md>), [context-window](<https://devfeed.tech/tags/context-window.md>), [effectively](<https://devfeed.tech/tags/effectively.md>), [failed](<https://devfeed.tech/tags/failed.md>), [failure](<https://devfeed.tech/tags/failure.md>), [features](<https://devfeed.tech/tags/features.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [pattern](<https://devfeed.tech/tags/pattern.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [performance](<https://devfeed.tech/tags/performance.md>), [project](<https://devfeed.tech/tags/project.md>), [skills](<https://devfeed.tech/tags/skills.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

Agentic Gradle aims to make builds work better with agents, which increasingly run tasks and diagnose failures. The project has two broad parts: focused skills that guide agents through Gradle tasks, and Gradle features addressing friction agents introduce. The excerpt describes official skills for interpreting build failures, choosing tasks and Build Scan information, and giving more current performance guidance such as enabling the configuration cache, using a version catalog and checking configuration-time anti-patterns. Gradle says it will publish a skill only after showing it improves performance on a real task. It is also building repeatable benchmarks that hold the agent and Gradle version steady to measure the effect of skills or Gradle changes. The excerpt does not describe the third planned piece.

### Source excerpt

More and more of the people who run Gradle every day aren't typing ./gradlew build themselves. They're asking an agent to run a build, paste it the failure, then ask it to fix the thing that failed. The agent is now part of the build loop, whether the build tool invited it or not. This is not a Gradle-specific oddity. Every build tool is being driven by a new kind of user: not a person with muscle memory for flags and log output, but a model with a terminal, a context window, and alarming confidence. New user, new failure modes. We have hit enough of them that pretending this is temporary started to feel silly. So we started a project. We're calling it Agentic Gradle. The practical version has two buckets: skills that teach agents how to use Gradle effectively, and new Gradle features for the places where agents make today's build tooling awkward. Not because Gradle is bad at this, but because agents push builds in ways we never had to support before. Picking it up meant we didn't do something else this cycle. We'll get to that, because it is the more interesting part of the story. But first, what we're actually building. What this looks like in practice There are three pieces, in the order we're putting real time behind them. Official Gradle skills. A skill is a small, focused set of instructions that teaches an agent how to do something specific with Gradle: read a build failure, run the right task, understand what a Build Scan is telling it. Skills also make vague prompts less dangerous. Give an agent "speed up my build" and, left to its own devices, it'll reach for whatever pattern it saw most often on the internet, which is often years out of date. A focused Gradle performance Skill can keep it closer to the boring advice that works: enabling the configuration cache, reaching for a version catalog, avoiding configuration-time anti-patterns it wouldn't otherwise think to check. We've been experimenting with these throughout the year, and a few are close to ready

## Resilient Sync: Your IDE Keeps Helping even when your Build is Broken

DevFeed: [Resilient Sync: Your IDE Keeps Helping even when your Build is Broken](<https://devfeed.tech/articles/resilient-sync-your-ide-keeps-helping-even-when-your-build-is-broken-24686.md>)

Original publisher: [Read original article](<https://blog.gradle.org/resilient-sync>)

Author: Laura Kassovic

Published: 2026-08-13T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [IntelliJ IDEA](<https://devfeed.tech/topics/intellij-idea.md>), [ide](<https://devfeed.tech/topics/ide.md>), [scylladb](<https://devfeed.tech/topics/scylladb.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [2026-2](<https://devfeed.tech/tags/2026-2.md>), [autocomplete](<https://devfeed.tech/tags/autocomplete.md>), [build](<https://devfeed.tech/tags/build.md>), [feature](<https://devfeed.tech/tags/feature.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [ide](<https://devfeed.tech/tags/ide.md>), [intellij-idea](<https://devfeed.tech/tags/intellij-idea.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>)

### AI overview

Gradle 9.7 and IntelliJ IDEA 2026.2 introduce resilient sync, allowing the IDE to remain useful when parts of a Gradle build fail to configure. Instead of aborting the entire sync, Gradle provides partial project models, editor data for resolvable Kotlin DSL scripts, and structured failure information.

### Source excerpt

You upgrade Gradle, hit sync, and watch every build script turn red. The IDE that was finishing your sentences five minutes ago suddenly has nothing to say, and you're left fixing build logic in what is effectively a very expensive text editor. And the API you need to fix the error is the exact API the IDE can no longer tell you anything about. To get autocomplete back, fix the build. To fix the build, it would help to have autocomplete. Chicken, meet egg. Gradle 9.7, together with IntelliJ IDEA 2026.2, fixes this. The feature is called resilient sync, and it is one of those changes you only notice by its absence once you have it. What goes wrong today Nobody designed the old behavior to be cruel. It falls out of two entirely reasonable decisions that happen to collide. The IDE reasons that if it cannot get a model back from Gradle, it has nothing accurate to show you, so it shows almost nothing. Gradle reasons that if configuration throws, the whole operation failed, so it reports the failure and stops. Both are correct. Together they produce a tool that abandons you precisely when you need it most. The worst version is the multi-project build. You have a hundred subprojects, and one of them (or one shared convention plugin in an included build) has a broken script. In the old world, that single failure takes down the sync for all one hundred. Ninety-nine healthy projects lose their IDE support over one bad line somewhere else in the tree. Power users had a workaround, as charming as workarounds usually are: # The old "please just give me some completion" incantation. Don't rely on this. org.gradle.jvmargs=-Dorg.gradle.kotlin.dsl.provider.mode=classpath It coaxed some completion out of a broken build, frequently broke Gradle's internal state in other ways, and often needed an IDE restart to load new API. Reader, it was not a fix. It was a coping mechanism. What is resilient sync? Resilient sync replaces all-or-nothing with best-effort. When part of your build fails

## The Red X that Says What it Saw

DevFeed: [The Red X that Says What it Saw](<https://devfeed.tech/articles/the-red-x-that-says-what-it-saw-24615.md>)

Original publisher: [Read original article](<https://blog.gradle.org/dogfooding-failure-summaries>)

Author: Laura Kassovic

Published: 2026-08-11T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [test](<https://devfeed.tech/topics/test.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [bot](<https://devfeed.tech/tags/bot.md>), [ci](<https://devfeed.tech/tags/ci.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [failure](<https://devfeed.tech/tags/failure.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [scan](<https://devfeed.tech/tags/scan.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The CI bot now reads failures from Develocity, groups equivalent failures across the builds behind a check, and posts a short summary on the pull request. In the cited example, the summary identified a test that unexpectedly passed despite being marked as expected to fail under Configuration Cache, and linked to a Build Scan with the exception and recent test history. The post describes the comment as a headline that helps developers find the relevant failure without first digging through raw logs; the Build Scan provides more detail. The supplied excerpt ends while describing failure grouping, so it does not establish the full implementation or its limitations.

### Source excerpt

A failing CI check knows exactly what went wrong. It was there. It watched the exception get thrown, caught the stack trace, wrote the whole thing down. And then, by long tradition, it tells you almost none of it: a red X, a job name, and an invitation to go read the logs yourself. Our CI bot has commented on pull requests in gradle/gradle for years: triggering builds on request, shepherding the merge queue, answering commands. In mid-July we gave it one more job. When a check goes red, it reads the failures out of Develocity, groups them, and posts a short summary on the pull request, so the red X finally has to say what it saw. A real failure Take pull request #38047, a change that gives the Copy and Sync tasks a lazy destinationDirectory property. Additive, non-breaking, the kind of change you expect to sail through. Most of its checks came back green. One did not. Here is what the bot left on the pull request: You can read the entire shape of the failure without opening anything. It is a single test, named in full: CachedTaskActionIntegrationTest, the case "ad hoc tasks with the same action share results," in :core:configCacheIntegTest. And it is the good kind of surprising. The test was marked to be fixed: a known limitation, annotated as expected to fail under the Configuration Cache. Except it did not fail. It passed. Expected the test to fail in 'Configuration Cache' mode, but it succeeded! The change had quietly fixed something a stale annotation still insisted was broken, and the build stopped to point it out. The comment links straight into the Build Scan. Open it, and the failure is waiting on the summary: That is the Build Scan for the failing build, and the failure is sitting right in the summary: the same test named again, the ToBeFixedUnexpectedSuccessException spelled out, and, because this is Develocity, the test's own history next to it: 713 runs in the last seven days, 536 passed, 7 failed. The comment is the headline. The Build Scan is the story

## Introducing Isolated Projects

DevFeed: [Introducing Isolated Projects](<https://devfeed.tech/articles/introducing-isolated-projects-24653.md>)

Original publisher: [Read original article](<https://blog.gradle.org/introducing-isolated-projects>)

Author: Alex Semin

Published: 2026-08-06T04:00:00Z

Content type: release

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>)

Tags: [adopting](<https://devfeed.tech/tags/adopting.md>), [build](<https://devfeed.tech/tags/build.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cli](<https://devfeed.tech/tags/cli.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [guide](<https://devfeed.tech/tags/guide.md>), [ide](<https://devfeed.tech/tags/ide.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [project](<https://devfeed.tech/tags/project.md>), [projects](<https://devfeed.tech/tags/projects.md>), [release](<https://devfeed.tech/tags/release.md>), [sync](<https://devfeed.tech/tags/sync.md>)

### AI overview

Gradle 9.7.0 moves Isolated Projects from experimental to incubating. It enforces boundaries between projects so Gradle can configure them independently and concurrently; parallel project configuration supplies most of the current performance gains, including for command-line builds and IDE sync. Configuration Cache is a prerequisite. Enable the feature with `--isolated-projects` or `org.gradle.isolated-projects=true`; IDE sync requires the property. Isolation violations can require build logic changes or compatible community plugins. Gradle reports the first violation immediately, while Diagnostics mode and the Configuration Cache HTML report help surface violations. The feature takes precedence over other performance features, and its constraints may expand, including in minor releases.

### Source excerpt

Isolated Projects is a Gradle performance feature that speeds up the configuration phase. When the feature is enabled, each project in a build becomes "isolated" from others via boundaries that cannot be crossed. With this guarantee, Gradle can safely operate on each project independently and concurrently. This enables greater utilization of machine resources at configuration time and sets the stage for future caching optimizations. In the latest Gradle 9.7.0 release, Isolated Projects graduates from experimental to incubating. We believe Isolated Projects is the future of Gradle, and we intend to stabilize it and eventually make it the default. In this Gradle version, most of the performance gains come from parallel project configuration. It is not the only optimization these isolation constraints make possible, just the first to ship. It provides speedups across practically all scenarios, including CLI invocations and IDE sync. We invite everyone to try it and share feedback. Adopting Isolated Projects Isolated Projects ships with an extensive guide to adopting it. If you've already upgraded to Configuration Cache, which is a prerequisite, then the process should be familiar. You can enable the feature either via the --isolated-projects command-line flag or with the property org.gradle.isolated-projects=true. It must be enabled with a property to take effect for IDE sync. # gradle.properties org.gradle.isolated-projects=true When Isolated Projects is enabled, it takes precedence over other performance features. You can learn more about how it interacts with other features in this section of the documentation. Since the feature introduces new isolation constraints, you might have to adjust your build logic or upgrade community plugins to take advantage of it. For correctness, Gradle will fail immediately upon encountering the first constraint violation and report the error: You can use the Diagnostics mode to discover many constraint violations at once. All the rep

## Three Gradle Talks from KotlinConf 2026 (and What to Steal from Each)

DevFeed: [Three Gradle Talks from KotlinConf 2026 (and What to Steal from Each)](<https://devfeed.tech/articles/three-gradle-talks-from-kotlinconf-2026-and-what-to-steal-from-each-24622.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-at-kotlinconf-2026>)

Author: Laura Kassovic

Published: 2026-07-28T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Groovy](<https://devfeed.tech/topics/groovy.md>), [ide](<https://devfeed.tech/topics/ide.md>), [Script](<https://devfeed.tech/topics/script.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [build](<https://devfeed.tech/tags/build.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [conference](<https://devfeed.tech/tags/conference.md>), [developer](<https://devfeed.tech/tags/developer.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [event](<https://devfeed.tech/tags/event.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [groovy](<https://devfeed.tech/tags/groovy.md>), [ide](<https://devfeed.tech/tags/ide.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlinconf](<https://devfeed.tech/tags/kotlinconf.md>), [refactoring](<https://devfeed.tech/tags/refactoring.md>), [script](<https://devfeed.tech/tags/script.md>), [scripting](<https://devfeed.tech/tags/scripting.md>), [talk](<https://devfeed.tech/tags/talk.md>), [talks](<https://devfeed.tech/tags/talks.md>)

### AI overview

The article reviews three Gradle talks from KotlinConf 2026. It explains the progression from Groovy build scripts to the Kotlin DSL and early Declarative Gradle, emphasizing the problems each approach addresses. It also introduces Gradle best practices for organizing and optimizing builds.

### Source excerpt

Every year I tell myself I'll watch every conference talk I missed. Every year I get through maybe three before a build breaks and I get pulled back into real life. KotlinConf is the one event where I actually follow through, partly because the talks are short and dense, and partly because a good chunk of my coworkers and friends are on stage. This year in Munich, three of them talked about Gradle: Paul Merlin on the history of our DSLs, Stefan Wolf on best practices, and Marcin Mycek on Declarative Gradle for Kotlin. I watched all three so you can decide which ones are worth your fifteen minutes. A Tale of the Gradle DSLs -- Paul Merlin Paul has been inside Gradle's DSL machinery for years, which makes him exactly the right person to tell this story and exactly the wrong person to pretend the early days were clean. The talk traces how build logic went from Groovy, to the Kotlin DSL, to Declarative Gradle. The useful part isn't the timeline. It's that each of those was solving a real problem the previous one couldn't. Groovy gave us a flexible, dynamic scripting language, which was great right up until you wanted your IDE to tell you what was valid. The Kotlin DSL brought static typing, real autocompletion, and refactoring that doesn't rely on hope. That's why the Kotlin DSL is now the default for new Gradle builds. Declarative Gradle is the next swing: describe what your build is rather than script how it runs. The honest through-line is that none of these fully replaces the last one. Kotlin DSL is where most people should be today. Groovy still runs an enormous amount of the world's build logic and isn't going anywhere fast. Declarative Gradle is early but points at where things are headed. Real talk: if your build scripts are still Groovy and still working, you don't have to panic-migrate this weekend. But if you're starting something new, reach for the Kotlin DSL and let the IDE carry some of the weight. 📺 Watch the talk 10 Gradle Best Practices Every Kotlin Deve

## How the Gradle Team Adopted Isolated Projects

DevFeed: [How the Gradle Team Adopted Isolated Projects](<https://devfeed.tech/articles/how-the-gradle-team-adopted-isolated-projects-24658.md>)

Original publisher: [Read original article](<https://blog.gradle.org/isolated-projects-in-gradle-team>)

Author: Alex Semin

Published: 2026-07-22T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Dependency management](<https://devfeed.tech/topics/dependency-management.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>)

Tags: [all](<https://devfeed.tech/tags/all.md>), [ci](<https://devfeed.tech/tags/ci.md>), [concurrently](<https://devfeed.tech/tags/concurrently.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [convention-plugins](<https://devfeed.tech/tags/convention-plugins.md>), [dependency-management](<https://devfeed.tech/tags/dependency-management.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [guide](<https://devfeed.tech/tags/guide.md>), [html](<https://devfeed.tech/tags/html.md>), [ide](<https://devfeed.tech/tags/ide.md>), [migration](<https://devfeed.tech/tags/migration.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [team](<https://devfeed.tech/tags/team.md>), [user-experience](<https://devfeed.tech/tags/user-experience.md>)

### AI overview

Gradle's team adopted experimental Isolated Projects to improve build scalability and parallelize project configuration, while uncovering rough spots early. Adoption requires Configuration Cache compatibility and migration to constraints that keep parallel builds reliable. The team recommends starting with simple workflows, then moving to IDE sync or CI; Diagnostics mode gathers violations in an HTML report. Convention plugins and sharing project outputs through dependency management helped avoid projects mutating one another's state. For more complex cases, they used Shared Build Services. The excerpt also stresses identifying third-party plugin incompatibilities early and reporting them to maintainers.

### Source excerpt

Isolated Projects is an experimental feature aimed at improving Gradle scalability and performance. It speeds up builds by running project configuration in parallel, which benefits practically every workflow, from CI builds to IDE sync. We want the feature to offer an excellent user experience, so we made it a goal to adopt Isolated Projects in our own build, even though it is still in active development. This lets us find and smooth out the rough spots early, though secretly, we were also looking forward to the productivity boost for our own team. With Isolated Projects, more build logic runs concurrently. To keep builds reliable under that parallelism, the feature introduces additional constraints, and adopting it means migrating your build to address the violations of those constraints. Migrating our build Isolated Projects builds directly on top of the Configuration Cache, so making the build Configuration Cache compatible is a prerequisite. Fortunately for us, we've been enjoying fast inner developer loops for many years now, so that box was already checked. The general approach to migrating against new constraints is to start with the simplest workflows, such as running the help task, and address the violations. Then proceed to more complex workflows, such as IDE sync or CI. Running in Diagnostics mode helps you see all violations at once in a single HTML report, and the guide describes the recommended migration path. For the Gradle build, we followed a similar path. What helped us the most and made the migration much smoother is following the best practices, especially the best practice of having convention plugins: each project applies the build logic it needs, and no project has to reach in and mutate another's state directly. We've leaned heavily on sharing artifacts between projects only via dependency management, which is inherently compatible with Isolated Projects by making each project define its "outputs", on which other projects can depend. For more

## The Company Formerly Known as Gradle

DevFeed: [The Company Formerly Known as Gradle](<https://devfeed.tech/articles/the-company-formerly-known-as-gradle-24696.md>)

Original publisher: [Read original article](<https://blog.gradle.org/the-company-formerly-known-as-gradle>)

Author: Gradle Build Tool

Published: 2026-07-17T04:00:00Z

Content type: news

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Maven](<https://devfeed.tech/topics/maven.md>), [bazel](<https://devfeed.tech/topics/bazel.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [apache-2-0](<https://devfeed.tech/tags/apache-2-0.md>), [bazel](<https://devfeed.tech/tags/bazel.md>), [bug](<https://devfeed.tech/tags/bug.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [company](<https://devfeed.tech/tags/company.md>), [free](<https://devfeed.tech/tags/free.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [maven](<https://devfeed.tech/tags/maven.md>), [npm](<https://devfeed.tech/tags/npm.md>), [observability](<https://devfeed.tech/tags/observability.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [platform](<https://devfeed.tech/tags/platform.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>), [toolchains](<https://devfeed.tech/tags/toolchains.md>)

### AI overview

Gradle Technologies renamed itself to Develocity in June 2026 because its commercial Develocity platform had become the company's center of gravity and the shared name confused the company with the build tool. The tool was not renamed, acquired, relicensed, or transferred: it remains free, open source, Apache 2.0-licensed, and at gradle.org. Develocity supports Gradle as well as Maven, Bazel, npm, sbt, and other toolchains; the free Build Scan service is powered by Develocity. The supplied text is an excerpt and ends before the FAQ is complete.

### Source excerpt

Names are like infrastructure. They mostly work invisibly, which means the rare occasions when they don't work generate confusion wildly out of proportion to the underlying facts. Our name has had a known bug, and we have finally shipped a fix. This post explains what changed, what emphatically did not, and why the word "Develocity" now appears near the word "Gradle" in places like search results and the header of this website. The short version, for people who close browser tabs quickly: our company renamed itself from Gradle Technologies to Develocity in June 2026. The build tool is not renamed, not acquired, not relicensed, and not changing hands. It remains free, open source, Apache 2.0-licensed, and at home right here at gradle.org. If your interest in corporate naming decisions is limited (a healthy instinct), you can stop reading now, and your builds will be entirely unaffected. For everyone else, some institutional mechanics (and an FAQ). One word, two referents In 2008, Hans Dockter started building a build tool and called it Gradle. Some years later, there was a company, and, following the extremely common pattern for companies formed around a successful open source project, it was also called Gradle. This works fine right up until the company starts doing things that are not the build tool, at which point every sentence containing the word "Gradle" acquires a footnote. We know this because we literally maintain that footnote: the fine print at the bottom of this website has said, for years, that "Gradle" on these pages means Gradle Build Tool and not Gradle, Inc. When a name requires a standing disclaimer to be parsed correctly, the name has a bug. The company side of the house has, for close to a decade, built a commercial product called Develocity: a universal toolchain & artifact observability platform that works with Gradle, and also with Maven, Bazel, npm, sbt, and other toolchains that are conspicuously not Gradle. (The free Build Scan service is po

## Triaging at Scale: How the Gradle Team Handles Issues and Pull Requests

DevFeed: [Triaging at Scale: How the Gradle Team Handles Issues and Pull Requests](<https://devfeed.tech/articles/triaging-at-scale-how-the-gradle-team-handles-issues-and-pull-requests-24699.md>)

Original publisher: [Read original article](<https://blog.gradle.org/triaging-gradle-github-issues>)

Author: Vlad Chesnokov

Published: 2026-07-16T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [issue tracking](<https://devfeed.tech/topics/issue-tracking.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [bug](<https://devfeed.tech/tags/bug.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [github](<https://devfeed.tech/tags/github.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [issue-tracker](<https://devfeed.tech/tags/issue-tracker.md>), [pull-requests](<https://devfeed.tech/tags/pull-requests.md>), [usability](<https://devfeed.tech/tags/usability.md>)

### AI overview

The Gradle team explains how it triages GitHub issues and pull requests at scale. The article describes lessons from using and then removing stale-issue automation, the role of human review, and how issue reports help identify bugs, documentation gaps, and usability problems.

### Source excerpt

Communities are at the heart of Gradle's success. Without their involvement, the build tool would not have the extensive feature set and wide use it has. And using the plural form is no mistake! While the user community is the largest, we also have a community of plugin authors that contribute to extending the capabilities of Gradle. A significant part of interactions between the Gradle team and those communities occurs via feature requests and bug reports using GitHub's issue tracker. Over the past years, we have improved how we handle those reports. We can now give them the attention they deserve and use them to help us improve the build tool across releases. In this post, we'll walk through how triage works today, the changes that got us here, and what you can do to help us help you when you report an issue. An iterative process Back in 2020, we introduced a stale bot to tackle our growing backlog of stale issues. Once it started closing issues, the community feedback was quick to arrive. The biggest complaint was that issues were closed automatically as stale, without a human from the engineering team ever weighing in. So we walked the automation back, step by step. First, we changed the stale bot to no longer close issues, only mark them stale and leave them open for the team to review. Then we reviewed all open issues carrying that label. With the backlog under control, we removed the stale bot for issues altogether. Later, we even re-triaged the closed stale issues that had at least one vote. Most turned out to be duplicates or already fixed. Today, no automation can silently close an issue. What's more, we don't miss any comments under closed issues: if somebody comments on a closed issue, it will be re-triaged. There are still around a thousand issues in our main repository closed by the stale bot. We don't plan to re-triage them, assuming they are obsolete. If the stale bot closed an issue you still care about, just leave a comment and we'll take another l

## Essential Tips for Gradle on Ephemeral CI Environments - Part 3

DevFeed: [Essential Tips for Gradle on Ephemeral CI Environments - Part 3](<https://devfeed.tech/articles/essential-tips-for-gradle-on-ephemeral-ci-environments-part-3-24633.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-on-ephemeral-ci-3>)

Author: Louis Jacomet

Published: 2026-07-09T04:00:00Z

Content type: tutorial

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [Spring Boot](<https://devfeed.tech/topics/spring-boot.md>)

Tags: [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [build](<https://devfeed.tech/tags/build.md>), [cache](<https://devfeed.tech/tags/cache.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-image](<https://devfeed.tech/tags/docker-image.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [performance](<https://devfeed.tech/tags/performance.md>), [spring-boot](<https://devfeed.tech/tags/spring-boot.md>)

### AI overview

This tutorial explains how to optimize Gradle's Execution phase in ephemeral CI environments, focusing on the Gradle Build Cache and task-output reuse. It describes benchmarking a small Spring Boot project in a Docker environment and cautions that the measurements are approximate and specific to Gradle 9.5.1 and the stated test setup.

### Source excerpt

In Part 1 and Part 2, we optimized Gradle's Startup and Configuration phases on ephemeral CI. In this final part, we reach the Execution phase: the point where Gradle checks whether task outputs can be reused and, when they cannot, runs the selected tasks. This is where the Gradle Build Cache becomes the main lever. Benchmarking Performance in Ephemeral CI The methodology is unchanged from Part 1 and Part 2: each scenario builds a fresh Docker image of the Spring Boot Project with --no-cache, base images are pre-pulled, and every figure is the average of ten runs against one consistent baseline. Individual runs vary by a second or two, so read small differences as approximate rather than exact. These numbers are not intended as universal Gradle performance claims. They show the relative impact of execution-phase optimizations for one small Spring Boot project, one Gradle version, one JDK image, and one local Docker environment. Larger builds, especially multi-module builds with expensive compilation, testing, code generation, or packaging tasks, will generally see bigger gains from task-output reuse than this sample project does. NOTE: All measurements in this post are pinned to Gradle 9.5.1. If you repeat the experiment with a newer Gradle version, rebuild the prime image and update any version-specific cache paths accordingly. The baseline (no optimizations) averaged 32.3s over ten runs, in line with the ~31.5s baselines from Parts 1 and 2. Optimizations for the Execution Phase During the Execution phase, Gradle runs the task graph that was selected and ordered during configuration. For each task, Gradle decides whether work can be avoided before it executes task actions: Input and output snapshotting: Gradle fingerprints the task's declared inputs, outputs, and relevant implementation details. Reuse checks: Gradle determines whether the task is already up to date locally, or whether matching outputs can be loaded from the Build Cache. Task action execution: Gradl

## Essential Tips for Gradle on Ephemeral CI Environments - Part 2

DevFeed: [Essential Tips for Gradle on Ephemeral CI Environments - Part 2](<https://devfeed.tech/articles/essential-tips-for-gradle-on-ephemeral-ci-environments-part-2-24632.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-on-ephemeral-ci-2>)

Author: Louis Jacomet

Published: 2026-07-08T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [Spring Boot](<https://devfeed.tech/topics/spring-boot.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [GitHub](<https://devfeed.tech/topics/github.md>)

Tags: [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [build-performance](<https://devfeed.tech/tags/build-performance.md>), [cache](<https://devfeed.tech/tags/cache.md>), [docker](<https://devfeed.tech/tags/docker.md>), [github](<https://devfeed.tech/tags/github.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [jdk](<https://devfeed.tech/tags/jdk.md>), [spring-boot](<https://devfeed.tech/tags/spring-boot.md>)

### AI overview

Part 2 examines Gradle configuration-phase performance in ephemeral CI environments, focusing on dependency and script caching and the roles of the setup-gradle GitHub Action and Develocity Universal Cache.

### Source excerpt

In Part 1, we explored foundational strategies for improving Gradle build performance in ephemeral CI environments, focusing on the Startup and Initialization phase. Now, in Part 2, we shift our focus to the Configuration phase: the work Gradle does after startup but before it executes any tasks. We'll benchmark dependency and script caching, then look at where the setup-gradle GitHub Action and Develocity's Universal Cache fit. Benchmarking Performance in Ephemeral CI The methodology is the same as in Part 1: each scenario builds a fresh Docker image of the Spring Boot Project with --no-cache, base images are pre-pulled, and every figure is the average of ten runs against one consistent baseline. Individual runs vary by a second or two, so read small differences as approximate rather than exact. These numbers are not intended as universal Gradle performance claims. They show the relative impact of configuration-phase optimizations for one small Spring Boot project, one Gradle version, one JDK image, and one local Docker environment. Larger builds, with more dependencies and more build logic, will generally see bigger gains from dependency and script caching than a small sample project does. NOTE: All measurements in this post are pinned to Gradle 9.5.1. If you repeat the experiment with a newer Gradle version, rebuild the prime image and update any version-specific cache paths accordingly. One difference from Part 1: for the Configuration phase, we prime the cache by building the complete Spring Boot Project, not the empty Prime Project. Caching configuration-phase work only means something when there are real dependencies and real build scripts to cache, so the prime image must reflect a realistic project. As in Part 1, that prime image is built once and only restored from, so the timed builds measure cache restore, not cache creation. Building the full project populates the following directories in the Gradle User Home: .gradle/ <-- Gradle User Home (default: ~/.

## Essential Tips for Gradle on Ephemeral CI Environments - Part 1

DevFeed: [Essential Tips for Gradle on Ephemeral CI Environments - Part 1](<https://devfeed.tech/articles/essential-tips-for-gradle-on-ephemeral-ci-environments-part-1-24631.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-on-ephemeral-ci-1>)

Author: Louis Jacomet

Published: 2026-07-07T04:00:00Z

Content type: tutorial

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [containers](<https://devfeed.tech/tags/containers.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [docker](<https://devfeed.tech/tags/docker.md>), [environments](<https://devfeed.tech/tags/environments.md>), [ephemeral](<https://devfeed.tech/tags/ephemeral.md>), [fast](<https://devfeed.tech/tags/fast.md>), [github](<https://devfeed.tech/tags/github.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [persistence](<https://devfeed.tech/tags/persistence.md>), [plugins](<https://devfeed.tech/tags/plugins.md>), [strategies](<https://devfeed.tech/tags/strategies.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [workflows](<https://devfeed.tech/tags/workflows.md>)

### AI overview

Ephemeral CI's disposable agents remove persistent build state, so Gradle optimizations that depend on local reuse need adaptation. The excerpt rates remote build caching, task avoidance, larger heaps, parallel execution, and configuration-phase optimization as effective; dependency-resolution tuning can help but often yields marginal gains. Reusing the dependency cache is fiddly without tooling: setup-gradle provides it on GitHub Actions, while Develocity's Artifact Cache works across CI providers. The article says it benchmarks startup optimizations in fresh Docker containers using one small Spring Boot Kotlin DSL project, one Gradle version, one JDK image, and a local Docker environment. Its measurements are specific to that setup; larger builds may shift the benefits toward dependency resolution, configuration, or execution optimizations.

### Source excerpt

Ephemeral CI replaces long-lived, stateful build agents with short-lived, disposable environments, typically powered by containers and cloud services like GitHub Actions or Docker, to ensure isolated, reliable, and repeatable builds. While this approach improves consistency, security, and scalability, it also eliminates persistent state, requiring new strategies for caching and setup efficiency. This post covers practical strategies to overcome those limitations and keep Gradle fast. With the right optimizations, Gradle's flexibility and tooling support ephemeral workflows well. Common Gradle Optimizations While numerous Gradle optimizations are widely recommended and beneficial in traditional CI, their effectiveness in ephemeral CI environments varies significantly. Many common optimizations rely on persistence and statefulness, making them less effective or more complex to maintain in ephemeral contexts. Here's a closer look at how these popular Gradle optimizations perform in ephemeral CI: # Optimization for Local or Traditional CI Builds Effective in Ephemeral CI? Reason 1 Enable the Build Cache ✅ Highly effective when remote caching is leveraged; local caching alone has limited utility 2 Tailor workflows (task avoidance) ✅ Helpful but requires careful planning and continuous adjustments 3 Increase Gradle's heap size ✅ Immediate benefits without significant setup overhead 4 Enable parallel execution ✅ Efficiently uses cloud resources 5 Optimize the configuration phase (lazy APIs, applying plugins selectively, etc.) ✅ Effective but requires rigorous management of configuration logic 6 Optimize dependency resolution (declarative syntax, remove dynamic versions, etc.) ✅ Helpful, though gains are often marginal in ephemeral CI 7 Re-use the Dependency Cache 🔷 Manual reuse is fiddly; the free setup-gradle action provides it on GitHub Actions, and Develocity's Artifact Cache provides it on any CI 8 Enable the Configuration Cache ✅ Increasingly enabled by default in mod

## You Are Probably Already Running gradle/actions

DevFeed: [You Are Probably Already Running gradle/actions](<https://devfeed.tech/articles/you-are-probably-already-running-gradle-actions-24690.md>)

Original publisher: [Read original article](<https://blog.gradle.org/running-gradle-github-actions>)

Author: Laura Kassovic

Published: 2026-06-30T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [build](<https://devfeed.tech/tags/build.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

gradle/actions is a family of GitHub Actions, with setup-gradle as its centerpiece. The excerpt says more than 45,000 open source repositories use it and that GitHub includes it in its official starter workflow for Gradle projects. On fresh, temporary GitHub Actions runners, setup-gradle helps Gradle avoid repeating downloads and setup work across commits. The excerpt contrasts this with using GitHub's general-purpose cache on the Gradle User Home: that directory contains varied, accumulating state--including dependencies, compiled build-script classes, Gradle distributions and daemon metadata--so treating it as a simple folder of downloaded JARs is inadequate. The provided text ends before explaining how setup-gradle handles that complexity.

### Source excerpt

There is a particular kind of software that you depend on heavily and have never once thought about. It does not have a landing page you have visited. It was not chosen at an architecture review. Nobody sat in a conference room and debated it against three competitors, and no one wrote a blog post titled "Why We Migrated To It." It simply showed up one day, did its job, and has been doing its job on every commit since. A great deal of the build automation running on GitHub is this kind of software. And one of the most widely used examples, if you write anything that touches the Java Virtual Machine, is a small collection of GitHub Actions published by Gradle at gradle/actions. You may not recognize the name setup-gradle. But it's used by more than 45,000 open source repositories, and it's the action baked into GitHub's own official starter workflow for Gradle projects. When you click "Set up a workflow" on a fresh Gradle repo and accept the suggestion GitHub hands you, you are adopting gradle/actions without ever having formed an opinion about it. This is how the most consequential defaults always spread: not by persuasion but by presumption. It is the same mechanism by which much of Europe enrolls organ donors. So: a primer on what the thing does, a tour of who actually runs it in production, and an argument about why the unglamorous parts are the ones worth caring about. What it actually is gradle/actions is not one action. It is a small family of them, and in practice, almost everyone means the same one when they invoke it. The centerpiece is setup-gradle. Its job is to make Gradle run well inside a GitHub Actions runner, which is a fresh, ephemeral machine that has never heard of your project and will be deleted the moment your build finishes. Left to its own devices, that machine re-downloads your dependencies, re-initializes Gradle, and re-does a pile of work it has no memory of having done five minutes ago on the previous commit. setup-gradle is what gives th

## The Four Kotlin Versions in a Gradle Project

DevFeed: [The Four Kotlin Versions in a Gradle Project](<https://devfeed.tech/articles/the-four-kotlin-versions-in-a-gradle-project-24698.md>)

Original publisher: [Read original article](<https://blog.gradle.org/three-kotlin-versions-in-a-gradle-project>)

Author: Laura Kassovic

Published: 2026-06-12T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [gradle-plugin](<https://devfeed.tech/tags/gradle-plugin.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-compiler](<https://devfeed.tech/tags/kotlin-compiler.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

This article explains the four Kotlin versions that can matter in a Gradle project: the Kotlin compiler version selected through the Kotlin Gradle Plugin, the language version targeted for project code, the Kotlin compiler bundled with Gradle for build logic, and the language version Gradle pins for that build logic.

### Source excerpt

Do you know what version of Kotlin your Gradle build is using? There are four Kotlin versions you need to know about in a project built with Gradle. They're easy to mix up, and mixing them up can lead to some confusion (and the occasional compiler error). The trick is that there are really only two compilers in play, and each one carries its own language-version dial. Two compilers, two dials, four numbers. Let's take them one at a time. This post was updated on June 16, 2026. 1. The Kotlin that compiles your code This is the version most people look for. If your application or library code is written in Kotlin and gets compiled by the Kotlin Gradle Plugin, you pick its version in your build: // build.gradle.kts plugins { kotlin("jvm") version "1.9.25" } Change the KGP version, and you change the Kotlin compiler used to compile your project. This is the version you control directly. 2. The Kotlin language version for your code Picking the KGP version chooses which compiler runs over your code. But that compiler has a second dial: the language version, which decides what Kotlin syntax it will accept. You set it through KGP: // build.gradle.kts kotlin { compilerOptions { languageVersion = KotlinVersion.KOTLIN_1_8 } } By default it matches the language version associated with your KGP version, so most projects never touch it. You can pin it lower, for example to keep a library compilable by projects still on an older Kotlin. #1 is the compiler; this is the language level you ask that compiler to target. 3. The Kotlin embedded in Gradle (that compiles your build logic) Now the other compiler. Gradle ships its own Kotlin compiler and standard library inside the distribution. It's the compiler that builds your Kotlin DSL scripts and Gradle-managed build logic, and its standard library is available on the classpath used by build scripts and plugins. You never declare this one. It comes bundled with whatever Gradle version you use. In Gradle 9.6.0: # gradle/wrapper/gradle-w

## How AWS Powers Gradle's Open Source Build Tool

DevFeed: [How AWS Powers Gradle's Open Source Build Tool](<https://devfeed.tech/articles/how-aws-powers-gradle-s-open-source-build-tool-24641.md>)

Original publisher: [Read original article](<https://blog.gradle.org/how-aws-powers-gradle-open-source>)

Author: Bo Zhang

Published: 2026-06-09T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Security](<https://devfeed.tech/topics/security.md>), [AWS IAM](<https://devfeed.tech/topics/aws-iam.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>), [Amazon Elastic Kubernetes Service](<https://devfeed.tech/topics/amazon-elastic-kubernetes-service.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [OpenID connect (OIDC)](<https://devfeed.tech/topics/oidc.md>)

Tags: [amazon-ec2](<https://devfeed.tech/tags/amazon-ec2.md>), [amazon-eks](<https://devfeed.tech/tags/amazon-eks.md>), [amazon-rds](<https://devfeed.tech/tags/amazon-rds.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-identity-and-access-management-iam](<https://devfeed.tech/tags/aws-identity-and-access-management-iam.md>), [ci](<https://devfeed.tech/tags/ci.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [oidc](<https://devfeed.tech/tags/oidc.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [security](<https://devfeed.tech/tags/security.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The article explains how AWS supports Gradle's open source build tool, including plugin distribution through Amazon S3, large-scale builds and tests on Amazon EC2 and Amazon EKS, performance tracking with Amazon RDS, and layered security and observability services.

### Source excerpt

The Gradle Build Tool runs a lot of the world's software. Millions of developers use it every day, and almost every Android app on your phone was built with it. So somebody, somewhere, is kicking off a Gradle build right now. And the next one. And a thousand more in the next minute. For all of them, it has to be fast, and it has to be there. That isn't free. Behind the open source project sits a plugin portal serving hundreds of millions of downloads a month, a CI fleet running millions of tests, a performance lab watching for regressions, and the security tooling that guards a supply chain a lot of the industry depends on. All of it runs on AWS. Here's how. Downloading plugins The Gradle Plugin Portal at plugins.gradle.org is where the community publishes the plugins that extend Gradle. Every plugin JAR it serves (thousands of them, downloaded around 200 million times a month) lives in Amazon S3. That's what lets us be the front door for the plugin ecosystem without running a fleet of file servers ourselves. Building and testing Gradle itself Most of our AWS bill goes here. Every commit to Gradle triggers hundreds of separate builds and tens of thousands of tests across our supported operating systems and architectures. That fleet runs on: Amazon EC2, with auto-scaling to match capacity to demand. Amazon EKS, which orchestrates our containerized Test Distribution agents. Amazon ECR, which stores the agent container images. Keeping Gradle fast A build tool only earns trust if it stays fast. Every commit runs through our performance test suite, and the results land in Amazon RDS, where we compare against history and catch regressions before they reach users. Securing the build Protecting a build tool means protecting a supply chain. Our CI authenticates to AWS through AWS Identity and Access Management (IAM) with GitHub OIDC. That gives us keyless, short-lived credentials, and any secrets we still need are pulled on demand from AWS Secrets Manager and AWS Systems Man

## The (Petty) Reason We Didn't End Up Using jj

DevFeed: [The (Petty) Reason We Didn't End Up Using jj](<https://devfeed.tech/articles/the-petty-reason-we-didn-t-end-up-using-jj-24697.md>)

Original publisher: [Read original article](<https://blog.gradle.org/the-petty-reason-we-didnt-end-up-using-jj-at-gradle>)

Author: Laura Kassovic

Published: 2026-06-02T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Git](<https://devfeed.tech/topics/git.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Windows](<https://devfeed.tech/topics/windows.md>), [Batch file](<https://devfeed.tech/topics/batch-file.md>)

Tags: [batch](<https://devfeed.tech/tags/batch.md>), [git](<https://devfeed.tech/tags/git.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [version-control](<https://devfeed.tech/tags/version-control.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

The article explains why Gradle did not adopt Jujutsu (jj) as a replacement for Git in a developer's workflow. The blocker is Jujutsu's lack of support for the per-file line-ending rules in .gitattributes, which causes persistent phantom modifications to gradlew.bat in Gradle repositories.

### Source excerpt

Jujutsu (jj) has been picking up steam as a Git-compatible version control system. When used with its Git backend, jj stores commits and files in Git and works with existing Git repositories, but it does away with the staging area so your working copy is represented as a real commit that updates as you go. Rewriting history is cheap and safe: edit or reorder a commit and jj rebases its descendants for you; conflicts can be recorded instead of halting the operation; and operations can be undone from the operation log. Recently, one of our engineers set out to replace git with jj in their day-to-day flow. Unfortunately, it didn't work out. Not because of anything fundamental about jj's model, but because of a small detail of how Gradle projects are shaped on disk. This is worth writing down, because we suspect a lot of teams in the JVM ecosystem will hit the same wall. The actual blocker: gradlew.bat and .gitattributes A typical Gradle repository ships the Gradle Wrapper, which usually includes gradlew.bat. That script uses labels and goto, which cmd.exe can mishandle when a batch file has LF-only line endings, so gradlew.bat has to be checked out with CRLF to run reliably on Windows. We enforce this with .gitattributes, a file that tells Git how to handle specific files or paths, controlling things like line-ending normalization and whether files are treated as binary or text: *.bat text eol=crlf This is standard Git behavior: the file is stored normalized in the index, and the eol=crlf attribute tells Git to materialize CRLF in the working copy on checkout. Edits are normalized back on the way in. You forget about it after the first commit. jj doesn't read .gitattributes, so it can't apply a per-file rule. There's a long-standing issue (jj-vcs/jj#53) tracking support for at least the eol attribute, but until it lands jj's only lever is the global working-copy.eol-conversion setting. That's the rough equivalent of Git's core.autocrlf: it applies to every file at once

## How Gradle Is Javamaxxing

DevFeed: [How Gradle Is Javamaxxing](<https://devfeed.tech/articles/how-gradle-is-javamaxxing-24628.md>)

Original publisher: [Read original article](<https://blog.gradle.org/gradle-is-javamaxxing>)

Author: Laura Kassovic

Published: 2026-05-28T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Java](<https://devfeed.tech/topics/java.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [bytecode](<https://devfeed.tech/tags/bytecode.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [garbage-collectors](<https://devfeed.tech/tags/garbage-collectors.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [java](<https://devfeed.tech/tags/java.md>), [java-8](<https://devfeed.tech/tags/java-8.md>), [jdk](<https://devfeed.tech/tags/jdk.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance-optimization](<https://devfeed.tech/tags/performance-optimization.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

Gradle aggressively adopts new JDK releases because newer JVMs can improve build speed, memory use, startup behavior, and maintainability. JVM toolchains allow Gradle to run on JDK 26 while compiling and testing projects for older Java versions, including producing Java 8-compatible bytecode.

### Source excerpt

Some people optimize one part of their lives to the absolute limit, then past it. They call it "-maxxing." Houseplantmaxxing. Sleepmaxxing. Tokenmaxxing. The Gradle Build Tool is Javamaxxing. TL;DR Breathe easy knowing you can run modern Gradle on JDK 26 while still shipping Java 8-compatible artifacts: Gradle aggressively adopts new JDKs because newer JVMs make builds faster, leaner, and easier to maintain. Upgrading the JDK that runs Gradle is often the easiest performance win. JVM toolchains fully separate the JVM running Gradle, the JVM compiling your code, and the JVM running your tests. NOT TL;DR We aggressively adopt new JDK releases as soon as we responsibly can. Not because it's trendy. Because newer JDKs make Gradle faster, leaner, and easier to maintain. Every OpenJDK release ships improvements to the JVM; garbage collectors, compiler infrastructure, startup behavior, memory layout, and runtime APIs. As a high-performance JVM build tool, Gradle benefits directly from all of it. The question people immediately ask is: Does this mean my project also has to run on the newest JDK? No. That coupling effectively disappeared once Gradle introduced JVM toolchains. With toolchains, the JVM that runs Gradle is completely separate from the JVM that compiles, tests, and executes your code. You can run Gradle on JDK 26 today and still produce Java 8 bytecode. What Is the Current State of Gradle and Java? We add daemon support for every new JDK as soon as the ecosystem permits: Java 24 in Gradle 8.14.0, Java 25 in 9.1.0 (released two days after JDK 25 GA), Java 26 in 9.4.0. The full mapping is in the Compatibility Matrix. We then bump the minimum JVM required to execute Gradle as users move. Gradle 9.0.0, released on July 31, 2025, raised the minimum JVM required to run the Gradle daemon to Java 17. That was the first daemon JVM floor increase since Gradle 5.0 made Java 8 the minimum back in 2018. The next major transition is already underway, Gradle 10.0.0 will likely

## Achieving Fast Inner Dev Loops with Gradle: Configuration Cache and Beyond

DevFeed: [Achieving Fast Inner Dev Loops with Gradle: Configuration Cache and Beyond](<https://devfeed.tech/articles/achieving-fast-inner-dev-loops-with-gradle-configuration-cache-and-beyond-24617.md>)

Original publisher: [Read original article](<https://blog.gradle.org/fast-inner-dev-loops-with-gradle>)

Author: Alex Semin

Published: 2026-05-20T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [developer-productivity](<https://devfeed.tech/topics/developer-productivity.md>), [build performance](<https://devfeed.tech/topics/build-performance.md>), [build times](<https://devfeed.tech/topics/build-times.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [build](<https://devfeed.tech/tags/build.md>), [build-tool](<https://devfeed.tech/tags/build-tool.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [context](<https://devfeed.tech/tags/context.md>), [developer-productivity](<https://devfeed.tech/tags/developer-productivity.md>), [flow](<https://devfeed.tech/tags/flow.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [incremental](<https://devfeed.tech/tags/incremental.md>), [kotlinconf](<https://devfeed.tech/tags/kotlinconf.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [productivity](<https://devfeed.tech/tags/productivity.md>)

### AI overview

This article explains how Gradle is working to accelerate inner developer loops. It describes the shift from execution time to configuration time as the main build bottleneck in large codebases, while highlighting configuration cache, incremental builds, build cache, and parallelism as approaches to reduce waiting and preserve developer flow.

### Source excerpt

How many engineers in your organization have to sit idle for 10 or more minutes just to rebuild the app locally after a small change? If you're an engineering leader, build engineer, or part of a developer productivity team, you're not alone in facing this challenge. Building complex software is inherently demanding, but the time your developers spend waiting has a profound impact beyond just the literal minutes lost. It fundamentally disrupts their psychological flow. "There are like these time scales of psychological flow, right? So if something takes longer than a minute, you already start planning for it... you suffer from context switch as well. If it's 1 second, that's where we want to be right in that seamless state of flow. And if it's less than one second, then you feel it's like magic... productive developers are happy developers." -- Rodrigo Oliveira When developers have to wait, their attention drifts, and the cost of context switching destroys their momentum. Our goal as enablers of developer productivity should be to eliminate this friction, bringing that feedback loop as close as possible to the "magical one second". In a recent presentation at KotlinConf 2025, Gradle engineers Rodrigo Oliveira and Alex Semin detailed how Gradle Build Tool is evolving to keep developers in that productive, happy "flow state". By tackling the most significant bottlenecks in modern software builds, Gradle is paving the way for incredibly fast inner developer loops. If you prefer to watch the presentation recording, you can find it here. The shifting bottleneck: From execution to configuration On every invocation, Gradle goes through three distinct phases: initialization, configuration, and execution. Historically, when we optimized Gradle builds, we focused almost exclusively on the execution phase. This is when the majority of work expected by a developer happens: production sources compilation, test execution, etc. For years, execution was the longest phase. We tackled thi

## Choice, Clarity, and the Future of Caching in Gradle Actions

DevFeed: [Choice, Clarity, and the Future of Caching in Gradle Actions](<https://devfeed.tech/articles/choice-clarity-and-the-future-of-caching-in-gradle-actions-24602.md>)

Original publisher: [Read original article](<https://blog.gradle.org/choice-clarity-future-caching-gradle-actions>)

Author: Daz DeBoer

Published: 2026-04-03T04:00:00Z

Content type: release

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [Gradle](<https://devfeed.tech/topics/gradle.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [cache-invalidation](<https://devfeed.tech/topics/cache-invalidation.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Library](<https://devfeed.tech/topics/library.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [actions](<https://devfeed.tech/tags/actions.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [basic](<https://devfeed.tech/tags/basic.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [choice](<https://devfeed.tech/tags/choice.md>), [data-ownership](<https://devfeed.tech/tags/data-ownership.md>), [future](<https://devfeed.tech/tags/future.md>), [github](<https://devfeed.tech/tags/github.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [keys](<https://devfeed.tech/tags/keys.md>), [library](<https://devfeed.tech/tags/library.md>), [license](<https://devfeed.tech/tags/license.md>), [licensing](<https://devfeed.tech/tags/licensing.md>), [metadata](<https://devfeed.tech/tags/metadata.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [mit](<https://devfeed.tech/tags/mit.md>), [open](<https://devfeed.tech/tags/open.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [opt-out](<https://devfeed.tech/tags/opt-out.md>)

### AI overview

Gradle Actions v6.1.0 clarifies cache ownership and restores an open-source caching option. Updated terms say Gradle claims no ownership of cache-entry content; it may collect metadata such as cache keys and usage metrics, while cached data will not be inspected or retained. The new Basic provider is a 100% open-source, path-based wrapper over GitHub's actions/cache, allowing users to opt out of the proprietary library with configuration. Enhanced Caching remains the default. The stated rationale for its proprietary core is to support planned features including Gradle Configuration Cache support and improved Gradle User Home cleanup.

### Source excerpt

Since the release of gradle/actions v6, we've been listening closely to the feedback from the community. It's clear that while we were focused on building the next generation of caching for Gradle, we missed the mark on how we communicated the changes to licensing that came with the release. As the maintainer of this project, my goal is to ensure this action remains a tool the community trusts. Today, we are releasing version 6.1.0, which puts transparency and user choice at the forefront. 1. Data Ownership: The "Safe Harbor" Clause The most significant concern we heard was that our new license terms were overly broad, leading some to fear that Gradle might claim ownership of the cached data processed by the action. Let me be clear: Your code and artifacts belong to you. Period. To formalize this, we have updated the Gradle Technologies Terms of Use to include a Safe Harbor clause specifically for cached content. This clause explicitly confirms that Gradle claims no ownership of the content of your cache entries. We may collect metadata (such as cache keys) and usage metrics to facilitate and improve the caching service, but the actual cached data will not be inspected or retained. For more details on licensing of gradle/actions and gradle-actions-caching, please see our new Distribution & Licensing Guide. 2. Restoring Choice: The "Basic" Caching Provider In v6.0, we introduced Enhanced Caching via the proprietary gradle-actions-caching component as the only caching option with setup-gradle. We understand that for some, having a 100% open-source path is a requirement, not a preference. In v6.1, we are introducing a Basic Caching provider. This is a 100% open-source thin wrapper over actions/cache. It provides reliable, path-based caching backed by GitHub. You now have a choice. If you prefer to stay entirely within the MIT-licensed ecosystem, you can opt out of the proprietary library with one line of configuration: - uses: gradle/actions/setup-gradle@v6 with: cache

## GitHub Actions for Gradle v6: What's Changing and Why

DevFeed: [GitHub Actions for Gradle v6: What's Changing and Why](<https://devfeed.tech/articles/github-actions-for-gradle-v6-what-s-changing-and-why-24620.md>)

Original publisher: [Read original article](<https://blog.gradle.org/github-actions-for-gradle-v6>)

Author: Gradle Build Tool

Published: 2026-03-24T04:00:00Z

Content type: article

Language: en

Sources: [Gradle](<https://devfeed.tech/sources/the-gradle-blog.md>)

Topics: [GitHub Actions](<https://devfeed.tech/topics/github-actions.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Continuous integration](<https://devfeed.tech/topics/continuous-integration.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [blog-post](<https://devfeed.tech/tags/blog-post.md>), [cache](<https://devfeed.tech/tags/cache.md>), [caching](<https://devfeed.tech/tags/caching.md>), [ci](<https://devfeed.tech/tags/ci.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [github-actions](<https://devfeed.tech/tags/github-actions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

This article announces v6 of GitHub Actions for Gradle builds. The Gradle User Home caching functionality has been extracted from setup-gradle into the closed-source gradle-actions-caching library, while the rest of the action remains open source and workflows continue to function without new functional restrictions. v6 also removes experimental Configuration Cache support, which is being reworked for broader project compatibility.

### Source excerpt

UPDATE: We published a follow-up to this post -- Choice, Clarity, and the Future of Caching in Gradle Actions Today, we're releasing v6 of GitHub Actions for Gradle builds, with an important change to how the caching component is licensed. In this blog post, we explain what's changing, what it means for you, and where we're headed. GitHub Actions for Gradle builds is a collection of GitHub Actions that makes it easy to configure and run Gradle builds on GitHub Actions CI. The centerpiece is setup-gradle, which provides a convenient way to invoke Gradle in GitHub Actions workflows with sophisticated, efficient caching across invocations, GitHub Dependency Graph support, automatic capture of Build Scan® links, and more. It's used by over 45,000 open source repositories and is featured in GitHub's official starter workflows. Since its introduction, GitHub Actions for Gradle builds, including the caching implementation in setup-gradle, have been fully open source under the MIT license. That changes with v6. What's changing Starting with v6, the functionality of setup-gradle that saves and restores Gradle User Home state has been extracted to gradle-actions-caching, a closed-source library distributed under our Terms of Use. The rest of the action remains open source. While the caching functionality of setup-gradle is now under a proprietary license, we are not introducing any functional restrictions in this release. Your workflows will continue to function as before. The only functional change in v6 is the removal of the experimental Configuration Cache support. It was not production-ready and worked only for a limited set of projects. We're reworking this feature so that it works for most projects and more users can benefit (more on this below). To upgrade, simply update your workflow files to reference v6: - uses: gradle/actions/setup-gradle@v6 By upgrading to v6, you accept the Terms of Use for the gradle-actions-caching component. Why we're making this change Support

[Next page](<https://devfeed.tech/sources/the-gradle-blog.md?cursor=WyIyMDI2LTAzLTI0VDA0OjAwOjAwKzAwOjAwIiwgIjM3M2I1NDM0LTY5NzUtNGI4Yi04Yjg5LTFhNTU0NWJhNjFiZCJd>)