RISC Zero

RISC Zero's zkVM is used to build zkRollups, a Layer 2 scaling solution. It generates succinct proofs (ZKPs) that attest to the validity of batched transactions off-chain, which are then posted to a base layer like Ethereum.

• Key Benefit: Enables high-throughput, low-cost transactions while inheriting the security of the underlying blockchain.
• Example: Projects can implement custom virtual machines (e.g., for EVM or other runtimes) and prove their execution, creating scalable app-chains.

The zkVM allows complex computations to be performed off-chain with a verifiable proof of correctness posted on-chain.

• Use Cases: Provable AI/ML inference, complex financial modeling, and verifiable game logic.
• Mechanism: Developers write code in Rust, compile it for the zkVM, and receive a receipt containing the proof and public outputs. This receipt can be verified by anyone, including a smart contract, without re-running the computation.

RISC Zero enables trust-minimized bridges by proving state transitions or message validity between blockchains.

• How it works: A prover generates a ZKP attesting that specific events (e.g., asset locks) occurred on a source chain. A verifier contract on the destination chain checks this proof to authorize minting or unlocking assets.
• Advantage: Reduces reliance on centralized multisigs or external validator sets, moving towards cryptographic security.

While not inherently private, RISC Zero's proofs can be combined with techniques to enable confidential computations.

• Private Inputs: The zkVM supports private inputs, allowing a prover to compute a function using secret data while only revealing the proof and the public result.
• Applications: Private voting, confidential identity verification, and selective disclosure of financial data in DeFi without exposing underlying secrets.

RISC Zero's Bonsai network is a decentralized platform that allows any smart contract or application to request a ZKP for arbitrary computation without running a prover.

• Function: Developers send computation requests to the Bonsai network, which returns a proof. This abstracts away the complexity and cost of proof generation.
• Impact: Enables ZK-as-a-Service, making advanced cryptography accessible to applications that couldn't manage their own proving infrastructure.

The RISC Zero zkVM allows developers to prove the correct execution of any program written in Rust (or languages that compile to RISC-V). This enables verifiable off-chain computation, where the integrity of complex logic can be cryptographically verified on-chain without re-execution.

• Key Use: Proving the result of a game simulation, a machine learning inference, or a complex financial calculation.
• Integration: Developers compile their existing Rust code for the zkVM, generating a STARK-based proof (a zk-SNARK) of the execution trace.

Bonsai is RISC Zero's decentralized network and API service that generates zero-knowledge proofs for any connected chain. It acts as a shared proving layer, allowing smart contracts to request and verify proofs without running heavy computation locally.

• Function: Developers send execution requests to Bonsai; it runs the code in the zkVM and returns a succinct proof.
• Ecosystem Role: Enables lightweight, cost-effective ZK verification on Ethereum, Avalanche, Polygon, and other EVM-compatible chains.

RISC Zero provides the foundational proving system for zkEVMs and ZK-rollups. Projects like Polygon zkEVM and Manta Network have used RISC Zero's technology to build scalable Layer 2 solutions.

• Mechanism: The zkVM can execute and prove EVM-equivalent transaction batches, generating validity proofs that are posted to Ethereum L1.
• Benefit: Provides the security of Ethereum with significantly higher throughput and lower fees through ZK-validated state transitions.

RISC Zero enables verifiable oracles by proving that specific data was fetched and processed according to a predefined algorithm. This creates tamper-proof data feeds for DeFi, insurance, and prediction markets.

• Process: An off-chain fetcher retrieves data (e.g., a price feed), processes it, and generates a zk-proof of the entire workflow.
• Trust Model: Consumers trust the cryptographic proof, not the honesty of the oracle node operator, reducing oracle manipulation risk.

A Zero-Knowledge Virtual Machine (zkVM) is a virtual machine whose execution can be cryptographically proven without revealing the inputs or internal state. RISC Zero's zkVM is based on the RISC-V instruction set architecture (ISA), allowing developers to write provable programs in languages like Rust. The core output is a zk-SNARK proof that attests to the integrity of the computation.

• Key Feature: General-purpose, not limited to specific circuits.
• Use Case: Creating verifiable off-chain computations for blockchain L2s, oracles, and co-processors.

zk-SNARKs are the cryptographic proof system used by RISC Zero to generate compact, easily verifiable proofs. A STARK is an alternative proof system with different trade-offs (e.g., no trusted setup, larger proof sizes). RISC Zero's implementation produces a receipt containing the zk-SNARK, which any verifier can check in milliseconds.

• Property: Succinct (small proof size), Non-interactive (single message from prover to verifier).
• Role in RISC Zero: The foundational cryptography that makes the zkVM's proofs possible.

Bonsai is RISC Zero's decentralized proving network and proof marketplace. It allows any application to request a zkVM proof without running the proving hardware themselves, paying for the service with the RISC Zero token (RISC). This separates the roles of application developer and proof generator.

• Function: Provides scalable, on-demand proving as a service.
• Economic Model: Uses a request/fulfillment model where provers are incentivized with fees.

RISC-V is an open-standard instruction set architecture (ISA). RISC Zero's zkVM implements a RISC-V runtime, meaning it executes standard RISC-V machine code. This allows developers to use existing RISC-V toolchains (like riscv-gcc) and write provable code in high-level languages that target RISC-V, primarily Rust via the risc0-zkvm crate.

• Benefit: Leverages a mature, open ecosystem of compilers and developers.
• Difference: It's a virtual RISC-V machine where execution generates a proof, not just a result.