Java 28 Development Progress and New JSON API Features

Java Development Kit 28 is beginning to take shape as a feature-rich release scheduled for arrival in March 2027. This version introduces a native JSON API alongside significant updates to the virtual machine and garbage collection processes. It functions as a non-long-term support release for the broader ecosystem.

Native JSON Processing and Platform Modernization

The inclusion of a simple JSON API marks a major shift in how the platform handles data interchange. For years, developers relied on third-party libraries like Jackson or Gson to parse and generate JSON documents. This new proposal aims to provide a standard, built-in solution that reduces the need for external dependencies in common tasks.

By integrating these tools directly into the JDK, the development team intends to streamline the coding process. This standard API will allow for the processing of JSON data with minimal ceremony. Engineers can expect a straightforward interface that handles basic data manipulation without the overhead of managing additional package versions or security patches for external tools.

This move toward a native solution reflects a broader trend in the Java community to internalize essential web technologies. While specialized use cases might still require high-performance external frameworks, the built-in API covers the majority of standard use cases. This reduces the surface area for potential bugs and simplifies the onboarding process for new developers who need to interact with web services.

Standardizing Data Interchange

The new API focuses on simplicity and ease of use. It provides a consistent way to read and write JSON across different Java environments. This consistency ensures that code remains portable and less susceptible to the breaking changes often found in external library updates. The design prioritizes readability, making it easier for teams to maintain large codebases over time.

Reducing Dependency Bloat

Relying on fewer external libraries is a priority for many IT managers. Each additional dependency introduces a new point of failure and potential security vulnerabilities. By providing a native way to handle JSON, JDK 28 helps organizations keep their deployment artifacts smaller and their security audits more manageable. It is a strategic addition that addresses long-standing developer requests for better core utility.

Value Objects and Memory Management Upgrades

JDK 28 introduces value objects as a preview feature to change how the language handles data that does not require a unique identity. Traditionally, Java objects have an identity that distinguishes them even if their internal data is identical. Value objects remove this requirement, focusing entirely on the fields they contain.

This shift allows the Java Virtual Machine to optimize how these objects are stored and accessed. Because value objects are immutable and lack identity, the system can represent them in memory more efficiently. This often results in a smaller memory footprint and faster execution times for data-heavy applications. The equality operator will compare the values within the fields rather than the memory address of the object itself.

The introduction of these objects provides a clearer programming model for immutable data structures. It aligns Java with modern functional programming concepts while maintaining the familiar object-oriented syntax. Developers gain the ability to write safer code that is less prone to side effects, as these objects cannot be changed once they are created.

Enhancing Virtual Machine Performance

The JVM benefits significantly from the lack of object identity. It can perform flatter memory layouts, which reduces the number of pointers the CPU must follow. This architectural change directly impacts the performance of large-scale applications that process millions of small data points. It is a fundamental evolution of the Java type system that has been in discussion for several years.

Updating the Shenandoah Garbage Collector

Another major change in JDK 28 is the shift in the Shenandoah Garbage Collector. The development team plans to make the generational mode the default setting. This mode separates objects based on their age, allowing the collector to focus on short-lived objects more frequently. This strategy generally leads to better performance and lower latency for most workloads.

The non-generational mode of Shenandoah will be deprecated in this release. While it will not be removed immediately, the goal is to phase it out in future versions to reduce maintenance costs. Focusing on a single, more efficient mode allows the contributors to concentrate their efforts on improving the core technology rather than supporting two distinct architectures.

Integrity Guarantees and Future Release Cycles

Safety and integrity remain central themes in the latest JDK updates. JDK 28 proposes a preview of strictly-initialized fields within the virtual machine. This feature ensures that fields are initialized before any part of the program can read them. This prevents developers from seeing default values like null or zero, which are common sources of logic errors.

For fields marked as final, this guarantee means that the observed value will always be the one set during initialization. This provides language designers and developers with a more reliable model for field management. It strengthens the overall integrity of the platform by eliminating a class of bugs related to uninitialized state. These types of low-level improvements are critical for building secure and predictable software.

As a non-LTS release, JDK 28 will receive six months of support from Oracle. These feature releases serve as important stepping stones, allowing the community to test and refine new technologies before they are included in a long-term support version. It gives early adopters a chance to experiment with the JSON API and value objects in production-like environments.

Strict Field Initialization Benefits

Strict initialization addresses one of the oldest quirks in Java development. By forcing a defined state before access, the JVM helps developers catch errors earlier in the development cycle. This is particularly useful in multi-threaded environments where race conditions often lead to the observation of partially initialized objects. The new model provides a safer foundation for complex application architectures.

Timeline for Upcoming Versions

The roadmap for Java remains consistent with its predictable release schedule. Before JDK 28 arrives in 2027, the community is preparing for the launch of JDK 27 on September 15. Like its successor, JDK 27 is a non-LTS release with a six-month support window. This rapid cadence ensures that the language continues to evolve quickly, meeting the demands of modern cloud and enterprise computing.

Each release builds upon the last, integrating feedback from the previous cycle. The transition from JDK 27 to JDK 28 represents a steady march toward a more efficient and developer-friendly ecosystem. By the time these features reach a long-term support release, they will have undergone extensive testing and refinement by the global Java community.