What's New in Java 26: New Features, Changes, and What Comes Next

Java 26 is officially here. Scheduled for general availability on March 17, 2026, this release marks the first non-LTS (Long-Term Support) release since Java 25 — and it delivers ten new JEPs (JDK Enhancement Proposals) spanning language improvements, garbage collection upgrades, security enhancements, and more. 

Whether you're still evaluating Java 25 for your production environment or already tracking what's next on the roadmap, understanding what Java 26 brings to the table helps you plan smarter upgrade paths and adopt new capabilities with confidence. 

Read this blog post for a breakdown of the incubator, preview, and permanent JEPs included in JDK 26.  

What is Java 26?

Java 26 was released on March 17, 2026. It is a short-term release version, and will receive support for six months.  

Java 26 succeeds Java 25, although that is still the currently supported Java LTS version. Short-term releases for Java come out every six months, while LTS releases come out every other year. As a part of its long-term support policy, Oracle offers quarterly bug fixes and version support for an extended duration for these Java LTS releases. 

Java's six-month release cadence means the platform moves fast. Each non-LTS release (including Java 26) serves as a proving ground for the features that will define future LTS versions — making it essential for developers to stay informed, even when not adopting every release in production. 

🔎 Wondering how Java LTS impacts you? Read this blog. 

Enhancements Included in Java 26

Java 26 ships with ten JEPs, across five categories: core Java library, HotSpot, Java language specification, security library, and client library. Together, these JEPs add new functions and capabilities to the Java language.  

Core Java Library

The core libraries consist of classes which are used by many portions of the JDK. The majority of the JEPs in Java 26 address the Core Java Library: 

• JEP 500: Prepare to Make Final Mean Final 
• JEP 517: HTTP/3 for the HTTP Client API 
• JEP 525: Structured Concurrency (Sixth Preview) 
• JEP 526: Lazy Constants (Second Preview) 
• JEP 529: Vector API (Eleventh Incubator) 

HotSpot

The Java HotSpot Virtual Machine optimizes Java application performance by using a JIT compiler to detect frequently executed code, then compiles them into native machine code. Two JEPs address HotSpot: 

• JEP 516: Ahead-of-Time Object Caching with Any GC 
• JEP 522: G1 GC: Improve Throughput by Reducing Synchronization 

Java Language Specification

The Java Language Specification (JLS) describes all aspects of the Java programming language, including its syntax, semantics, and memory model. One JEP addresses the Java Language Specification in Java 26: 

• JEP 530: Primitive Types in Patterns, instanceof, and switch (Fourth Preview) 

Security Library

The JDK provides a comprehensive set of built-in security APIs for various functions. One JEP addresses the Security Library: 

• JEP 524: PEM Encodings of Cryptographic Objects (Second Preview) 

Client Library

The Client Library enables Java applications to work with external APIs, services, etc. One JEP deprecates a feature: 

• JEP 504: Remove the Applet API 

What Is a JEP and Why Does It Matter?

A JEP, or Java Enhancement Proposal, is a formalized method for adding new features into the Java language on a preliminary, preview, or permanent basis. Further, there are incubator, preview, and permanent JEPs included in Java 26.  

A Closer Look at the Incubator JEPs in JDK 26

There is one incubator JEP in JDK 26: Vector API.  

JEP 529: Vector API (Eleventh Incubator) 

The Vector API continues its long incubation journey. First introduced in Java 16, it has now reached its eleventh incubation round in Java 26, with no substantial implementation changes since Java 25. 

The vector API introduces a mechanism for expressing vector computations that compile reliably at runtime to optimal vector instructions on supported CPU architectures. The result is performance that far exceeds equivalent scalar computations—a significant advantage for data-intensive workloads. 

The Vector API will remain in incubation until key features from Project Valhalla become available as preview features. At that point, the team will adapt the API accordingly and promote it to a preview JEP.  

A Closer Look at the Preview JEPs in JDK 26

There are five Preview JEPs in Java 26. Together, they introduce and codify new features in the Java language.  

JEP 525: Structured Concurrency (Sixth Preview) 

The Structured Concurrency JEP builds upon previews dating back to Java 19. The core idea: treat groups of related tasks running across different threads as a single unit of work. This approach streamlines error handling and cancellation, improves reliability, and makes concurrent code far easier to reason about and observe. 

The key change in this preview is the addition of an onTimeout() method to the StructuredTaskScope.Joiner interface. This method allows implementations to return a result once a timeout expires, which is a practical improvement for real-world concurrent workflows. 

JEP 526: Lazy Constants (Second Preview) 

Lazy Constants, first previewed in Java 25, returns for a second preview in Java 26. The feature introduces a LazyConstant interface, allowing developers to define constants whose values are computed lazily — i.e., only when first accessed — while still being treated by the JVM as true constants after initialization. 

This enables the JVM to apply the same aggressive optimizations it uses for compile-time constants, even in cases where the constant's value can only be determined at runtime. 

