ere is a Rust workspace providing a unified interface and toolkit for working with multiple zero-knowledge virtual machines (zkVMs). It abstracts over the differences between zkVMs, allowing you to compile, execute, prove, and verify programs across several backends with a common API.

Supported zkVMs

zkVM	Status	Compile	Execute	Prove	Verify	Notes
SP1	✅ Full	✅	✅	✅	✅
OpenVM	✅ Full	✅	✅	✅	✅
RISC Zero	✅ Full	✅	✅	✅	✅
Jolt	⚠️ Partial	✅	✅	❌	✅	Prover incompatibility
Pico	⚠️ Partial	✅	❌	✅	❌	Missing execute and verify methods in API
Zisk	⚠️ Partial	❌	❌	❌	❌	Ziskup not working in Docker

Features

Unified Rust API for compiling, executing, proving, and verifying zkVM programs
Pluggable backends: swap between zkVMs with minimal code changes
SDK installer scripts for all supported zkVMs

Directory Structure

crates/zkvm-interface/ — Core traits (Compiler, zkVM), input serialization, and reporting types
crates/ere-{zkVM}/ — zkVM specific backend
tests/ — Example guest programs and integration tests for each backend
scripts/sdk_installers/ — Shell scripts to install the SDKs for each zkVM
docker/ — Dockerfiles and build contexts for each zkVM environment

How It Works

1. The Interface

The zkvm-interface crate defines two main traits:

Compiler: Compiles a guest program (e.g., a Rust crate) into the appropriate binary/artifact for a zkVM
zkVM: Executes, proves, and verifies programs on a zkVM

Each backend implements these traits for its own types.

2. Backend Crates

Each backend crate (e.g., ere-sp1, ere-jolt) implements the Compiler and zkVM traits, handling the specifics of compilation, execution, proof generation, and verification for its respective zkVM. The Compiler and zkVm trait living in the same crate is purely coincidental, it is entirely possible for the compiler to live elsewhere.

3. Input Handling

The Input struct in zkvm-interface serializes input data for guest programs, supporting chunked and contiguous access. Some zkVMs will ask for the input as a list of lists of bytes, while others want a list of bytes.

4. Testing

Each backend has a set of guest programs and tests under tests/<backend>/, which are used to validate compilation, execution, and proof/verification flows. This test corpus is expected to grow over time.

5. SDK Installation

SDKs for each zkVM can be installed using the scripts in scripts/sdk_installers/.

Usage

1. Install SDKs

Before using a backend, install its SDK:

bash scripts/sdk_installers/install_sp1_sdk.sh
bash scripts/sdk_installers/install_jolt_sdk.sh

2. Add as a Dependency

Add the relevant crates to your Cargo.toml as needed.

3. Example: Compiling and Proving a Program

use zkvm_interface::{Compiler, zkVM, Input};
use ere_sp1::{EreSP1, RV32_IM_SUCCINCT_ZKVM_ELF};

let program_path = std::path::Path::new("path/to/guest");
let elf_bytes = RV32_IM_SUCCINCT_ZKVM_ELF::compile(program_path).unwrap();

let mut input = Input::new();
input.write(&42u32).unwrap();

let (proof, report) = EreSP1::prove(&elf_bytes, &input).unwrap();
EreSP1::verify(&elf_bytes, &proof).unwrap();

4. Running Tests

Each backend crate and guest program has its own tests. Run them with:

cargo test --workspace

Note: for this to work, you will need to have installed the relevant toolchain and target for the zkVM test you want to run. The recommended workflow is to use Docker.

Contributing

Contributions are welcome! Please open issues or pull requests

Disclaimer

zkVMs are rapidly improving, so the API is subject to a lot of change. In terms of scope, although the API is generic, the main use case will be zkEVMs. This may manifest itself in the selection of precompiles that may be chosen as defaults.

License

MIT OR Apache-2.0