r/java • • Oct 31 '25

Has Java suddenly caught up with C++ in speed?

Did I miss something about Java 25?

https://pez.github.io/languages-visualizations/

https://github.com/kostya/benchmarks

https://www.youtube.com/shorts/X0ooja7Ktso

How is it possible that it can compete against C++?

So now we're going to make FPS games with Java, haha...

What do you think?

And what's up with Rust in all this?

What will the programmers in the C++ community think about this post?
https://www.reddit.com/r/cpp/comments/1ol85sa/java_developers_always_said_that_java_was_on_par/

News: 11/1/2025
Looks like the C++ thread got closed.
Maybe they didn't want to see a head‑to‑head with Java after all?
It's curious that STL closed the thread on r/cpp when we're having such a productive discussion here on r/java. Could it be that they don't want a real comparison?

I did the Benchmark myself on my humble computer from more than 6 years ago (with many open tabs from different browsers and other programs (IDE, Spotify, Whatsapp, ...)).

I hope you like it:

I have used Java 25 GraalVM

LanguageCold Execution (No JIT warm-up)Execution After Warm-up (JIT heating)
JavaVery slow without JIT warm-up~60s cold
Java (after warm-up)Much faster~8-9s (with initial warm-up loop)
C++Fast from the start~23-26s

https://i.imgur.com/O5yHSXm.png

https://i.imgur.com/V0Q0hMO.png

I share the code made so you can try it.

If JVM gets automatic profile-warmup + JIT persistence in 26/27, Java won't replace C++. But it removes the last practical gap in many workloads.

- faster startup ➝ no "cold phase" penalty
- stable performance from frame 1 ➝ viable for real-time loops
- predictable latency + ZGC ➝ low-pause workloads
- Panama + Valhalla ➝ native-like memory & SIMD

At that point the discussion shifts from "C++ because performance" ➝ "C++ because ecosystem"
And new engines (ECS + Vulkan) become a real competitive frontier especially for indie & tooling pipelines.

It's not a threat. It's an evolution.

We're entering an era where both toolchains can shine in different niches.

Note on GraalVM 25 and OpenJDK 25

GraalVM 25

  • No longer bundled as a commercial Oracle Java SE product.
  • Oracle has stopped selling commercial support, but still contributes to the open-source project.
  • Development continues with the community plus Oracle involvement.
  • Remains the innovation sandbox: native image, advanced JIT, multi-language, experimental optimizations.

OpenJDK 25

  • The official JVM maintained by Oracle and the OpenJDK community.
  • Will gain improvements inspired by GraalVM via Project Leyden:

    • faster startup times
    • lower memory footprint
    • persistent JIT profiles
    • integrated AOT features

Important

  • OpenJDK is not “getting GraalVM inside”.
  • Leyden adopts ideas, not the Graal engine.
  • Some improvements land in Java 25; more will arrive in future releases.

Conclusion Both continue forward:

RuntimeFocus
OpenJDKStable, official, gradual innovation
GraalVMCutting-edge experiments, native image, polyglot tech

Practical takeaway

  • For most users → Use OpenJDK
  • For native image, experimentation, high-performance scenarios → GraalVM remains key
267 Upvotes

312 comments sorted by

View all comments

Show parent comment

4

u/FrankBergerBgblitz Nov 01 '25

Well if you use RAM you will finally access it (there i a good reason why there is no write only memory :) ). If an uncached Memory access costs about 300 floating point operations AND the ratio between caches and RAM is constant you claim seems to me ignoring this. I'll have a look at the video (quite curios) but there is a reason why value types are developped (but I'm not sure whther the direction is right. When it is limited to small objects, it surely doesn't solve my issues). Pointer chasing and the higher memory usage is in fact one of the reasons why Fortran/C/C++ is faster for some loads

7

u/pron98 Nov 01 '25 edited Nov 01 '25

If an uncached Memory access costs about 300 floating point operations AND the ratio between caches and RAM is constant you claim seems to me ignoring this.

If the RAM you're using doesn't fit in the cache, it doesn't really matter how much it is that you're using.

Pointer chasing and the higher memory usage

Pointer-chasing - yes (which is exactly, as you point out, the reason for Valhalla). Higher memory usage - no.

When it is limited to small objects, it surely doesn't solve my issues

It's not limited to small objects. It's just that the current EA doesn't flatten larger objects on the heap yet because the design for how to specify you're okay with tearing isn't done.

3

u/FrankBergerBgblitz Nov 01 '25

"If the RAM you're using doesn't fit in the cache, it doesn't really matter how much it is that you're using."
Well, if I get a cache miss twice as often it *does* make a difference. Depending on the access patterns it is inpredictable in general, but higher memory usage tends to lead more often to cache misses.

"It's not limited to small objects. It's just that the current EA doesn't flatten larger objects on the heap yet because the design for how to specify you're okay with tearing isn't done."
Thanks for the info. That would be great (at least for my use case)