zkEVM vs. zkVM: Unlocking Verifiable Compute Capabilities
TechFlow Selected TechFlow Selected
zkEVM vs. zkVM: Unlocking Verifiable Compute Capabilities
This article will compare the technical differences between zkEVM and zkVM, and introduce RISC Zero zkVM and its upcoming Bonsai network.
Navigating Web3 tides with focused insightsAuthor: Erik Kaneda, Senior Engineer at RISC Zero
Translation: Maxlion
Introduction
This article compares the technical differences between zkEVM and zkVM, and introduces RISC Zero's zkVM and its upcoming Bonsai network. RISC Zero is a general-purpose zkVM—its zkVM is a verifiable computer that works similarly to a real embedded RISC-V microprocessor, enabling programmers to write ZK proofs just like any other code. It supports writing ZK proofs in Rust and C++, and any language that compiles to RISC-V.
Background
As current smart contracts grow in complexity, dapps are becoming more advanced, block space is increasingly scarce, and the cost of running on-chain code continues to rise. In other words, if your DeFi logic becomes computationally expensive or your on-chain game requires additional computing power, you should consider using a zkVM or zkEVM to move complex application logic off-chain.
In this blog post, I want to explain how much one letter can make a difference in this context. I'll start with an overview of the EVM, then discuss zkEVM, followed by zkVM. While zkEVM allows you to run Solidity applications off-chain, RISC Zero’s zkVM and the upcoming Bonsai network allow you to write scalable, chain-agnostic code using Rust.
Quick Overview of the EVM:
EVM stands for Ethereum Virtual Machine—you can think of it as the software that executes all transactions on Ethereum.
Each node participates in the Ethereum network by running this software (e.g., implementations like geth). On Ethereum, transactions are represented as code in a format called EVM bytecode—the instructions for the EVM. Broadly speaking, these instructions handle mathematical computations, retrieve blockchain information, and transfer funds. There are many virtual machines in the world, each with its own specialty. Ethereum’s virtual machine is particularly important because it is well-suited for decentralized finance (DeFi) applications.
What does "zk" mean, and why is everyone putting it in front of everything?
One of the trendiest things lately is adding "zk" to the beginning of words. These two letters stand for zero-knowledge proofs. Wikipedia has many examples (my favorite is the "two balls and the colorblind friend" problem). If you're unfamiliar with them, I recommend taking a few minutes now to read about zero-knowledge proofs.
In short, zero-knowledge proofs enable verifiable computation. You can think of them as a way to ensure which computations were performed and that their results are correct. One way computers reach agreement on a result is by having every machine run the same code and compare outputs. Depending on the computation, this can be prohibitively expensive for resource-constrained systems. By using a zero-knowledge proof framework like RISC Zero, machines can verify correct execution by checking the mathematical validity of a proof, rather than re-running the same code (as in EVM).
At RISC Zero, we call these proofs "receipts", and I’ll use this term throughout the rest of this blog. Each receipt includes a cryptographic identifier indicating what computation was performed, along with a log of any public outputs from that computation. While this may seem simple, it means machines can generate receipts to "prove" a computation has been completed.
So what happens when you put "zk" in front of EVM?
The term zkEVM describes software that runs smart contracts on an EVM bytecode engine and generates receipts for specific computations (or transactions). This software can typically prove that two or more receipts are valid and then generate another receipt. Using this mechanism, a zkEVM can execute many transactions and represent them with a single receipt—a process known as a "Rollup". Projects written in Solidity can use zkEVMs to scale transactions by performing computations off-chain and publishing a single receipt on-chain to represent many off-chain transactions. There are many types of zkEVMs; if you'd like to learn more, check out this article.
zkVM: Unlocking Verifiable Computation by Dropping the "E"
At RISC Zero, we’ve implemented a zero-knowledge virtual machine (zkVM), not a zkEVM. The key difference is that “VM”—short for “virtual machine”—is far more general than EVM.
With a zkVM, you can run almost any software that runs on a computer—not just anything that runs on Ethereum. This computer uses the RISC-V architecture, a set of instructions designed for general-purpose computing. This means RISC-V doesn’t have built-in concepts like wallet addresses or other blockchain structures. The instruction set mainly consists of operators that move data between memory locations and perform mathematical operations on data. While this instruction set may seem overly generic, programmers don't need to know assembly language to write programs for this zkVM.
Compared to the EVM, this underlying RISC-V emulator allows programmers to write programs for the zkVM in languages like Rust, C/C++, and Go (note: we currently support Rust; support for C/C++ and Go is in progress). This means developers can leverage existing libraries from these language ecosystems. For example, we can run programs that play games like Wordle or Where's Waldo. But we’re not limited to simple games—you can run many other programs that compile to RISC-V.
Why Run RISC-V Programs?
If you're interested in frameworks that help you build better DeFi applications, you might wonder why we're building such a general-purpose computing framework like RISC Zero.
By allowing users to write programs in general-purpose languages, we open up possibilities beyond Solidity-based code. This means application logic isn’t constrained to what can be expressed in Solidity, enabling truly chain-agnostic development. General-purpose languages like Rust make it easier for developers to write diverse types of programs compared to domain-specific languages. For instance, you could write a simple arithmetic calculator in Rust that takes a math expression as input, computes the result, and returns it. If you expand this calculator to support common programming constructs like variables, loops, and functions, you’ve essentially built a simple interpreter—one that takes a program as input, runs it, and returns the output. Such programs can be compiled to RISC-V and executed on RISC Zero’s zkVM. With Rust, you can use existing crates to accelerate your application development instead of building everything from scratch.
One such library is the revm crate for Rust—an implementation of the EVM written in Rust. By using this crate, we can run an EVM bytecode interpreter inside the zkVM. This means you can execute Solidity contracts on an EVM interpreter running within the zkVM! Doing so, the zkVM produces a receipt representing the execution of the smart contract within the EVM. This concept has already been explored in Odra’s blog post and used by the zkPoEx team to enhance bug bounties.
How to Scale Blockchains?
As smart contracts grow in complexity, many find that maintaining on-chain code only increases costs over time. In other words, if your DeFi logic becomes increasingly computationally intensive, or your on-chain game demands more processing power, RISC Zero’s zkVM and the upcoming Bonsai network allow you to write scalable, on-chain-ready code using general-purpose programming languages. I've highlighted several examples in this post—we’re at the very beginning of truly scalable computing networks. If you’d like to see how this works, get started today, join our community, sign up for Bonsai, and help build a decentralized and scalable internet for everyone.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
RISC Zero
