Project Valhalla, Explained: How a Decade of Work Arrives in JDK 28

Project Valhalla, a monumental decade-long effort to introduce value types into Java, is seeing its initial integration into OpenJDK 28. JEP 401 (Value Classes and Objects), alongside JEP 402 for Enhanced Primitive Boxing, will be available as a preview feature, marking a profound shift in Java's foundational object model.

The core promise of Valhalla is to allow types that "code like a class, works like an int." This means developers can write standard, readable classes that the JVM can treat with the efficiency of primitives, enabling flat and dense memory layouts. This addresses a critical performance bottleneck in modern hardware where the CPU-memory speed gap makes data locality paramount, an issue exacerbated by Java's traditional "fluffy" (scattered) reference types and unpredictable escape analysis optimizations.

Key aspects of this transformative project include:

• Historical Evolution: The concept of value types predates Java's release, but its complexity led to its omission. Project Valhalla officially began in 2014, progressing through several prototypes (e.g., "Q World" and "L World") and evolving naming conventions from "value types" to "inline classes," and briefly, "primitive classes," before settling on the current "value classes."
• Design Breakthroughs: A pivotal realization was that the language model and JVM model do not require a 100% overlap, allowing a simpler programming model with a more complex, optimized JVM implementation underneath. The ambitious dual-projection "primitive classes" model was ultimately simplified to orthogonal concepts of "value classes" and future "null-restricted types."
• JEP 401 in JDK 28 (Preview):
  • Declaration: Value classes are declared with the value modifier; they have implicitly final fields, cannot be synchronized upon, and are final by default, unable to inherit from identity classes.
  • No Identity: The defining trait is the absence of identity. Consequently, the == operator now checks for substitutability (recursive field comparison) rather than memory address. Attempting synchronized on a value object will throw an IdentityException.
  • Performance Optimizations: This enables key JVM optimizations like scalarization (breaking objects into their constituent fields) and heap flattening (inlining object data directly into fields or array cells). This leads to significantly denser memory layouts, reducing garbage collection overhead and improving cache efficiency.
  • Boxing Overhead Reduction: Primitive wrapper classes like Integer will become value classes under preview, drastically diminishing boxing overhead. An array like Point[] (where Point is a value class) can now store values contiguously, dramatically improving memory access compared to an array of pointers to scattered objects.
• Future Work: It's crucial to note that JDK 28's preview does not include full specialized generics (meaning ArrayList<Point> won't immediately see the full flattening benefits), null-restricted types, or 128-bit encodings. These advanced features are planned for future releases.

Valhalla is not merely adding a new feature but fundamentally altering Java's deepest assumption that "every object has identity." While JDK 28 delivers only the first, preview stage, it sets the groundwork for unlocking a decade of further performance enhancements in Java, particularly for data-intensive applications, without sacrificing the language's strong abstraction capabilities. Developers are encouraged to experiment with the preview to provide feedback.