After almost one year of development and a competitive audit by Cantina, we are excited to release the first production v1.0.0 version of OpenVM. OpenVM v1.0.0 is the next step in our mission to build a modular zkVM framework that provides developers extensibility without tradeoffs on performance. With this release, OpenVM is recommended for production and can verify Ethereum mainnet blocks for $0.0015 per transaction and under 3 minutes on CPU, a 5x+ improvement from the initial v0.1 release.
Developers can use OpenVM to generate ZK proofs that verify the execution of arbitrary Rust programs, accelerate proving with custom VM extensions, and verify proofs on-chain efficiently. The modular OpenVM zkVM framework enables developers to further tailor the ISA, ZK circuits, and proof system to their use case for the most optimal performance.
The v1.0.0 release of OpenVM is available today under MIT license on Github and is recommended for production usage. We are also releasing an OpenVM whitepaper providing a formal specification of our novel no-CPU zkVM design and audit reports from our Cantina competition and an internal audit by the Axiom team.
To learn more, check out the developer book, whitepaper, and Github. If you’d like to chat about using or contributing to OpenVM, join our developer Telegram.
What’s Supported in OpenVM 1.0.0
OpenVM v1.0.0 is a full-featured and performant zkVM framework which can generate ZK proofs for arbitrary Rust programs. OpenVM can handle programs as diverse and complex as Revm, Reth, or rollup state transition functions (like Scroll), and ships with:
A Rust frontend supporting std and no-std programs via compilation to RISC-V.
Verification of unbounded length programs via continuations and proof aggregation.
A Solidity verifier to efficiently verify OpenVM proofs in EVM.
A robust set of VM extensions allowing developers to efficiently verify operations like the following efficiently from within standard Rust programs:
SHA2-256 (new in v1.0.0) and Keccak hashes.
Elliptic curve operations over Weierstrass curves including ECDSA on secp256k1 and secp256r1 (new in v1.0.0).
Optimal Ate pairing on curves including BN254 and BLS12-381.
Int256 and modular arithmetic over arbitrary moduli.
STARK recursion.
In addition to this feature-rich set of defaults shipping with OpenVM, developers can customize OpenVM for their use cases by writing new program-specific VM extensions and integrating them seamlessly using OpenVM’s modular architecture. We applied this approach to optimizing recursion for the v1.0.0 release, with substantial performance benefits (more below!).Â
In conjunction with the release, we have formalized the specification for OpenVM in a new whitepaper and more detailed specifications, which together describe the behavior of the toolchain, transpiler, and ZK circuits underlying OpenVM. They also give soundness and security proofs for the underlying proof systems and describe the security goals of the system.
Performance Updates
The v1.0.0 release can prove Ethereum mainnet blocks for ~$0.0015 per transaction and in under 3 minutes on CPU machines. This represents a 5x+ performance improvement over our December 2024 v0.1 release and was enabled by optimizations across the stack, most notably with a blazing-fast new recursion system using program-specific circuits and direct hinting and substantial improvements to execution and tracegen.Â
To evaluate performance, we integrated the default VM extensions shipping with OpenVM into Revm and Reth and generated proofs for the state transition function for mainnet Ethereum blocks on CPU machines. We generated both STARK proofs and smaller proofs efficiently verifiable on the EVM and measured proving times on a single machine (serial) and multiple machines (parallel) as well as the cost per transaction.
On the same set of mainnet blocks we evaluated on the v0.1 release in December, OpenVM v1.0.0 improves by over 5x on both cost and latency, with proving costs under $0.001 per transaction. Proving latency is under 10 minutes on a single machine for both STARK and EVM proofs, dropping to under 3 minutes for EVM proofs and under 70 seconds for STARK proofs on multiple machines.
We also generated proofs for a more recent 1000 block range of mainnet blocks with block numbers between 22,000,000 and 22,000,999. OpenVM has a higher average proving cost of $0.0015 per transaction over this sample due to higher average gas usage per transaction, with single machine proving still under 10 minutes and multi-machine proving staying under 70 seconds for STARK proofs and 3 minutes for EVM proofs.
These benchmarks are reproducible via our benchmark repo here. We are encouraged by our progress on performance and are excited to keep shipping improvements – more here soon!
What’s Next
With this release, we are excited to see OpenVM used in live production environments including Scroll’s upcoming mainnet upgrade. In conjunction with this, Axiom is launching the hosted Axiom Proving API to support developers using OpenVM with deployment and ZK proof generation services.
In the coming months, we will continue development of OpenVM to add new proof system backends, new prover modalities (client-side, mobile, HW accelerated), and further improve proving performance. We remain committed to the modular and open development philosophy behind OpenVM and have started collaborations with several new ecosystem teams since the previous December release. If you are interested in contributing or a deeper collaboration, reach out on Telegram or X.Â
In the meantime, learn more and try out OpenVM today by checking out:
Developer Quickstart: A developer-focused guide to proving your first Rust program with OpenVM.
Developer Book: A guide for using OpenVM to prove arbitrary code execution in Rust and for customizing OpenVM by adding program-specific VM extensions.Â
Whitepaper and Specifications: A formal specification for OpenVM including details on the proof system, no-CPU architecture, continuations design, and soundness analysis.
As always, you can find our open-source code on Github – see you there!