ZK-EVMs Compared: Polygon zkEVM, zkSync Era, Scroll, and Starknet

The ZK-EVM Landscape in 2026

Zero-knowledge Ethereum Virtual Machines have matured from research projects to production infrastructure handling billions in daily transaction volume. By early 2026, four ZK rollups dominate developer mindshare: Polygon zkEVM, zkSync Era, Scroll, and Starknet. Each makes different tradeoffs between EVM equivalence, proving speed, decentralization, and developer tooling.

The key distinction is equivalence level, defined by Vitalik Buterin's ZK-EVM taxonomy:
Type 1: identical to Ethereum at the bytecode level. Highest compatibility, slowest proving.
Type 2: EVM-equivalent at the bytecode level with minor state representation differences. Near-full compatibility, fast proving.
Type 3: EVM-compatible with some opcodes unimplemented.
Type 4: compiles Solidity/Vyper to a custom VM rather than generating EVM bytecode proofs.

Where each player sits in 2026 determines what contracts you can deploy unmodified and what developer tooling works out of the box.

Polygon zkEVM

Polygon zkEVM targets Type 2 equivalence. It generates proofs over EVM bytecode, meaning standard Solidity contracts compile and deploy without modification. Most Ethereum tooling — Hardhat, Foundry, Remix, Etherscan verification — works directly.

Prover architecture: Polygon uses a recursive proof system where individual transaction proofs are aggregated into a single proof that is verified on Ethereum mainnet. The prover is centralized but scheduled for progressive decentralization.

Performance in 2026: approximately 2-5 second proof generation for simple transactions on the sequencer side, with batch proof times of minutes. Finality on L1 (full ZK finality) takes roughly 30 minutes per batch. Soft finality (sequencer confirmation) is near-instant.

Strengths: best Ethereum tooling compatibility of any ZK rollup, active ecosystem, strong Polygon Labs backing, and integration with AggLayer for cross-chain liquidity sharing.

Limitations: proving costs remain non-trivial; some complex precompile operations still have higher gas costs than Ethereum mainnet.

zkSync Era

zkSync Era operates as a Type 4 system — it compiles Solidity and Vyper to its custom LLVM-based zkEVM bytecode rather than proving over EVM bytecode. This enables significant prover optimizations but introduces subtle incompatibilities.

Key incompatibilities to know:
- msg.value in delegate calls behaves differently.
- Contract deployment involves a two-step process (bytecode is published separately).
- tx.origin and ecrecover have ZK-circuit-friendly implementations that differ from EVM semantics in edge cases.
- The address derivation formula for CREATE2 is different from Ethereum.

Native account abstraction: zkSync Era has native account abstraction at the protocol level. Every account is a smart account — there is no EOA vs contract distinction. This enables powerful UX but means standard Ethereum wallet libraries need zkSync-specific adapters.

Performance: zkSync's LLVM-based prover is one of the fastest in production. Proof generation for a batch is measured in seconds on high-end hardware. The zkSync team has consistently shipped prover optimizations that reduce costs.

Strengths: fastest proving, native AA, large ecosystem and TVL.
Limitations: address derivation difference requires careful frontend handling; CREATE2 factory contracts often need redeployment.

Scroll and Starknet

Scroll targets Type 2 equivalence with an emphasis on open-source, community-governed infrastructure. The proving architecture uses a combination of halo2 circuits compiled from EVM trace analysis. Scroll has been transparent about its proof generation pipeline and actively involves external researchers in prover optimization.

Scroll's key differentiator: it is the most decentralization-focused ZK rollup, with an early rollout of decentralized provers. Anyone can run a Scroll prover and earn fees. This aligns with Ethereum's values but currently results in slower average proving times than centralized alternatives.

Starknet takes a different approach: rather than proving EVM bytecode, it defines its own Cairo VM. Cairo is a Turing-complete language designed to be provable — every Cairo program is ZK-provable by design. Smart contracts are written in Cairo (or Rust via the Cairo backend).

Starknet's strengths: the most provable-by-design architecture, native ZK types and operations, the fastest theoretical proof generation because Cairo programs are written to be proving-friendly. Weaknesses: a completely different programming model from Solidity. Migration of existing EVM contracts requires rewriting in Cairo.

For developers who want maximum ZK capability and are willing to learn Cairo, Starknet is the frontier. For developers who want EVM compatibility, Scroll and Polygon zkEVM are the pragmatic choices.

Choosing the Right ZK-EVM for Your Project

The choice depends on your application profile:

Existing Solidity contracts with minimal modifications needed: Polygon zkEVM or Scroll. Both achieve near-bytecode-level EVM equivalence. Test your contracts on both testnets and check for incompatibilities before choosing.

New DeFi protocol wanting the best performance and native AA: zkSync Era. Accept the CREATE2 and AA differences; they are manageable with proper tooling. The ecosystem liquidity and native AA are worth the trade-off.

Research or privacy-focused application willing to write Cairo: Starknet. Cairo's native ZK types enable constructs that are impractical in EVM-based ZK systems.

Enterprise or compliance-sensitive application: all four chains have some form of KYC-gated pool support, but Polygon zkEVM's integration with Polygon's enterprise ecosystem is most mature.

Benchmark in 2026: run your contracts on Sepolia, then on each ZK-EVM testnet. Measure gas costs, identify incompatibilities, and test edge cases. Do not rely on theoretical equivalence claims — test empirically before committing.