Great goals drive technological leaps—just as the Moon Landing pushed the boundaries of aerospace, reconstructing the JVM with Rust and LLVM is our pursuit of redefining virtual machine technology.
The meaning of this project lies not only in building a functional JVM, but in leveraging modern tools to iterate on a decades-old classic: using Rust’s memory safety and system-level performance, combined with LLVM’s industrial-grade compilation capabilities, to create a more efficient, secure, and maintainable virtual machine.
Sun pioneered the JVM and HotSpot in the C++ era, laying the foundation for modern Java ecosystems. Now, with Rust—a better system programming language—we stand on the shoulders of giants to remake the JVM, integrating cutting-edge compiler and virtual machine technologies.
This is not a toy project, it is a collection of four core hard technologies:
- Rust system programming
- JVM specification implementation
- LLVM IR compilation
- JIT compiler design
It aims to:
- Combine Rust’s memory safety and zero-cost abstractions to solve the memory risks and performance overhead of traditional C++ based VMs
- Leverage LLVM’s powerful optimization capabilities to build a high-performance JIT compiler, achieving execution speed comparable to industrial-grade VMs like HotSpot
- Provide a modular, reusable virtual machine technology suite (split into crates) for the Rust and JVM ecosystems
This is a long-term endeavor—Sun spent 30 years refining the JVM, and Oracle continues to iterate on it. Our roadmap is divided into 3 core phases, with clear, actionable milestones:
- Pass TCK to achieve official Java compatibility
- Integrate GC (via crate) to support memory management
- Implement interpreter & LLVM-based JIT compiler to enable mixed execution for high performance
- Split the project into modular crates, building a reusable suite of VM technologies (GC, JIT, class loading, etc)
- Support WebAssembly to enable the JVM to run in browsers, expanding application scenarios
The journey of a thousand miles begins with a single step. Even the greatest technologies start with a bold vision. We are not just recreating the JVM—we are using modern tools to make it better, safer, and more adaptable to the future.
Just Do It. Let’s build a Rust-powered JVM for the next decade.