Long-term support release due in September is off and running, with a stable values API and the removal of the 32-bit x86 port the initial proposed features. Credit: Christina Morillo Java Development Kit (JDK) 25, a planned long-term support release of standard Java due in September, now has four features officially proposed for it. The two latest features include module import declarations and compact source files and instance main methods, features previously previewed and now set for finalization in JDK 25. Both features showed up April 21 on the JDK 25 reference implementation page on the OpenJDK website. Prior to these features, the first feature had been a preview of an API for stable values, which promises to speed up the startup of Java applications. The second was the removal of the previously deprecated 32-bit x86 port. JDK 25 comes on the heels of JDK 24, a six-month-support release that arrived March 18. As a long-term support release, JDK 25 is set to get at least five years of premier-level support from Oracle. JDK 25 is due to arrive as a production release on September 16, following rampdown phases in June and July and two release candidates planned for August. The most-recent LTS release has been JDK 21, which arrived in September 2023. Module import declarations, which has been previewed in JDK 24 and JDK 23, enhances the Java language with the ability to succinctly import all of the packages exported by a module. This simplifies the reuse of modular libraries but does not require the importing code to be in a module itself. It includes the following goals: Simplifying the reuse of modular libraries by letting entire modules be imported at once Avoiding the noise of multiple type import-on-demand declarations when using diverse parts of the API exported by a module Allowing beginners to more easily use third-party libraries and fundamental Java classes without having to learn where they are located in a package hierarchy Ensuring that module import declarations work smoothly alongside existing import declarations. Developers who use the module import feature would not be required to modularize their own code. Compact source files and instance main methods would evolve the Java language so beginners can write their first programs without needing to understand language features designed for large programs. Beginners can write streamlined declarations for single-class programs and seamlessly expand programs to use more advanced features as their skills grow. Experienced developers can likewise enjoy writing small programs succinctly without the need for constructs intended for programming in the large. This feature has been previewed in JDK Versions 21, 22, 23, and 24, albeit under slightly different names. In JDK 24 it was called simple source files and instance main methods. Stable values are objects that hold immutable data. Because stable values are treated as constants by the JVM, they enable the same performance optimizations that are enabled by declaring a field final. But compared to final fields, stable values offer greater flexibility as to the timing of their initialization. A chief goal of the proposal, which is in a preview API stage, is improving the startup of Java applications by breaking up the monolithic initialization of application state. Other goals include enabling user code to safely enjoy constant-folding optimizations previously available only to JDK code. This guarantees that stable values are initialized at most once, even in multi-threaded programs, and decouples the creation of stable values from their initialization, without significant performance penalties. Removal of the 32-bit x86 port, currently proposed to target JDK 25, involves removing both the source code and build support for this port, which was deprecated for removal in JDK 24. In explaining the motivation, the JEP states that the cost of maintaining this port outweighs the benefits. Keeping parity with new features, such as the foreign function memory API, is a major opportunity cost, according to the JEP. Deprecating and removing the port will allow OpenJDK developers to accelerate development of new features and enhancements. Other features that could find a home in JDK 25 include other features previewed in JDK 24, such as a key derivation function API, scoped values, structured concurrency, flexible constructor bodies, and primitive types in patterns, instanceof, and switch. A vector API, incubated nine times from JDK 16 to JDK 24, also could appear in JDK 25.