RISC Zero zkVM with Rust

Update your system and install required dependencies:

sudo apt update
sudo apt upgrade -y

Install build essentials, LLVM toolchain, and supporting libraries:

sudo apt install -y \
  build-essential \
  curl \
  git \
  pkg-config \
  libssl-dev \
  clang \
  cmake \
  llvm \
  lld \
  protobuf-compiler \
  libclang-dev \
  ca-certificates

sudo apt install -y docker.io docker-buildx
export DOCKER_BUILDKIT=1
docker buildx create --use
docker buildx inspect --bootstrap
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Verify everything is in place:

docker --version
git --version
clang --version

You should see something like this:

Install Rust via the official installer, then source the environment:

curl https://sh.rustup.rs -sSf | sh
source ~/.cargo/env

Update and add useful components:

rustup update
rustup component add rustfmt
rustup component add clippy

Verify:

rustc --version
cargo --version

Obligatory example...

Install the RISC Zero CLI and zkVM toolchain:

curl -L https://risczero.com/install | bash
source ~/.bashrc
rzup install

Verify:

rzup --version
cargo risczero --version

Lets see what we get this time. oh right.

Scaffold a new zkVM project and generate its lockfile:

cd ~
cargo risczero new my_project --guest-name guest
cd my_project
cargo generate-lockfile

Your project structure will look like this:

Open methods/guest/src/main.rs and replace its contents:

use risc0_zkvm::guest::env;

fn main() {
    let input: u32 = env::read();
    let result = input * 2;
    env::commit(&result);
}

1. Reads input supplied by the host.
2. Performs a computation (doubles the value).
3. Commits the result to the public journal for proof generation.

How its looking so far

Open host/src/main.rs and replace its contents:

Rust · Hostuse risc0_zkvm::{default_prover, ExecutorEnv};
use methods::{GUEST_ELF, GUEST_ID};

fn main() {
    let input: u32 = 10;

    let env = ExecutorEnv::builder()
        .write(&input)
        .unwrap()
        .build()
        .unwrap();

    let prover = default_prover();

    let receipt = prover
        .prove(env, GUEST_ELF)
        .unwrap()
        .receipt;

    receipt.verify(GUEST_ID).unwrap();

    println!("Proof verified successfully");

    std::fs::write(
        "receipt.bin",
        bincode::serialize(&receipt).unwrap()
    ).unwrap();
}

1. Sends the input value to the guest program.
2. Executes the guest inside the zkVM.
3. Generates and verifies the zero-knowledge proof.
4. Saves the receipt to receipt.bin.

Should have something like this now.

Compile the guest program to a RISC-V ELF binary:

cargo risczero build

Development proof — fast iteration without full cryptographic overhead:

RISC0_DEV_MODE=1 cargo run --release

Production proof — generate a real, cryptographically secure proof:

unset RISC0_DEV_MODE
cargo run --release

Create a separate binary for verifying receipts independently:

mkdir -p host/src/bin

Then create host/src/bin/verify_receipt.rs:

Rust · Verifieruse risc0_zkvm::Receipt;
use methods::GUEST_ID;

fn main() {
    let data = std::fs::read("receipt.bin").unwrap();
    let receipt: Receipt = bincode::deserialize(&data).unwrap();

    receipt.verify(GUEST_ID).unwrap();

    let result: u32 = receipt.journal.decode().unwrap();
    println!("Receipt verified!");
    println!("Guest result: {}", result);
}

cargo run --release --bin verify_receipt

If builds fail or you need a fresh start:

cargo clean
rm -rf ~/.cache/risc0
cargo risczero build

For fully reproducible builds, create a Dockerfile in your project root:

FROM rust:1.77

RUN apt update && apt install -y \
    clang cmake llvm lld protobuf-compiler

RUN curl -L https://risczero.com/install | bash

ENV PATH="/root/.cargo/bin:${PATH}"

WORKDIR /app
COPY . .

RUN rzup install
RUN cargo risczero build

CMD ["cargo","run","--release"]

Build and run:

docker build -t risczero-demo .
docker run risczero-demo

# System deps
sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential curl git pkg-config \
  libssl-dev clang cmake llvm lld protobuf-compiler \
  libclang-dev docker.io

# Rust
curl https://sh.rustup.rs -sSf | sh
source ~/.cargo/env

# RISC Zero
curl -L https://risczero.com/install | bash
source ~/.bashrc
rzup install

# Project
cargo risczero new my_project --guest-name guest
cd my_project
cargo risczero build

# Dev proof
RISC0_DEV_MODE=1 cargo run --release

# Production proof
unset RISC0_DEV_MODE
cargo run --release

# Verify
cargo run --release --bin verify_receipt