JEP 519 shipped stable in JDK 25. It shrinks every single object header on the heap. It’s one JVM flag. Most teams still haven’t flipped it.
Here’s a JVM optimization that costs nothing to try, requires no code changes, and has already been validated across hundreds of production services at Amazon. It shipped as a stable, production-ready feature in JDK 25. And if your team is like most, it’s sitting there unused. This is the story of Compact Object Headers, what they actually do, what the real numbers look like, and why “it’s automatic now” is the myth that’s keeping teams from claiming savings they’re already entitled to.
What’s Actually Sitting in Every Object Header
Every object on the Java heap carries a header before any of its actual data. That header isn’t optional, and until recently, it wasn’t small. On a typical 64-bit JVM with compressed object pointers enabled, a plain object header consumes 96 bits, 12 bytes, made up of a mark word (used for locking, garbage collection state, and identity hash codes) and a compressed class pointer. On larger heaps, above roughly 32 GB, where compressed pointers stop working, that header grows to 128 bits, 16 bytes.
For an application with a handful of large objects, that overhead barely registers. But most real Java applications aren’t shaped like that. Spring Boot services, data pipelines, caching layers, anything built around small domain objects, DTOs, wrapper types, list nodes, tends to allocate enormous numbers of small objects. When each one is paying a fixed 12-to-16-byte tax just to exist, that tax adds up fast. It’s routine for header overhead alone to account for 15 to 25 percent of total heap usage in object-heavy workloads.
The Fix: One 64-Bit Word Instead of Two
JEP 519, Compact Object Headers, takes the mark word and the class pointer, previously two separate fields, and merges them into a single compact 64-bit word. The class pointer itself gets compressed further, down to 22 bits, still enough headroom for roughly four million distinct classes, far beyond what any real application will ever load. The net result is straightforward: every object header on the heap shrinks from 96 or 128 bits down to a flat 64 bits, and every object gets smaller without a single line of application code changing.
This didn’t appear out of nowhere in JDK 25. It’s the first shipped result of Project Lilliput, the OpenJDK effort dedicated specifically to shrinking object memory overhead, and it spent a full release cycle as an experimental feature under JEP 450 in JDK 24 before graduating to a stable product feature. Enabling it takes one flag:
-XX:+UseCompactObjectHeaders
That’s the entire integration cost. No dependency changes, no application code touched, no build configuration beyond a JVM flag you can add to a deployment manifest today.
The Myth: “It’s On by Default in Java 25”
The misconception: Because JEP 519 promoted compact object headers to a stable, production-ready feature, plenty of teams assume upgrading to JDK 25 gets them the savings automatically. It doesn’t. Compact object headers remain opt-in in JDK 25. A separate proposal, JEP 534, exists specifically to flip the default and currently targets JDK 27, and its own text is explicit that the JDK 25 team deliberately held off, in their words, changes this size are best introduced carefully and gradually. If you’ve upgraded to JDK 25 and never added the flag, you’re running with the old 96-to-128-bit headers exactly as before.
That gap, between “production-ready” and “on by default,” is precisely why this savings is still sitting unclaimed on so many clusters. Teams read “stable in JDK 25” and reasonably assume stable means enabled. It means tested, not turned on.
The Real Numbers, Not Marketing Numbers
The headline figures come straight from OpenJDK’s own JEP 519 text, not a vendor benchmark. Running the SPECjbb2015 benchmark with compact object headers enabled showed 22 percent less heap space used, 8 percent less CPU time, and 15 percent fewer garbage collections with both the G1 and Parallel collectors, all with no application changes involved. A separate, highly parallel JSON parsing benchmark ran 10 percent faster. Those figures are exactly where the “15 to 25 percent” range in the title comes from, not a rounded-up marketing number.
The validation behind those numbers is unusually thorough for a JVM-level change. Amazon ran compact object headers across hundreds of production services before JDK 25 ever shipped, largely using backports of the feature to JDK 17 and JDK 21. SAP went further still, enabling compact object headers by default in SapMachine, its own OpenJDK distribution, ahead of the upstream default flip. That’s not a lab result, it’s production traffic at two of the largest JVM operators on the planet.
Where the FinOps Case Writes Itself
For any team already tracking JVM memory against container limits, this is about as close to a free lunch as infrastructure optimization gets. Smaller headers mean lower heap usage at the same workload, which means either a smaller memory request per pod, or more headroom before you hit a limit and get OOM-killed. Lower heap usage also means less garbage collection work per cycle, since the collector is scanning fewer bytes of live header data on every pass. If your team has already gone through the exercise of right-sizing JVM container memory requests, compact object headers is the next lever, and it’s a lever you pull with one flag instead of a re-architecture.
Rollout checklist before you flip the flag
- Confirm you’re on JDK 25 or later, or a distribution that has backported JEP 519.
- Check your heap size. Compact headers rely on compressed class pointers, which stop working above roughly 32 GB per heap.
- Audit any native code or JNI integrations that assume a fixed object header layout, these are the most likely source of surprises.
- Re-check debugging and profiling tooling. Anything that parses raw object headers needs to be header-layout aware.
- Roll out to a non-critical service first and compare heap and GC metrics before and after, the same way you’d validate any other JVM flag change.
What We Learned
Compact Object Headers, delivered through JEP 519, shrink every Java object’s header from 96 or 128 bits down to a single 64-bit word by merging the mark word and a compressed class pointer, with OpenJDK’s own SPECjbb2015 numbers showing 22 percent less heap and 8 percent less CPU time as a direct result. It shipped as a stable, production-ready feature in JDK 25, validated against hundreds of real production services at Amazon before it ever reached that milestone. The catch is entirely about defaults, not readiness, the feature is opt-in behind a single flag, and a separate JEP proposing to make it the default hasn’t landed yet. For any object-heavy Java workload running in containers with a memory limit attached to a cost line, that single flag is one of the highest-leverage, lowest-risk changes available today, and most teams simply haven’t flipped it yet.
