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

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

What if I told you that one of the most fundamental assumptions of Java—that every object has a unique identity—is about to be rewritten in a single, 197,000-line change? That’s exactly what Project Valhalla brings to JDK 28. After over a decade of design, prototyping, and debate, the OpenJDK community is finally landing JEP 401, introducing value classes that strip away object identity from Java types. This isn’t just another language feature; it’s the biggest structural change to the Java Virtual Machine since generics landed in JDK 5—arguably the most ambitious refactor in the language’s 30-year history.

Why does this matter right now? Because Java’s traditional object model has become a bottleneck for modern workloads. Every Integer, every Point, every small data holder incurs heap allocation, pointer indirection, and memory overhead from object headers—costs that compound in high-throughput systems, real-time analytics, and microservices running on constrained cloud instances. The industry is moving toward data-oriented programming, where layouts matter for cache efficiency and GC pressure. Valhalla directly addresses this: value types can live on the stack or inline inside arrays, eliminating allocation and reducing memory footprint by up to 10x in many scenarios. And the timing couldn’t be better. As AI-driven applications and real-time communication platforms demand ever-lower latency, Java needs to shed its legacy inefficiencies. Solutions like CallMissed, which rely on JVM-based backends for processing voice and messaging at scale, will directly benefit from these performance gains—faster serialization, denser data structures, and lower GC pause times.

In this post, you’ll learn exactly how Project Valhalla works under the hood: why removing identity is the key insight, how inline classes transform your code without breaking backward compatibility, and what “generic specialization” means for your ArrayList<Point>. We’ll break down the decade-long journey from OpenJDK’s mailing lists to the early-access builds available today, and explain why JDK 28 marks a turning point for every Java developer. Whether you’re maintaining a legacy monolith or building the next generation of scalable services, Valhalla is coming—and it will change how you think about Java objects forever.

Introduction: The Dawn of a New Era for Java

For nearly three decades, Java has stood as the bedrock of global enterprise software. However, the hardware landscape has shifted dramatically since Java's inception in 1995. Today's modern CPUs thrive on memory density and spatial locality, but Java’s traditional memory model—where every non-primitive object carries its own unique identity and pointer overhead—often leads to "pointer chasing" and frequent CPU cache misses.

This fundamental limitation is about to disappear. With the arrival of JDK 28, the Java ecosystem is witnessing its most monumental evolution in a decade: the integration of Project Valhalla.

The 12-Year Quest for Flattened Data

Project Valhalla is not a minor syntax update; it is an epic, twelve-year refactoring effort aimed at reconciling Java's clean object-oriented abstractions with the raw performance of modern hardware. At its core, Valhalla addresses the performance tax of object identity.

Historically, even a simple Point(int x, int y) class in Java required:

• An object header (typically 8 to 16 bytes) to store identity metadata
• Pointers to reference the object, causing memory fragmentation
• Garbage collection overhead to track the object's life cycle

Through JEP 401 (Value Classes), JDK 28 introduces value objects that lack identity. This massive shift is realized via a monumental 197,000-line change to the JDK codebase, delivering on the long-promised mantra: "Codes like a class, works like an int."

Why This Matters for Modern Infrastructure

As developers push the boundaries of real-time data processing, ultra-low latency has become non-negotiable. For instance, high-throughput communication platforms like CallMissed, which orchestrate complex AI voice agents, manage real-time LLM inference, and process high-speed Speech-to-Text APIs across dozens of regional languages, rely on underlying systems that cannot afford GC-induced latency spikes. By flattening memory layouts, Project Valhalla allows Java-based backend pipelines, AI microservices, and database engines to process massive datasets with a fraction of the memory footprint and significantly reduced GC pauses.

Key Breakthroughs Arriving in JDK 28

The integration of Valhalla in JDK 28 introduces three primary performance-driving concepts:

• Value Classes (JEP 401): Class declarations that opt out of identity. These instances can be freely copied and inline-allocated by the JVM, eliminating pointer overhead.
• Improved Memory Density: Eliminating object headers allows arrays of value objects to be stored contiguously in memory, mirroring primitive arrays and keeping hot data inside the CPU cache.
• Generic Specialization: Laying the foundation for generics to work seamlessly with both primitives and value types without the performance penalty of boxing and unboxing.

