zkVM benchmark: why RISC Zero R0 won the Nescience test
Quote894 words25 likes
Walks through Vac's benchmark of six zkVMs for the Nescience privacy architecture. R0 won on proof speed, size and memory; Valida is promising but early; SP1 lacks full ZK; zkWASM was weakest.
Key claims
R0 emerged as best fit of six zkVMs
SP1 dismissed for lack of ZK support
zkMIPS faced major memory issues
📊 zkVM Performance Analysis 📊
zkVMs are the scaling endgame and many high-profile teams are competing for supremacy in this emerging billion $$$ vertical.
Today, we will explore third-party benchmarks of zkVM performance, in order to identify the leaders of the narrative.
Alpha. ↓
General-purpose zkVMs are ZK proof systems designed to allow the verifiable execution of arbitrary program logic off-chain, while maintaining on-chain verifiability through succinct cryptographic proofs.
zkVMs are key to broaden the design space for Web3 builders, and allow them to break free from the limitations of blockchains like Ethereum, while retaining the decentralization of their applications.
Check the QT post below for a more comprehensive overview of the zkVM landscape.
In this post, the focus lies on benchmark testing that @vacp2p has done.
@vacp2p is a principle-driven research and development group that provides technical support to @InstituteFT startups.
Recently, @vacp2p has conducted a series of tests to identify the most suitable zkVM for a project called Nescience.
Nescience is a user-centric state-separation architecture designed for blockchain applications, giving users control over their on-chain privacy settings.
Unlike traditional privacy-focused blockchain systems, where developers set fixed privacy rules, Nescience allows users to customize privacy for each transaction using four execution types: public, private, shielded, and de-shielded.
➤ Public executions are transparent
➤ Private executions ensure full confidentiality using UTXO models
➤ Shielded executions hide certain details (e.g., the receiver's identity)
➤ De-shielded executions selectively reveal tx data (e.g. sender identity)
By leveraging cryptographic tools like ZK proofs and sparse Merkle trees, Nescience strikes a balance between privacy and transparency, offering a flexible, privacy-focused solution for any decentralized application.
In narrowing down zkVM options, @vacp2p focused on several key factors, ultimately seeking a zkVM that could support these specific requirement:
First, they prioritized fully implemented zero-knowledge functionality, ensuring the zkVMs could reliably generate and verify zero-knowledge proofs that preserve privacy.
Performance was another critical consideration, with an emphasis on zkVMs that demonstrated strong benchmarks in terms of speed and efficiency.
Additionally, specific functionalities such as lookup tables, precompiles, and recursive capabilities were essential, as these features are crucial within the Nescience framework.
In the end, the selection for the testing came down to:
➤ @SuccinctLabs' SP1: A performant, open-source zkVM supporting LLVM-based languages like Rust. It enables recursive proofs using Plonky3 but does not fully implement zero-knowledge functionality, focusing more on aggregation and supporting many cryptographic systems.
➤ R0 by @RiscZero: A zkVM built on RISC-V architecture, supporting Rust and C code execution. It uses STARKs for security and can prove execution of cryptographic functions like SHA-256 and ECDSA, making it versatile and adaptable.
➤ Nexus by @NexusLabsHQ: A highly parallelized, prover-optimized zkVM focused on performance and security. Written in Rust, it supports recursive proofs through the Nova folding scheme and offers broad language support, including Rust and C++.
➤ zkMIPS by @ProjectZKM: A zkVM based on the MIPS microarchitecture, utilizing Plonky2. It supports Ethereum as a global settlement layer and can run arbitrary Rust code, unique for its use of the MIPS opcode set.
➤ zkWASM by @DelphinusLab: A zkVM adhering to the standard WASM bytecode specification, allowing Rust code to be compiled and executed as WASM, providing broad language support and flexibility.
➤ Valida by @lita_xyz: A STARK-based zkVM designed for high prover performance and code reuse. It supports conventional programming languages via a RISC-inspired instruction set and is engineered for extensibility with custom user-defined instructions.
So let's have a look at the results of the @vacp2p analysis.
The testing had two phases:
➊ Arithmetic operations
This phase assessed zkVMs' efficiency in handling arithmetic tasks (addition, subtraction, multiplication, etc.) using heptagonal numbers, measuring their speed and ability to process complex calculations.
➋ Memory consumption
The second phase tested memory management with data structures like hash maps and queues. zkVMs were evaluated on operations like insert, delete, append, and search to detect memory bottlenecks and assess performance under heavy loads—key for Nescience's data-intensive tasks.
After thoroughly evaluating six zkVM candidates for the Nescience project, @RiscZero's R0 emerged as the top choice due to its strong balance of proof generation speed, size, and manageable memory usage.
Its robust ZK proof capabilities and support for multiple programming languages align perfectly with Nescience’s privacy, performance, and flexibility requirements.
@lita_xyz's Valida showed potential with high prover performance but is still too early in development, facing Rust integration challenges and limitations in handling complex memory operations.
@SuccinctLabs' SP1 was dismissed due to the lack of zero-knowledge proof support, despite decent arithmetic performance.
Nexus by @NexusLabsHQ offered consistent proof sizes but struggled with memory-heavy tasks, and its performance with larger workloads was not competitive.
zkMIPS by @ProjectZKM had promising proof times but faced major memory issues, disqualifying it.
zkWASM by @DelphinusLab was the weakest, with poor performance in proof size and generation time, and excessive RAM usage made it impractical for Nescience.
In conclusion, @RiscZero's R0 is currently the best fit, with Valida a potential future contender.
While this testing relates to a specific use case, the analysis definitely provides interesting insights into the performance of these systems, and impressively proves the leading role @RiscZero currently holds within this vertical.
Don't fade ZK.
Don't fade @RiscZero.
Bonus alpha: @RiscZero's R0 zkVM, which has emerged as the winner of this performance test, also powers Steel 1.0, a highly scalable smart contract execution prover for EVM devs.
DYOR. ↓
x.com/zerokn0wledge_/status/1843538762866843750
QUOTING @zerokn0wledge_
✨ The zkVM Landscape ✨ ZK-powered, verifiable execution is the scaling endgame. List of top 15 zkVM projects you have to know.↓ ➊ What is a zkVM? A zero-knowledge virtual machine (zkVM) is ZK proof system that allows developers to prove the off-chain execution of arbitrary so
✨ The zkVM Landscape ✨ ZK-powered, verifiable execution is the scaling endgame. List of top 15 zkVM projects you have to know.↓ ➊ What is a zkVM? A zero-knowledge virtual machine (zkVM) is ZK proof system that allows developers to prove the off-chain execution of arbitrary so
2 images on X