Scheduled for release in March 2026, JDK 26 continues Java’s evolution with a suite of enhancements focused on performance, security, and developer productivity. While not a Long-Term Support (LTS) release, it introduces pivotal features that refine existing previews and lay groundwork for future stability.

Performance and Efficiency Upgrades

A key theme for JDK 26 is optimizing how Java applications run, from startup speed to garbage collection.

• Enhanced G1 Garbage Collector: The G1 collector is set for a significant boost. The update aims to reduce synchronization between application and GC threads, which should lead to better overall application throughput and lower latency. This is achieved by streamlining the code for write barriers without altering the fundamental G1 architecture or how developers interact with it.
• Ahead-of-Time (AOT) Object Caching: This feature is designed to slash application startup and warmup times. Its major advantage is compatibility with any garbage collector, including the low-pause ZGC. Instead of using a GC-specific memory format, it loads cached objects sequentially from a neutral format, building on the foundations of Project Leyden.
• Vector API (Eleventh Incubation): This long-running incubation continues to provide a platform-agnostic API for writing complex computations. The key benefit is that these computations compile down to highly efficient vector instructions on supported CPU architectures (x64 and AArch64), offering performance that far surpasses traditional scalar code. Its future is tied to the upcoming object model changes from Project Valhalla.

Refining the Developer Experience

Several updates are aimed directly at making code more intuitive, secure, and manageable.

• Pattern Matching for Primitives (Fourth Preview): This feature seeks to create a uniform approach to data exploration by allowing primitive type checks in all pattern matching contexts, including instanceof and switch statements. Now in its fourth preview, it includes refined compiler checks to catch a wider range of coding errors, promoting safer and more consistent code.
• Structured Concurrency (Sixth Preview): Managing multi-threaded code becomes simpler with this API. It treats groups of related tasks as single units of work, making error handling, cancellation, and observability much more straightforward. This approach helps eliminate common concurrency issues like thread leaks.
• Lazy Constants (Second Preview): This feature introduces objects that hold immutable data and are treated by the JVM as genuine constants, enabling the same performance optimizations as final fields. The advantage is that they offer more flexibility regarding when initialization occurs.
• Cryptographic Object Encoding with PEM (Second Preview): The API for encoding and decoding cryptographic objects (like keys and certificates) to and from the Privacy-Enhanced Mail (PEM) format is updated. Revisions include renaming the PEMRecord class to PEM and adding a decode() method. The EncryptedPrivateKeyInfo class also sees method name changes and now supports a wider range of objects for encryption.

Strengthening Security and Integrity

JDK 26 also takes steps to fortify the platform for the future.

• Warnings on Final Field Mutation: The platform has begun issuing warnings when deep reflection is used to alter final fields. This prepares developers for a future restriction, aligning the runtime behavior with the language’s intent—making final truly mean final. This change is expected to enhance both the security and potential performance of Java applications.

API Modernization: Removal and Adoption

As Java evolves, older technologies are retired to make way for modern standards.

• Farewell to the Java Applet API: In a continued effort to modernize the platform, the long-deprecated Applet API has been officially removed. This aligns with the industry’s move away from browser plugins.
• Embracing HTTP/3: The Client API now supports the modern HTTP/3 protocol, ensuring Java applications can leverage the latest advancements in web communication.

This collection of features demonstrates a clear path for Java, balancing powerful new capabilities with the refinement of existing ones to meet the demands of contemporary software development.