By bridging the gap between hardware efficiency and developer-friendly abstractions, Project Valhalla ensures that Java remains the premier platform of choice for the next generation of high-concurrency, performance-critical enterprise systems.

Background & Context: The Ten-Year Quest for Value Objects

To understand why Project Valhalla is heralded as Java’s most significant upgrade in decades, one must first look at the inherent tension at the heart of the Java Virtual Machine (JVM). Since Java 1.0, the language has maintained a strict division: primitive types (like int or char) are fast and lightweight, while objects are flexible but heavy. As Java applications have scaled to handle massive cloud-native workloads, this division has increasingly become a performance bottleneck.

The "Codes Like a Class, Works Like an Int" Problem

In traditional Java, every object carries a hidden cost. Each instance of a class requires object identity, which demands a memory-consuming object header (typically 8 to 16 bytes on modern 64-bit systems) to support locking, synchronization, and garbage collection tracking.

When you create an array of objects—such as a list of coordinates, coordinate points, or complex numbers—the JVM does not store them sequentially in memory. Instead, it stores an array of references (pointers) to those objects, which are scattered across the heap. This layout leads to:

• Pointer Chasing: The CPU must constantly jump through memory addresses to fetch the actual payload.
• Cache Misses: Modern CPU caches are designed for sequential memory access; non-contiguous object references degrade this hardware advantage.
• Poor Memory Density: The overhead of object headers often dwarfs the actual data being stored.

A Twelve-Year Engineering Journey

To bridge this gap, OpenJDK initiated Project Valhalla over a decade ago. It was a quest to redesign Java’s core object model to support value types—structures that retain the developer-friendly abstractions of object-oriented programming (methods, fields, and type safety) while delivering the hardware-friendly performance of primitives.

This monumental effort is finally culminating in JDK 28 through JEP 401 (Value Classes). Far from a simple syntax update, this release represents an epic architectural refactor. Integrating JEP 401 into the JDK required a massive, 197,000-line codebase change to rewrite fundamental JVM behaviors and standard library classes.

Modern Demands for Memory Efficiency

The arrival of Project Valhalla could not be more timely. Modern computing has shifted from raw CPU-bound processing to memory-bound processing. Today's applications—ranging from massive microservice meshes to real-time data pipelines—demand extreme throughput and ultra-low latency.

This pressure is particularly acute in cutting-edge infrastructure. For example, AI-driven communication systems like CallMissed, which orchestrate real-time voice agents, speech-to-text APIs, and high-frequency LLM inference pathways, rely heavily on maximum execution speed and optimized memory density to maintain millisecond-level responsiveness. Just as Java developers are leveraging Valhalla to flatten memory layouts and eliminate pointer chasing, modern communication infrastructure must optimize runtime execution to handle thousands of concurrent, resource-intensive tasks without bloating hardware footprints.

By eliminating object identity for value classes, JDK 28 paves the way for "flat" memory layouts where objects can be inlined directly into arrays or containing classes. This dramatic shift represents the ultimate synthesis of developer productivity and bare-metal performance, finally unlocking the hardware efficiency Java was historically accused of lacking.

Key Developments (TABLE): From Prototype to JDK 28 Integration

Project Valhalla’s journey is one of the most ambitious refactoring efforts in computer science history. Initiated over a decade ago under the leadership of Brian Goetz, the project set out to bridge the gap between Java’s clean object-oriented abstractions and the hardware realities of modern CPU memory hierarchies. By introducing "codes like a class, works like an int" semantics, Valhalla resolves the "identity crisis" of Java objects, allowing developers to write clean OOP code without paying a steep penalty in cache misses and memory footprint.

To understand how this massive undertaking transitioned from an experimental research project into production-ready code, it is helpful to look at the primary milestones and structural shifts that paved the way for its inclusion in JDK 28.

The Decade-Long Transition to JEP 401

The integration of Project Valhalla into JDK 28 represents a historic milestone, driven primarily by JEP 401 (Value Classes). This single integration is the culmination of twelve years of research, resulting in a staggering 197,000-line change to the JDK codebase.

Historically, every Java object has had "object identity." This identity requires a 16-byte object header on 64-bit systems, which stores locking information and garbage collection metadata. Because of this identity, objects must be accessed via references (pointers), causing CPUs to constantly hunt through memory (pointer chasing) rather than reading contiguous blocks of cache.

