source: .forge/discovery/research/java-25-readiness.md · generated — edit the markdown, not this file

Java 25 readiness — toolchain assessment

As of 2026-08-23. Advisory, point-in-time. Every version claim below is dated and sourced; re-verify before acting, because tool support for a new JDK major moves week to week. This document changes no pin — AD #1 (Java 21) and AD #25 (the deliberately moving Boot/JDK pin) remain the decision authority. Companion: virtual-threads-evaluation.md.

The question

Is the backend toolchain (forge-et-be) ready for a future Java 21 → 25 bump?

Bottom line — GO

No hard blocker as of this date. Every pinned component either already supports JDK 25 at the exact version this repo resolves, or is satisfied by a one-line version touch. Two small housekeeping items fold into the bump commit; neither blocks it.

Context that makes this unsurprising: Java 25 is the LTS released 16 Sep 2025 (~11 months old now), so the historically-laggy pieces — the javac-internals stack (Lombok, Error Prone, NullAway, palantir-java-format) and Groovy/Spock — have all had time to catch up, and have.

Two senses of “the bump” — both are ready

  • Run the Gradle daemon on JDK 25, still emitting Java 21 bytecode (toolchain languageVersion stays 21). Low-stakes; already fully supported.
  • Move the language/bytecode target to 25 (toolchain languageVersion 21 → 25 in buildSrc/src/main/groovy/et.java-conventions.gradle) — the real AD #1 change.

The formatter caveat below bites as soon as the daemon runs on 25, even before the bytecode target moves — so it applies to both senses.

Component readiness

Pins are the versions this repo actually resolves as of 2026-08-23: build files for the explicit pins, committed gradle.lockfiles for the Boot-BOM-managed ones (the data-tier libraries come from the feature/FS-2-data-layer worktree, where the JPA stack is being wired).

Component Repo pin (2026-08-23) Java 25? Floor / note Source
Spring Boot 4.1.1 ✅ Yes Supports Java 17–26; JDK 25 is first-class Spring system requirements; Boot 4.0 release
Gradle 9.7.1 ✅ Yes JDK 25 (daemon + toolchain) since 9.1.0; matrix tops out at Java 26 Gradle compatibility matrix (docs v9.7.1)
Lombok 1.18.46 (Boot-BOM) ✅ Yes JDK 25 support added in 1.18.42 (Sep 2025); the resolved version is past it Lombok changelog
Groovy 5.0.8 (Boot-BOM) ✅ Yes Groovy 5 tested on JDK 11–25 Groovy 5.0 release notes
Spock 2.4-groovy-5.0 ✅ Yes Runs on Groovy 5; ships JDK-25 detection (Jvm.isJava25) Spock 2.4 API
Hibernate ORM 7.4.5.Final (Boot-BOM) ✅ Yes Rides on ByteBuddy 1.18.11 (below) lockfile; see data-tier note
Spotless (plugin) 8.10.0 ✅ Yes The Gradle plugin runs fine on JDK 25; the catch is its bundled formatter default ↓ buildSrc/build.gradle
palantir-java-format (the CI format gate) 2.71.0 (Spotless default — not explicitly pinned) ⚠️ Yes, but at the floor The fix to run on JDK 25 landed in 2.71.0 exactly; current release is 2.97.0 (6 Aug 2026) SLING-12947; palantir releases
Error Prone not wired yet (arrives FS-4) ✅ Yes at current 2.32.0 broke on JDK 25 (NoSuchFieldError in javac TypeTag); current 2.50.0 supports JDK 25/26-EA; min JDK-to-run is 21 Error Prone releases
NullAway not wired yet (arrives FS-4) ✅ Yes at current 0.13.0+ tests on JDK 25; requires Error Prone ≥ 2.36.0. Current 0.14.0 NullAway CHANGELOG
Testcontainers Boot-BOM-managed (arriving with the data tier) ✅ Yes (low-risk) Docker-client library — no bytecode-generation coupling to the JVM version; confirm the resolved version at bump time Testcontainers for Java

Why the data tier is genuinely clear (the part that usually bites)

The classic JDK-major laggard is ByteBuddy — the library Hibernate uses to rewrite entity classes at runtime. A new Java release means a new class-file version (Java 25 = class-file 69), and ByteBuddy has to bless it; before it does, you are stuck on -Dnet.bytebuddy.experimental=true, which can silently emit wrong bytecode.

Good news, straight from the feature/FS-2-data-layer lockfiles — the Boot 4.1.1 BOM already resolves:

  • ByteBuddy 1.18.11 — JDK 25 support landed in 1.17.0 (ASM 9.8, class-file 69), so this is comfortably past the floor (SPARK-51205).
  • HikariCP 7.0.2 — modern; the pre-5.x synchronized-acquisition issues are long gone.
  • Hibernate ORM 7.4.5.Final, Flyway 12.4.0, PostgreSQL JDBC 42.7.13 — all current and JDK-25-fine.

So the data layer FS-2 is building carries no Java 25 debt.

The two things to do in the bump commit (housekeeping, not blockers)

  1. Pin palantir-java-format explicitly; don’t inherit the floor. Spotless 8.10.0 provisions palantir-java-format at its bundled default, which sits at 2.71.0 — exactly the minimum that runs on JDK 25. It works, but it is the oldest version that does, and it is implicit. Make it explicit and current in buildSrc/src/main/groovy/et.quality-conventions.gradle: palantirJavaFormat('2.97.0'). Do the same courtesy for the Groovy side — greclipse('4.40') formats the Spock specs; confirm it runs on JDK 25 and bump if not. This matters the moment the daemon runs on 25, because Spotless’s formatter runs inside the daemon JVM.
  2. Wire Error Prone + NullAway at current versions. They are not in the build yet (they arrive at FS-4). Whenever they land, use current (Error Prone 2.50.0 / NullAway 0.14.0) — both already support JDK 25/26. There is no old pin here to be trapped by; the only failure mode is choosing a stale version, which the FS-4 work should simply avoid.

A note on “parsing Java 25 syntax”

The format gate has two distinct requirements: run on JDK 25 (cleared — palantir 2.71.0+), and parse Java 25 language features in source. The second is a non-issue in practice here: the codebase targets bytecode 21 and, per coding-standards §0 (“simple, boring, deletable”), is not reaching for bleeding-edge Java 25-only syntax. If that ever changes, the same explicit palantir pin (current 2.97.0) covers it.

Consistency with AD #1 / AD #25

AD #1 fixes the bytecode target at Java 21; AD #25 frames the version pin as a deliberate, roughly-annual, tested move onto a supported line. A 21 → 25 bump fits that exactly:

  • Java 25 is an 8-year LTS — aligns with AD #25’s “take a supported line, don’t settle on a soon-to-be-EOL one” logic.
  • The change is a single languageVersion = JavaLanguageVersion.of(25) in et.java-conventions.gradle, bundled with the two version touches above, and proven green through the existing Fast/Slow lanes in one commit — the same low-blast-radius discipline that made the Boot 3.5 → 4.1 move ~40 lines.

Verdict

GO whenever the team chooses to schedule it. No component is not-ready. The move is: bump the toolchain, explicitly pin the two formatter/checker versions in the same commit, run the lanes. Nothing here is gating.

Sources

Generated from .forge/discovery/research/java-25-readiness.md by .claude/lib/render-docs-html.js. Markdown is canonical.