JEP 530: Primitive Types in Patterns, instanceof, and switch (Fourth Preview)

Under Project Amber, this JEP extends pattern matching to support primitive types, closing the gap between reference types and primitives in pattern contexts. 

Java 26 delivers the fourth preview with two specific changes: 

• An enhanced definition of unconditional exactness for safer type conversions 
• Tighter dominance checks in switch constructs, improving correctness guarantees 

JEP 524: PEM Encodings of Cryptographic Objects (Second Preview)

This JEP introduces a standard API for reading and writing PEM-encoded cryptographic objects, a feature security-minded teams will appreciate. It was first introduced in Java 25 as JEP 470.  

The second preview in Java 26 brings two changes: 

• PEMRecord has been renamed to PEM 
• The PEMEncoder and PEMDecoder classes now support encryption and decryption of KeyPair and PKCS8EncodedKeySpec objects 

This makes working with PEM-formatted keys and certificates significantly cleaner and more consistent across the platform. 

JEP 517: HTTP/3 for the HTTP Client API

The Java HTTP Client API, introduced in Java 11, gains one of its most significant upgrades yet: HTTP/3 support. This brings the multiplexing, reduced latency, and improved performance characteristics of HTTP/3 directly into the standard library, no third-party dependencies needed. 

Removed and Deprecated Features in Java 26

One JEP and several JVM flags are set for deprecation and removal in Java 26.  

JEP 504: Remove the Applet API

The Applet API has been deprecated since Java 9 and deprecated for removal since Java 17;  Java 26 finally completes its removal. If your codebase still references any Applet classes, this is the time to address those dependencies. 

Deprecated JVM Flags

Several JVM flags have been deprecated for removal in Java 26: 

• AlwaysActAsServerClassMachine and NeverActAsServerClassMachine: With G1 set to become the default GC across all environments (via the upcoming JEP 523), these flags serve little practical purpose. 
• AggressiveHeap: Originally added to satisfy specific benchmarks, this flag lacks transparency. Equivalent behavior can be reproduced with a combination of more explicit JVM flags. 
• MaxRAM: Modern JVMs can accurately detect physical RAM and set reasonable limits automatically. Use -Xmx and -Xms instead. 

InitialRAMPercentage Default Value Removed

The InitialRAMPercentage flag has had its default value of 1.5625 removed, now set to 0. The previous default dated back to 2007 and could produce excessively large initial heap sizes on modern hardware. The JVM will now rely on ergonomics to set appropriate values. 

Why Java 26 Matters for Java Developers

Java 26 may not be a Java LTS release, but several of its features directly address developer productivity and performance, including: 

• Faster startup times: The expanded AOT Object Caching support (JEP 516) now works with ZGC, removing a key limitation for teams running latency-sensitive applications on the Z Garbage Collector. 
• Better throughput: G1 GC improvements in JEP 522 reduce synchronization overhead between application and GC threads, delivering up to 15% throughput gains in workloads with heavy object-reference modifications. 
• Cleaner concurrent code: The continued maturation of Structured Concurrency makes writing correct, observable concurrent code more achievable — a real benefit for microservices-heavy architectures. 
• Stronger security primitives: PEM encoding support brings a long-overdue standard API to cryptographic object handling. 

What Comes After Java 26?

Java 27 is scheduled for general availability in September 2026. Only one JEP has been formally targeted so far: 

• JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3 — This JEP enhances TLS 1.3 with a hybrid key exchange mechanism designed to resist quantum computing attacks. It builds on JEP 496 (Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism), delivered in Java 24. 

Additional JEPs are expected to be targeted for Java 27 soon. Notable candidates include: 

• JEP 401: Value Classes and Objects (Preview) — A long-anticipated feature from Project Valhalla, introducing value objects: immutable, identity-free objects defined solely by the values of their fields. 
• Lazy Constants (Third Preview) — A third preview with further refinements, including a new ofLazy() factory method for creating stable collections. 
• Faster Startup and Warmup with ZGC — A proposal to enhance ZGC with more efficient memory allocation strategies for reduced startup overhead. 

 Summary

Java 26 is the latest short-term release of Java and includes ten JEPs, or Java Enhancement Proposals. Together, these JEPs enable: 

• Faster startup times 
• Better throughput 
• Cleaner concurrent code 
• Stronger security primitives 

Java 26 will be succeeded by Java 27 in September, 2026.  

Start Coding Java Faster in Java 26 

JRebel supports all Java versions, including Java 26, so that your team can integrate the latest Java features without disrupting your development workflow or waiting through lengthy redeployments. 

See how much time your Java development team could save by eliminating redeploys with JRebel during your 14-day free trial.  

Activate Free Trial 

Additional Resources 

• Blog: What's New With Java 25
• Blog: Java 21: Uncover New Features in JDK 21
• Blog: What is Java LTS and Why Does It Matter?