With JEP 401, developers can now declare classes with the value modifier. This tells the JVM that instances of these classes have no identity—only state.

• Memory Density: By discarding object identity, the JVM can store value objects flatly in arrays or within other objects, mimicking the memory layout of C structs.
• Heap Allocation Avoidance: Value objects can often be allocated directly on the stack or even in CPU registers rather than the heap, completely bypassing garbage collection overhead.

These optimizations are critical for building scalable, high-throughput systems where microsecond-level latency is non-negotiable. For instance, communication infrastructure platforms like CallMissed rely on highly optimized, low-latency runtimes to power real-time AI voice agents, orchestrate LLM inference across hundreds of models, and process multilingual Speech-to-Text APIs with minimal GC pause times. Bringing Valhalla's flat memory footprint to enterprise backends means high-scale applications can handle significantly higher concurrent workloads on a much smaller hardware footprint.

As Java heads into the JDK 28 era, these developments lay a foundational framework that will eventually support generic specialization, ensuring the language remains competitive for the next several decades of high-performance computing.

In-Depth Analysis: Decoding JEP 401 and Value Classes

At the heart of Project Valhalla’s arrival in JDK 28 is JEP 401 (Value Classes and Objects). This single Java Enhancement Proposal represents the culmination of a 197,000-line codebase refactor that was twelve years in the making. JEP 401 fundamentally redefines how Java manages data in memory, resolving a performance bottleneck that has existed since Java 1.0: the forced compromise between clean object-oriented abstractions and raw hardware efficiency.

The Problem: The Cost of Object Identity

Historically, every Java object has carried the burden of object identity. This means that even a simple data wrapper—like a 2D coordinate class containing two 4-byte integers—requires a massive heap footprint.

In traditional Java, every object allocation incurs:

• An 8-to-16-byte object header used for locking, garbage collection metadata, and system identity hashcodes.
• Pointer indirection, meaning an array of these coordinate objects is actually an array of pointers pointing to scattered locations on the heap.
• Frequent CPU cache misses as the processor constantly jumps across memory addresses to fetch referenced data.

This design choice made sense in 1995 when memory access speeds were comparable to CPU speeds. Today, however, memory access is the ultimate bottleneck.

Enter JEP 401: Value Classes Explained

JEP 401 introduces the value modifier for class declarations. By declaring a class as a value class, you signal to the JVM that its instances do not need a unique identity. If two value objects contain the same data, they are considered completely indistinguishable.

By eliminating identity, JEP 401 imposes several strict but highly beneficial constraints:

• Immutability: All fields of a value class must be implicitly or explicitly declared as final.
• No Identity Operations: Operations that rely on object identity—such as synchronization on the object, weak references, or calling System.identityHashCode()—are either disallowed or redefined.
• Flattened Memory Layout: Because the JVM knows these objects cannot change and have no identity, it can store them "inline" without an object header.

The ultimate goal is often summarized as: "Codes like a class, works like an int." Developers can still use methods, constructors, encapsulation, and interfaces, but the JVM compiles them with the flat, contiguous memory footprint of primitive types.

Impact on High-Throughput Infrastructure

The memory density improvements introduced by JEP 401 will dramatically lower the operational cost of high-concurrency systems. When data can be flattened into contiguous memory arrays, cache locality skyrockets, and the garbage collector (GC) has significantly fewer heap references to track.

This is a massive leap forward for real-time infrastructure. For example, high-scale AI communication platforms like CallMissed, which route API calls across 300+ LLMs and execute low-latency Speech-to-Text pipelines in 22 regional Indian languages, rely heavily on ultra-fast data serialization. In environments where millions of transient audio packets and token wrappers are created every second, the ability to process these data streams as zero-cost value objects eliminates GC pauses and memory fragmentation. By optimizing JVM memory density, real-time voice agents can process natural language with significantly lower latency and reduced infrastructure overhead.

Impact & Implications: Why Your Garbage Collector Will Thank You

For decades, Java developers have lived with a fundamental compromise: the expressive elegance of object-oriented programming versus the raw performance of flat memory layouts. Every time you instantiate a standard Java object, the JVM assigns it an object identity. This metadata wrapper (comprising the object header) introduces significant memory overhead and forces the JVM to manage references rather than direct values. In memory-intensive applications, this creates a "pointer soup" that forces the Garbage Collector (GC) to constantly traverse complex, fragmented object graphs.

