Accelerating the GraalVM Release Train

Software is moving faster than ever, fueled by AI and rapidly evolving developer tools. To keep pace and get new features and improvements into your hands sooner, we are accelerating the GraalVM release schedule. We are introducing monthly feature releases while continuing to provide quarterly Critical Patch Updates (CPUs) and maintaining one stable release train per major version.

What this means moving forward:

• Oracle GraalVM 25.0 will continue to receive security and minor bug fixes and remains the stable release train.
• GraalVM 25.1+ will provide monthly feature releases for users who want new features sooner. We intend to ship 25.1 in May 2026, followed by 25.2, 25.3, and subsequent releases in the months that follow.

What’s changing

• GraalVM Community Edition previously shipped feature releases every six months, with each receiving two quarterly CPUs before being superseded by the next feature release. Going forward, GraalVM Community Edition will switch to monthly feature releases, incorporating CPUs when they are available each quarter.
• Feature releases for both Oracle GraalVM and GraalVM Community Edition will now ship monthly on the 25.1+ release train. Feature releases are fully tested to ensure stability.

What stays the same

• Quarterly CPUs remain aligned with Oracle and OpenJDK schedules, and all active releases receive the relevant security baseline.
• Weekly Early Access (EA) builds will continue be made available to provide a channel for pre-GA feedback.

Why we’re doing this

Monthly releases reduce the time from idea to impact. Smaller, more frequent drops make it easier for you to try features and provide actionable feedback, which helps us iterate faster. The ecosystem around AI-enhanced development and runtime optimization evolves weekly, and our cadence should reflect that reality. At the same time, security updates remain predictable through quarterly CPUs aligned with the broader Oracle and OpenJDK ecosystem.

Schedule for adopting new features for GraalVM languages

We pick up new features for GraalVM languages once the language is stabilized and starts seeing adoption from the library ecosystem. For Python, this generally means we support a Python version when it enters the security-fix phase (yellow) in the release chart below. The current supported version of Python in GraalVM is Python 3.12, which entered yellow in 2025. Python 3.13 will be supported in 2026.

For JavaScript, a new ECMAScript standard is generally published each June, with support in GraalVM implemented within a few months. This will continue.

The Java library ecosystem generally does not support anything other than Java LTS releases, so as previously announced, there are no plans for GraalVM releases of JDK 26, 27, or 28. GraalVM will track upstream changes and plans to provide Java 29 support shortly after its release.

Understanding release numbers

GraalVM continues to follow the JDK version numbering scheme described in JEP 223 (MAJOR.MINOR.SECURITY). The MAJOR number indicates the Java language specification baseline. The MINOR number indicates the feature release train, such as 25.1, 25.2, and so on. The SECURITY number indicates the CPU level from the underlying JDK update, for example, .3 for April 2026.

What this looks like on the calendar

Oracle GraalVM 25 LTS

Updates for Oracle GraalVM 25 (LTS) continue to be released on the regular quarterly CPU schedule. For example, in 2026 there are four CPU releases:

• January 20th: 25.0.2
• April 21st: 25.0.3
• July 21st: 25.0.4
• Oct 20th: 25.0.5

GraalVM feature releases

Monthly features releases for Oracle GraalVM and GraalVM Community Edition follow the same minor feature/security level numbering. Each quarter, a feature release will include the latest JDK Critical Patch Updates (CPU), which is reflected in version’s SECURITY digit. For example:

• May 2026 (Feature): 25.1.3
• June 2026 (Feature): 25.2.3
• July 2026 (Feature + CPU): 25.3.4
• Aug 2026 (Feature): 25.4.4
• …

See the Release Calendar for exact CPU days and planned versions: https://www.graalvm.org/release-calendar/

What’s coming in monthly feature releases

We will use the monthly 25.1+ feature line to deliver incremental capabilities across Native Image and language runtimes. The following highlights are in focus.

Truffle — New Bytecode Interpreters are rolling out to GraalPy, GraalJS, and GraalWasm. These interpreters improve warmup performance and reduce memory footprint significantly before JIT compilation is performed. See https://github.com/oracle/graal/blob/master/truffle/docs/bytecode_dsl/BytecodeDSL.md

GraalPy (Python) — the major focus is on the bytecode interpreter and other optimizations to improve Python warmup as well as to reduce the cost of native method crossing. We continue to improve ecosystem compatibility and JVM interop (for example, support for using `java.util.List` as a Python list object). See https://www.graalvm.org/python/

Native Image — Layers improves deployment by enabling layered native images with shared base layers that include the JDK, frameworks, and libraries. These layers can be mapped and reused to reduce memory usage and improve container efficiency. See https://github.com/oracle/graal/issues/7626 for more information.

Native Image — Crema enables an “Open World” model that supports dynamic class loading and execution at run time. It adds a bytecode interpreter and JIT compiler for classes loaded dynamically on top of an AOT compiled base layer. See https://github.com/oracle/graal/issues/11327 for details.

Native Image — Terminus makes the native-image tool self-hosting so the tool itself runs natively. It relies on a strong separation of host and guest heaps via Espresso and aims to deliver faster and more portable builds. See https://github.com/oracle/graal/issues/12236 for more information.

Native Image — Web Image targets WebAssembly to produce Wasm modules, plus a JavaScript wrapper, so JVM applications can run in browsers or in Node.js. See https://www.graalvm.org/latest/reference-manual/web-image/ for details.

GraalJS (JavaScript/Node) — modern ECMAScript support and first class embedding in polyglot scenarios. See https://www.graalvm.org/latest/reference-manual/js/

GraalWasm (WebAssembly) — execute and embed Wasm modules inside JVM applications for safe, high performance plugin architectures. See https://www.graalvm.org/webassembly/docs/

Guidance for different users

• Production applications should remain on the 25.0 LTS release train and upgrade to the latest CPU each quarter.
• Applications on feature trains can adopt monthly feature releases on their own schedule to pick up new capabilities, but for maximum security should always upgrade to a release with the latest CPU.
• Framework, library, and tooling authors should find monthly releases incremental and predictable. We will pre-announce noteworthy changes in EA and we welcome coordination during CPU weeks.
• Early adopters are encouraged to try EA builds for upcoming monthlies to validate changes against their workloads and to provide feedback earlier.

Frequently asked questions

• How do security fixes flow into monthly releases ?
  For each release, the third version digit (i.e., the SECURITY digit) matches the JDK CPU level. After each CPU Tuesday, the next monthly feature release carries that CPU level, for example 25.3.4 in July 2026.
• How long is each monthly 25.1+ feature release supported?
  Each feature release is superseded by the next one. We do not backport fixes to older feature releases, so users should upgrade forward.
• Will there be backports to earlier monthly releases?
  No, users should upgrade forward to the latest monthly release to receive bug fixes and security patches. However, Oracle GraalVM 25.0 customers continue to receive support per policy on LTS lines.

All aboard!

We all need to move faster, so join us on the new high-speed GraalVM release train!

Try Early Access builds and tell us what works and what does not. Adopt monthly feature releases to unlock improvements sooner. Stay current on CPUs for the latest security fixes.