Definition:
RISC Zero is a general-purpose zero-knowledge virtual machine (zkVM) that executes programs compiled to RISC-V bytecode and generates a ZK proof (called a Receipt) attesting to their correct execution — allowing any Rust program (or code compiled to RISC-V) to become a verifiable computation whose result can be trusted without re-executing the program. Unlike application-specific circuits, RISC Zero’s zkVM lets developers write normal code and get ZK guarantees without needing to know ZK cryptography.
Why General-Purpose ZK VMs Matter
Traditional ZK systems require writing specialized arithmetic circuits for every computation — a highly skilled, time-consuming process. RISC Zero’s approach:
- Developers write standard Rust code
- The code compiles to RISC-V (a standard open instruction set)
- RISC Zero proves any RISC-V execution trace with ZK proofs
- The proof (Receipt) can be verified on-chain or off-chain
This drastically lowers the barrier to ZK-proofing any computation.
Core Architecture
RISC-V Instruction Set:
RISC Zero’s zkVM implements a subset of RISC-V RV32IM — a widely supported, fixed instruction set. Any code that compiles to RISC-V can run inside the zkVM.
Proof System (STARK-based):
RISC Zero uses its own STARK-based proof system called STARK to SNARK (sometimes referred to as a composition approach):
- An inner STARK proof proves the execution of the RISC-V program
- The STARK is then wrapped in a SNARK (Groth16 or PLONK) for cheap on-chain verification
This two-layer approach gives the scalability of STARKs with the small proof size of SNARKs for Ethereum submission.
Journal (Public Output):
The zkVM execution produces a Journal — the public outputs the program writes during execution. The Receipt (ZK proof) commits to the Journal’s contents, so the verifier knows the public outputs are correct.
Image ID:
Each program has an Image ID — a commitment to the program being executed. The Receipt commits to the Image ID, so the verifier knows not only that execution was correct but exactly which program ran.
Bonsai Network (Proving Service)
Running ZK proofs is computationally intensive. RISC Zero’s Bonsai is a cloud proving service:
- Submit a RISC-V program and inputs to Bonsai’s API
- Bonsai distributes proving across GPU clusters
- A verified Receipt is returned to the caller
Smart contracts (e.g., on Ethereum) can request proofs via the Bonsai API through an on-chain callback pattern, outsourcing the heavy computation while still verifying the result trustlessly.
Steel — EVM Coprocessor
Steel is RISC Zero’s EVM view call library:
- Allows Rust programs running inside the zkVM to make authenticated Ethereum state reads
- The program proves it read correct on-chain data (using Merkle proofs of the Ethereum state trie)
- Enables the ZK coprocessor pattern: prove historical Ethereum state facts off-chain, verify on-chain
Ethereum Integration
RISC Zero provides:
- Groth16 verifier contract — Deployed on Ethereum for final on-chain verification of SNARK-wrapped proofs
- Bonsai Relay contract — On-chain coordination for the Bonsai async proving pattern
- Foundry integration — forge test-compatible proof generation for integration testing
- EIP-4844 support — Proofs submitted as blobs for future scalability
Comparison to SP1 (Succinct)
| Feature | RISC Zero | SP1 (Succinct) |
|---|---|---|
| ISA | RISC-V RV32IM | RISC-V RV32IM |
| Proof system | Custom STARK + SNARK wrapper | Plonky3-based |
| Proving service | Bonsai | Succinct Prover Network |
| Language support | Rust + any RISC-V target | Rust + any RISC-V target |
| Open source | Yes (MIT/Apache) | Yes |
| EVM integration | Yes (Groth16 verifier) | Yes |
Both systems target the same use cases and compete directly as the leading general-purpose zkVM platforms as of 2024–2025.
Use Cases
- ZK rollup sequencer proofs — Prove an entire L2 block’s execution in one Receipt
- Private computation — Prove computation results without revealing inputs
- ZK coprocessors — Prove historical Ethereum state queries (via Steel)
- Verifiable ML inference — Prove a neural net produced a specific output
- ZK gaming — Prove game state transitions without revealing moves
Related Terms
Sources
- RISC Zero Documentation — Official developer documentation for the zkVM and Bonsai.
- RISC Zero GitHub — Open-source zkVM implementation.
- RISC Zero zkVM Technical Specification — Architecture of the proof system.
- Bonsai Network — Proving-as-a-service documentation and API reference.
Last updated: 2026-04