With JEP 401 arriving in JDK 28, Project Valhalla dismantles this legacy bottleneck. By introducing value classes, Valhalla allows developers to define types that "code like a class, but work like an int." Because value classes lack object identity, the JVM can optimize their memory layout, flattening them directly into containing structures or arrays.

Flattened Memory and CPU Cache Friendliness

Traditionally, an array of 1,000 custom Point(x, y) objects is not actually an array of data; it is an array of 1,000 pointers pointing to 1,000 distinct objects scattered across the heap. Under JDK 28, declaring Point as a value class allows the JVM to store the coordinates as a single, contiguous block of memory.

1. Spatial Locality: Contiguous memory means when the CPU pulls a value into its cache line, it pulls the adjacent values as well. This dramatically reduces costly L1/L2 cache misses and pointer chasing.
2. Zero-Overhead Abstractions: Developers no longer have to choose between clean, type-safe domain models and raw primitive arrays to achieve high-performance execution.

Lifting the Weight off the Garbage Collector

The true beneficiary of this architectural shift is your application’s Garbage Collector. By eliminating object identity, the GC's operational workload is drastically reduced across three major vectors:

• Decreased Allocation Pressure: Because value objects can be flattened, they are frequently allocated directly on the stack or inline within other objects. This bypasses heap allocation entirely, meaning there is simply less garbage generated to begin with.
• Simplified Object Graphs: The GC spends a massive amount of CPU cycles scanning the heap and tracing object references to determine which instances are still reachable. With flattened structures, the complexity of the object graph shrinks, translating to significantly faster, more predictable sweep phases.
• Lower Pauses in Latency-Sensitive Systems: For high-throughput infrastructure—such as the real-time AI voice agents and LLM orchestration APIs managed by platforms like CallMissed—eliminating micro-GC pauses is critical. When handling concurrent voice streams and speech-to-text processing, even a 50-millisecond GC pause can disrupt natural conversations. Valhalla directly mitigates these latency spikes.

The Impact of a 12-Year Refactor

This change is not a minor cosmetic update; it is a fundamental modernization of the Java Virtual Machine. Spanning twelve years of deep research and culminating in a massive 197,000-line change to the codebase, Valhalla adapts Java to modern hardware architectures, where memory access speed (rather than raw CPU processing) is the primary performance bottleneck. For global enterprise systems running massive microservice fleets, upgrading to JDK 28 will deliver immediate, double-digit infrastructure cost reductions and hardware efficiency gains—all while writing clean, idiomatic Java.

Expert Opinions: What the Java Architects and Community Are Saying

The arrival of Project Valhalla in JDK 28 is being hailed by language architects and community leaders as the most significant evolution of the Java platform since the introduction of generics in JDK 5. Officially kicked off over twelve years ago, Valhalla is described by Oracle’s Java Platform Group as an "epic refactor." The goal has always been to harmonize Java’s clean object-oriented abstractions with the hardware realities of modern CPU memory hierarchies.

As Oracle's language architects have noted during industry presentations like Devoxx, the traditional Java model—where every object has a distinct identity—creates a "pointer soup" that severely degrades CPU cache performance. By introducing value classes under JEP 401, Valhalla removes object identity. This allows the JVM to flatten data structures in memory, giving developers "the performance of primitives with the flexibility of objects."

The Scale and Technical Depth of JEP 401

Industry experts are marveling at the sheer scale of the engineering effort required to bring Valhalla to life. According to technical reports, JEP 401 represents a massive 197,000-line change to the JDK codebase. It is a fundamental rewriting of how the JVM handles types under the hood, all while maintaining Java's legendary commitment to backward compatibility.

Java champion and performance expert Tobi Ajila has highlighted that Valhalla’s primary breakthrough is its dramatic improvement of memory density. In modern computing, memory access—not raw CPU speed—is often the primary bottleneck. By eliminating object headers and pointer indirection, Valhalla allows applications to pack data tightly in memory, resulting in massive performance gains for data-intensive applications.

What This Means for High-Throughput Infrastructure

