Project Valhalla preview lands in OpenJDK 28

Java’s most ambitious language evolution in a decade has reached the OpenJDK mainline. Oracle engineer Lois Foltan confirmed that Java Enhancement Proposal 401, the cornerstone of Project Valhalla, will merge into the main codebase in early July, making its debut as a preview feature in JDK 28, scheduled for March 2027. The proposal introduces value classes and objects, a fundamental shift designed to address long-standing performance and memory inefficiencies in Java’s object model.

What changed

JEP 401 redefines how Java handles certain data types by introducing value objects—class instances that lack identity and are defined solely by their field values. Currently, nearly all Java objects are reference types, which require additional memory overhead and dereferencing operations. Primitives like int or double avoid these costs, but their use is limited. Value objects bridge this gap, allowing developers to create lightweight, identity-free types that the JVM can optimize more aggressively.

The pull request for the preview adds over 197,000 lines of code across 1,816 files, reflecting the scale of the change. Oracle’s Java Language Architect Brian Goetz described the integration as "extremely large," urging other OpenJDK contributors to avoid major commits during the merge window to minimize conflicts. The preview will initially migrate a subset of JDK classes, such as Integer, to value semantics, with plans to expand the scope gradually.

Why it matters

The performance implications of value objects are significant. Reference types require additional memory to store object headers and must be dereferenced to access their fields, adding overhead to operations like iteration or arithmetic. Value objects, by contrast, can be stored inline in arrays or other objects, reducing memory footprint and improving cache locality. For applications handling large datasets or high-throughput computations, these optimizations could yield measurable gains in speed and efficiency.

The change also simplifies Java’s type system. Currently, developers must navigate quirks like the Integer cache, where small values (below 128) may compare equal with == due to internal pooling, while larger values do not. Value objects eliminate such inconsistencies by ensuring that equality comparisons are based solely on field values. However, the shift introduces breaking changes: code that relies on object identity, such as synchronizing on Integer instances, will now throw exceptions.

What to watch

Project Valhalla’s rollout will be gradual. Goetz cautioned that JEP 401 is unlikely to exit preview status before JDK 29, the next long-term support (LTS) release in September 2027. Even then, the preview window may extend further, as the proposal’s underlying primitives are foundational for other features, such as the Vector API, which will need to rebase on Valhalla’s changes before stabilizing.

Developers can experiment with value objects in JDK 28’s early-access builds, but production adoption will hinge on the feature’s finalization in an LTS release. The broader impact of Valhalla will depend on how widely the Java ecosystem embraces value classes, particularly in performance-sensitive libraries and frameworks. For now, the preview marks a critical milestone in Java’s evolution, offering a glimpse of the language’s future while underscoring the challenges of modernizing a 30-year-old platform.