zkEVM explained: zkSync, Starknet, Scroll and Polygon approaches
Thread1,052 words
Explains the EVM and what a zkEVM is, then classifies the projects by compatibility level. zkSync and Starknet transpile at the language level, Scroll and Polygon target bytecode level, with caveats on EVM equivalence claims.
Key claims
zkEVMs enable general-purpose zk rollups, unlike app-specific ones
zkSync 2.0 and Starknet are language-level, Scroll and Polygon bytecode-level
Polygon's zkEVM was disputed as EVM-compatible rather than equivalent
0/ zero knowledge rollups are the future of $ETH scaling & the rise of EVM-compatible zk-rollups (zkEVM) is a big step towards unlocking unprecedented scalability on L2 ⚡️✨
@zksync, @Scroll_ZKP, @StarkWareLtd & @0xPolygonHermez
a 🧵 on what #zkEVM is & why it matters (0/37)👇
1/ but before we dive into @zksync, @Scroll_ZKP, @0xPolygonHermez & @StarkWareLtd’s #Starknet, let first have a look what the #Ethereum Virtual Machine (EVM) is
2/ so basically, the #EVM is a piece of software that executes smart contracts & computes the state of the $ETH network after a new block is added to the chain
3/ the #EVM sits on top of $ETH’s hardware & node layer & its main purpose is computing the network's state & compiling various types of smart contract code (written in human-readable languages) into a machine-readable format called bytecode (numbers) to run the smart contracts
4/ the #EVM hence powers smart contract execution and is one of the core features of $ETH. Instead of a classic distributed ledger of transactions, the EVM basically transforms #Ethereum into a distributed state machine
5/ #Ethereum's state is a large data structure which holds not only all accounts & balances, but also an overall network or machine state which can change from block to block according to a pre-defined set of rules
6/ the specific rules of changing state from block to block are defined by the #EVM. At any given block in the chain, #Ethereum has one & only one canonical state with the rules for valid state transition being defined by the EVM spec
7/ but now that we have a basic understanding of what the EVM is, WTF is a #zkEVM?
8/ a #zkEVM is a virtual machine that executes smart contracts in a way that is compatible with zero-knowledge-proof computation and the programming languages supported by the originial EVM
9/ however, this can be quite difficult to build. A zkEVM rollup's main goal is to run EVM bytecode. Unfortunately though, zk-proofs require all the computational statements they are proving to be converted into a very specific format to then be compiled down into a STARK/SNARK
10/ there are a few ways to do it:
- prove the EVM execution trace directly by converting it into the verifiable format (@Scroll_ZKP)
- create a custom VM, map EVM opcodes to opcodes for that VM & prove correctness of the trace in that custom environment (@0xPolygonHermez)
...
11/...
- create a custom VM, transpile Solidity into the custom VM’s bytecode (directly, or via a custom high level language) & prove in a custom environment (@zkSync & @StarkWareLtd)
12/ but before we have a closer look at the individual projects a few basics:
why do zkEVMs matter?
well, prmarily because zkEVM for the first time enables general purpose zk-rollups. So far, we have only seen application-specific zk-rollups & validiums
13/ zkEVM will now finally unlock zk-rollups's unprecedented scalability for entire ecosystems of composable #DeFi protocols & potentially even (application-specific) recursive rollup structures on top of zkEVMs (L3 scaling as outlined by @StarkWareLtd)
x.com/expctchaos/status/1535336011634335744
14/ what are zk-rollups you ask?
high-level, zk-rollups use fancy cryptography to take some of the load off $ETH L1, resulting in increased throughput & lower tx fees on #L2
for more info see:
x.com/expctchaos/status/1527419760593584136
15/ while app-specific rollups (@dYdX, @Immutable, @loopringorg) have already gained traction in the past, the technology needs general purpose rollups in order to onboard developers & users to generate network effects as quickly as possible
16/ rollup teams are hence deeply concerned about
- migrating existing $ETH contracts (& devs) to their rollup
- being supported by existing EVM tooling (e.g. libraries, wallets, marketplaces etc.)
the simplest way to achieve both goals is to create a zkEVM as outlined in 7-11
17/ but let's get into the #zkEVMWars
back in July, a trio of announcements from @Scroll_ZKP, @the_matter_labs and Polygon kicked off the race to mainnet, a.k.a. the zkEVM wars, as each company implied that it would be the “first” to bring a zkEVM to market
18/ as recently described by @Scroll_ZKP founder @LuozhuZhang in a Twitter thread, there are three different types of #zkEVMs:
- bytecode level
- language level
- consensus level
based on this definitions all above zkEMVs fall in the first two categories
source: @MessariCrypto
19/ the holy grail of zkEVMs basically is reaching full bytecode-level compatibility and hence what is referred to as EVM equivalence (a term coined by @OptimismFDN):
x.com/expctchaos/status/1532284764895555584
20/ but let’s start with @zkSync’s EVM implementation
for more info on #zkSync in general, see:
x.com/expctchaos/status/1527434674494226464
21/ in terms of type of #zkEVM, #zkSync 2.0 falls into the language-level bucket. Consequently, devs can write smart contracts in #Solidity, but @zkSync transpiles that code into a language optimized for zk-proofs called Yul behind the scenes
source: @the_matter_labs
22/ while @the_matter_labs, claims that this system was engineered to provide the rollup scalability advantages, primarily in the proofing process, by most definitions, @zkSync’s EVM implementation would likely be described as EVM-compatible rather than #EVM-equivalent
23/ not being equivalent means that #zkSync potentially isn’t 1:1 compatible with every single $ETH tool out there, which might result in additional overhead for devs. However, @the_matter_labs insists that this shouldn’t be an issue in the long-term
23/ this is similar to the approach @StarkWareLtd takes with #StarkNet & the programming language #Cairo
25/ #Starknet is based on the Cairo programming language, which is optimized for zk-proofs. To enable smart contracts & composability, StarkNet takes a language-level compatibility approach & transpiles EVM-friendly languages (e.g. Solidity) down to a STARK-friendly VM (in Cairo)
26/ just yesterday, @StarkWareLtd announced Cairo 1.0 which it claims will enhance usability, safety & convenience
x.com/StarkWareLtd/status/1569348258916630528
27/ @Scroll_ZKP & @0xPolygonHermez on the other hand, are both taking the maybe a bit more ambitious bytecode-level approach to their zkEVMs
28/ these approaches rip out the transpiler step completely, meaning they don’t convert #Solidity code into a separate language before it gets compiled & interpreted
29/ this generally results in better compatibility with the EVM. But even here, there are distinctions that probably make @Scroll_ZKP more of a “true” zkEVM than @0xPolygonHermez
30/ when #Polygon announced bringing the first #EVM-equivalent zkEVM to market back in July, it was quickly pointed out by many that the #zkEVM implementation likely better described as EVM-compatible rather than EVM-equivalent based on its specifications
4 images on X
How the covered assets moved · since 13 Sep 2022
Prices as of 23 Oct 2026This explainer walks through how things work without making a call on the token, so price moves since publication are shown as market context.
Mentioned for context
Since then
Zero has written 7 more pieces on zkSync since this one.
- Make ICOs Great Again: how VC-dominated token launches broke crypto marketsOn zkSync
- The ZK trademark saga: Matter Labs, zkSync and the community backlashOn zkSync
- zkSync Era as a volition: zkPorter accounts and Guardian-secured off-chain DAOn zkSync
- zkSync ZK Stack explained: hyperchains, L3 recursion and hyperbridgesOn zkSync
Daily closes in USD from DefiLlama and Yahoo Finance. Only a bullish or bearish thesis is read as a call; explainers, maps and mentions are context. Not financial advice.