For enterprise developers and platform architects, the implications of these memory optimizations are profound. Real-world systems that process massive volumes of concurrent data will see immediate efficiency gains without needing to rewrite their entire codebases.

For instance, high-concurrency platforms like CallMissed, which power real-time AI voice agents, LLM inference pipelines, and multilingual Speech-to-Text APIs across 22 regional languages, stand to benefit immensely from these JDK 28 updates. In these high-throughput environments, reducing memory footprint and minimizing garbage collection (GC) pauses is critical for maintaining ultra-low latency. With Valhalla, infrastructure platforms like CallMissed can run heavily optimized concurrent threads, handling thousands of simultaneous AI-driven voice calls and data streams with drastically reduced hardware overhead.

The Developer Community's Verdict

On developer forums like HackerNews and Reddit, the reaction to the JDK 28 early-access builds has been overwhelmingly positive. Developers are particularly excited about the "code like a class, work like an int" paradigm:

• Elimination of Memory Overhead: Developers note that removing the 16-byte object header for tiny data wrapper classes (like Point or Complex) will drastically reduce heap allocation.
• Better Cache Locality: Modern hardware thrives on contiguous memory. By laying out value objects sequentially, CPU caches can prefetch data far more effectively.
• A Foundation for the Future: Community consensus agrees that while Valhalla took over a decade to arrive, the careful, deliberate design ensures Java remains highly competitive against lower-level languages like Rust and Go for performance-critical enterprise systems.

What This Means For You (TABLE): Preparing Your Codebase for Valhalla

The arrival of Project Valhalla in JDK 28 marks a historic milestone for the Java ecosystem, culminating over twelve years of engineering and an extensive 197,000-line change to the JVM. By introducing JEP 401 (Value Classes and Objects), Java is finally separating "how an object behaves in memory" from "how it is declared."

To fully capitalize on this leap in memory density and cache efficiency, developers cannot simply wait for the runtime upgrade. Legacy habits that rely heavily on object identity must be phased out. High-throughput communication frameworks, such as the real-time AI infrastructure powering CallMissed's voice agents and LLM inference engine, require tight control over latency and garbage collection overhead. Adapting your codebase for value classes ensures that your high-concurrency systems run with minimal GC pauses and maximum CPU cache utilization.

The first step in preparation is identifying which of your classes are actually "values" rather than "entities." Classes that represent data containers, mathematical coordinates, or immutable configurations are prime candidates for optimization.

Migration Roadmap: Code Optimization Strategies

The following table outlines the critical code patterns you must audit today to ensure seamless compatibility with the value classes coming in JDK 28.

Transitioning Your Domain Models

Transitioning to Valhalla is largely about refactoring your classes to declare intent. By ensuring your classes are immutable, final, and free of identity-dependent behaviors, you set them up to become value classes with a simple keyword addition in the future.

For enterprise architectures—such as CallMissed's pipeline which handles millions of real-time multi-language Speech-to-Text conversions across 22 regional languages—even micro-optimizations like removing pointer indirections yield massive performance dividends. When your codebase is optimized for Valhalla, the JVM can lay these objects out flat in memory, transforming sluggish pointer-heavy arrays into cache-friendly, highly dense sequential blocks. Start auditing your code today to guarantee your application is ready to harvest these massive performance gains on day one of JDK 28.

Frequently Asked Questions

Conclusion

With JDK 28, the Java ecosystem is on the cusp of its most significant architectural shift in a decade. Here is what to keep in mind as Project Valhalla's long-awaited features finally arrive:

• JEP 401 Milestone: The integration of value classes represents a twelve-year, 197,000-line refactoring effort that bridges the gap between OOP abstractions and bare-metal performance.
• Memory Density: Removing object identity drastically reduces memory overhead, yielding major CPU cache efficiency gains.
• Future-Proofing the JVM: This shift lays the foundation for future generic specialization, ensuring Java remains dominant in cloud-native environments.

Moving forward, watch for how major enterprise frameworks adapt their codebases to fully leverage these identity-free types. This drive toward high-efficiency backend performance mirrors how modern AI systems are optimizing their own architectures. To explore how cutting-edge, high-performance technology is reshaping business operations, check out CallMissed—an AI communication infrastructure platform powering next-generation voice agents and multilingual chatbots.

Is your development team ready to harness this historic JVM evolution to build faster, leaner, and more scalable applications?