Jolt

Just One Lookup Table.

Jolt is a zkVM (zero-knowledge virtual machine) for RISC-V, built to be the simplest, fastest, and most extensible general-purpose of its kind. This repository currently contains an implementation of Jolt for the RISC-V 64-bit Base Integer Instruction Set + M Standard Extension for Integer Multiplication and Division + A Standard Extension for Atomic Operations + C Standard Extension for Compressed Instructions (RV64IMAC). Contributors are welcome!

The Jolt Book

• 🚧 currently undergoing updates 🚧

Jolt: SNARKs for Virtual Machines via Lookups
Arasu Arun, Srinath Setty, Justin Thaler

Twist and Shout: Faster memory checking arguments via one-hot addressing and increments
Srinath Setty, Justin Thaler

Unlocking the lookup singularity with Lasso
Srinath Setty, Justin Thaler, Riad Wahby

Initial launch:

• Releasing Jolt
• FAQ on Jolt's initial implementation

Updates:

• Nov 12, 2024 blog video
• Aug 18, 2025 (Twist and Shout upgrade) blog
• Oct 15, 2025 (64-bit Proving for Jolt) blog

• Proofs, Arguments, and Zero-Knowledge

For developers looking to build using Jolt, check out the Quickstart guide.

For developers looking to contribute to Jolt, follow the instructions below.

You will need the Rust toolchain pinned in rust-toolchain.toml.

If you have rustup installed, you do not need to do anything as it will automatically install the correct toolchain and any additional targets on the first cargo invocation.

Clone this repo:

git clone git@github.com:a16z/jolt.git

To check if rustup has picked the right version of Rust run rustup show inside the cloned repository.

cd jolt; rustup show.

Install the Jolt CLI:

cargo install --path .

This repository uses workspaces, and each workspace can be built individually, e.g.

cargo build -p jolt-prover

For faster incremental builds, use the build-fast profile:

cargo build --profile build-fast -p jolt-prover

Unit and end-to-end tests for the prover can be run using the following command:

cargo nextest run -p jolt-prover --features prover-fixtures

Examples in the examples directory can be run using e.g.

cargo run --release -p sha2-chain

Jolt is instrumented using tokio-rs/tracing for execution profiling.

To generate a trace, run e.g.

cargo run --release -p jolt-prover --features profiling -- profile --name fibonacci --format chrome

Where --name can be fibonacci, sha2-chain, sha3-chain, or btreemap. The corresponding guest programs can be found in the examples directory.

The command writes a timestamped directory under benchmark-runs/ containing trace.json, summary.json, and memory.html. The trace can be viewed in Perfetto.

CPU and memory counters are included in the Chrome trace. For a multi-scale sweep:

cargo run --release -p jolt-prover --features profiling -- benchmark --min-scale 18 --max-scale 21 --resume

Jolt uses allocative for memory profiling. The prover records per-batch heap snapshots for its live sumcheck state.

To generate allocative output, run:

cargo run --release -p jolt-prover --features profiling,allocative -- profile --name fibonacci --format chrome

Heap totals are included in summary.json and rendered in memory.html.

Tracer, Jolt's emulator, doesn't currently support attaching a debugger.

However, it supports backtraces for panics that happen in guest programs. By default, symbols are stripped from release guest ELFs and backtraces won't have much information. Debug/dev builds preserve symbols automatically.

There are two ways to enable backtrace support, depending on your workflow:

• JOLT_BACKTRACE=1 — ad-hoc debugging; set it in your shell and the guest auto-rebuilds with symbols preserved. The call stack is always captured; this just enables symbol resolution (function names, file:line). Use JOLT_BACKTRACE=full for register snapshots + cycle counts per frame.

  JOLT_BACKTRACE=1 cargo run --release -p example
  JOLT_BACKTRACE=full cargo run --release -p example

• backtrace = "dwarf" in #[jolt::provable] — bakes symbol preservation + -Cforce-frame-pointers=yes into the build. Use this for guests where you always want full debug support (test programs, dedicated debug builds), or when you need frame pointers for ZeroOS-level unwinding / external tooling. Not needed for normal debugging — JOLT_BACKTRACE=1 is sufficient for most cases.

  #[jolt::provable(backtrace = "dwarf")]
  fn my_function(input: u64) -> u64 { ... }

  Valid values: "off", "dwarf", "frame-pointers".

You can also control symbol preservation directly via jolt build --backtrace enable.

To further assist in debugging, Jolt supports print! and println! macros in guest programs. For no_std guests, import the macros via use jolt::println;. When std is enabled, the standard println! works automatically.

When debugging issues with guest programs, it's recommended to use the corresponding trace_analyze for your #[jolt::provable] functions. This skips instantiating the prover and allows for faster iteration.

Jolt ships an agent skill that teaches AI coding agents (Claude Code, Cursor, Codex, etc.) how to wrap Rust functions in Jolt zero-knowledge proofs.

npx skills add a16z/jolt

Fallback (Claude Code / Codex):

curl -sfL jolt.rs/skill | bash

We have enabled benchmarking during CI to track performance changes over time in terms of prover runtime and peak memory usage.

This repository started as a fork of https://github.com/arkworks-rs/spartan. Original Spartan code by Srinath Setty.

Jolt is dual licensed under the following two licenses at your discretion: the MIT License (see LICENSE-MIT), and the Apache License (see LICENSE-APACHE).

Jolt is Copyright (c) a16z 2023. However, certain portions of the Jolt codebase are modifications or ports of third party code, as indicated in the applicable code headers for such code or in the copyright attribution notices we have included in the directories for such code.

This code is being provided as is. No guarantee, representation or warranty is being made, express or implied, as to the safety or correctness of the code. It has not been audited and as such there can be no assurance it will work as intended, and users may experience delays, failures, errors, omissions or loss of transmitted information. Nothing in this repo should be construed as investment advice or legal advice for any particular facts or circumstances and is not meant to replace competent counsel. It is strongly advised for you to contact a reputable attorney in your jurisdiction for any questions or concerns with respect thereto. a16z is not liable for any use of the foregoing, and users should proceed with caution and use at their own risk. See a16z.com/disclosures for more info.