| Authors | Jeremy Bruestle, Paul Gafni, and the RISC Zero Team |
|---|---|
| Paper title | RISC Zero zkVM: Scalable, Transparent Arguments of RISC-V Integrity |
| Date and status | August 11, 2023 — draft |
| Project | RISC Zero |
| Paper license | Not stated in the PDF |
| Official source | Official RISC Zero draft PDF |
This paper describes how RISC Zero proves that a computation on a RISC-V virtual machine followed its rules. The formal paper is dated August 11, 2023, is marked as a draft, and is by Jeremy Bruestle, Paul Gafni, and the RISC Zero Team. It focuses on the cryptographic argument behind computational receipts; it is not a general performance benchmark or a complete account of today’s RISC Zero products.
| Original paper | Original paper |
|---|---|
| Directories | Ethereum Whitepapers & Research |
What the Paper Covers
Usually, a party checking a computation has to run it again. That becomes expensive for large workloads. A proof system lets a prover show that a specified program and inputs support a stated claim, while a verifier checks a more compact proof. In a zkVM, a guest program runs in a virtual machine and a receipt binds the program’s identity and public outputs to claims about its execution.
From Program to Receipt
RISC Zero’s current documentation describes the general flow this way: a guest program is compiled to an ELF file; the executor runs it and records a session; the prover checks the session and produces a receipt. The receipt includes a journal of outputs the program deliberately makes public. A verifier can check the receipt and claims about the program that ran. This can verify computation without replaying all of the work, but public outputs remain visible; the application decides what data to publish.
The Proof Construction in the 2023 Draft
The draft models execution as an execution trace: an ordered record of machine states as instructions run. Constraints define which transitions are valid. The system checks whether the trace satisfies those constraints and ties that check to the RISC-V program and its output claims.
The paper describes a STARK construction using AIR with randomized preprocessing. The preprocessing includes a PLONK-based memory-permutation argument and a PLOOKUP range check. DEEP-ALI and FRI then let a verifier test polynomial properties of trace data through selected checks instead of reading every computation step. In the practical protocol, Fiat–Shamir replaces interactive challenges with values derived using HMAC-SHA-256. This is a high-level outline: security depends on the complete protocol, parameters, hash assumptions, soundness analysis, and implementation.
Transparency and the Scope of Setup Claims
The draft describes its core STARK proof as transparent: parameters can be derived or checked from public information, without a trusted ceremony holding a secret trapdoor. That claim should not be generalized to every RISC Zero receipt. Current documentation also describes Groth16 receipts that wrap succinct proofs, and RISC Zero documents a separate trusted setup ceremony for that Groth16 circuit. So “RISC Zero requires no trusted setup” is too broad unless it specifies which proof is meant.
What the Paper Does Not Establish
- The paper is not a benchmark comparing proving time or production cost across all applications.
- Using RISC-V does not make every program efficient to prove; workload and guest support still matter.
- Zero knowledge does not automatically hide all data. The journal and any inputs chosen as public can remain visible to an application’s users.
- A receipt supports only claims bound to the verified program, image ID, inputs, and outputs; it does not prove that an entire application or network is bug-free.
For current use, the developer documentation discusses local proving and remote proving requests through Boundless. Ethereum integration can wrap a STARK proof in Groth16 for smaller on-chain verification, with its own assumptions and trade-offs.
Social Media Sentiment
A February 2026 r/CryptoTechnology discussion shows both interest and caution about verifiable computation. One commenter names RISC Zero and Succinct among the zkVM approaches closest to general-purpose use, while also flagging proving times far slower than native execution, especially for AI workloads. This is one self-selected discussion, not a survey or a measure of RISC Zero adoption.
Last updated: 2026-10
Related Terms
See Also
- Scalable, transparent, and post-quantum secure computational integrity (STARKs)
- Plonky2: Fast Recursive Arguments with PLONK and FRI
- Halo 2: Zcash’s PLONKish Proof System
Sources
- Bruestle, J., Gafni, P., and the RISC Zero Team (August 11, 2023). RISC Zero zkVM: Scalable, Transparent Arguments of RISC-V Integrity (draft). Read the official PDF — primary source for the title, authors, date, draft status, and proof construction summarized here.
- RISC Zero Developer Docs. Proof System Overview. Read the proof-system overview — describes composite, succinct, Groth16, and fake receipts in development mode.
- RISC Zero Developer Docs. zkVM Overview. Read the zkVM overview — explains the guest, execution, receipt, and local or Boundless proving options.
- RISC Zero Developer Docs. Trusted Setup Security. Read the Groth16 setup explanation — limits the trusted-setup claim to the Groth16 wrapper.
- RISC Zero Developer Docs. RISC Zero on Ethereum. Read the Ethereum integration guide — explains wrapping STARK proofs with Groth16 for on-chain verification.
- r/CryptoTechnology (February 2026). What’s the current state of verifiable compute? Read the community discussion — a limited sample about usefulness, proving time, and zkVM compute overhead.