Skip to main content

This site is for educational purposes only. Nothing here constitutes financial advice.

Topic 45 of 189

zk-SNARK vs zk-STARK vs PLONK

How the three major proof-system families compare on trusted setup, proof size, prover cost, and quantum resistance — and which production rollups picked which.

Beginner
8 min readUpdated November 2026Block Clarity Hub Editorial Team

The basics

What All Three Are Trying to Do

A zero-knowledge proof lets you prove you know something (a witness) without revealing it. Modern proof systems do something even more useful: they let you prove that a long computation (millions of steps) was performed correctly, by producing a tiny proof that anyone can verify quickly. This is what powers ZK rollups — a prover compresses thousands of L2 transactions into a single proof, posted to L1, that lets Ethereum verify the whole batch in milliseconds. The three major families are SNARK, STARK, and PLONK (and PLONK's many descendants).

The Three In One Sentence Each

SNARK (Succinct Non-interactive ARgument of Knowledge): tiny proofs, fast verification, but requires a one-time 'trusted setup' ceremony (Zcash, original Filecoin). STARK (Scalable Transparent ARgument of Knowledge): no trusted setup, post-quantum secure, but proofs are larger (StarkNet, Miden). PLONK: universal trusted setup that can be reused across circuits, hybrid properties (Aztec, zkSync).

  • SNARK pioneers (Zcash Sapling, Filecoin): small proofs, requires per-circuit trusted setup (Groth16)
  • STARK (StarkNet): transparent, post-quantum-secure, larger proofs
  • PLONK family (Aztec, zkSync; Polygon zkEVM until its July 2026 sunset): reusable setup, flexible
  • All three solve 'prove the long computation was correct, with tiny proof' — they trade off how

Key Takeaways

  • Three families: SNARK (small + trusted setup), STARK (transparent + bigger), PLONK (universal setup)
  • All three let you compress a long verifiable computation into a small proof
  • Production ZK rollups use all three — there's no single winner
  • Choice depends on your priorities: proof size vs. setup vs. quantum resistance

Going deeper

Trusted Setup — What's Actually Trusted

A SNARK's setup ceremony generates a 'common reference string' that proofs reference. If everyone who participated in the ceremony was honest (or if at least one was), the system is sound. If everyone colluded, they could generate fake proofs. The original Zcash ceremony had 6 participants in 2016; the Ethereum KZG ceremony for EIP-4844 had over 140,000 contributions in 2023 — a one-honest-participant assumption that is very easy to satisfy. PLONK's setup is universal (works for any circuit) rather than per-circuit, which dramatically reduces ceremony burden as more circuits get deployed.

Proof Size and Verifier Cost

Rough order of magnitude on current production systems. Groth16 (an early SNARK family): ~200 bytes proof, ~10 ms verify. PLONK: ~500 bytes proof, ~20 ms verify. STARK: ~50-200 KB proof, ~30 ms verify. STARK proofs are 100-1000x larger, which matters because the prover posts them on-chain — bigger proofs mean more L1 gas. STARK proponents argue it's a worthwhile tradeoff for the no-trusted-setup property; SNARK proponents argue the ceremony cost is one-time and proof size is recurring.

Prover Cost — Where the Money Burns

Generating a proof is computationally expensive. Provers run on GPU farms or specialised hardware. STARKs are typically faster to prove than SNARKs for the same circuit (fewer expensive cryptographic operations). This is one of StarkNet's argued advantages — faster prover means cheaper sequencer operations, which can pass through to lower user fees. PLONK variants (e.g., HyperPlonk, plonky2) have closed the gap and in some cases overtaken STARKs in prover speed.

Post-Quantum: Where STARKs Shine

STARKs use only hash functions and information-theoretic primitives — no elliptic curves or pairings. This makes them naturally post-quantum secure. If quantum computers eventually break elliptic-curve cryptography, every SNARK and PLONK system in production becomes vulnerable; STARKs continue working with at most parameter updates. This is a meaningful long-horizon consideration in choosing the proof system for long-lived infrastructure.

Key Takeaways

  • Trusted setup requires at least one honest participant; the KZG ceremony's 140,000+ contributions made this easy to satisfy
  • Proof sizes: Groth16 ~200B, PLONK ~500B, STARK ~50-200KB — STARK trades size for transparency
  • Prover cost is competitive across all three families; benchmarks change rapidly with new schemes
  • STARKs are post-quantum secure by construction; SNARKs and PLONK rely on quantum-vulnerable assumptions

Under the hood

PLONK's Universal Setup and the Descendant Zoo

PLONK introduced a universal updatable setup: you do the ceremony once for a given circuit size, and any circuit fitting in that size can use it without per-circuit ceremonies. This was a huge usability improvement and triggered a cascade of derivative schemes: TurboPlonk (faster), UltraPlonk (custom gates), HyperPlonk (multilinear, better at large circuits), plonky2 (Goldilocks field + FRI commitments — faster prover, larger proofs). Each tradeoff finds different applications; the 'PLONK family' is now broader than the SNARK or STARK families.

Folding Schemes — The Next Generation

Nova (2021) and HyperNova (2023), co-authored by Microsoft Research's Srinath Setty, introduced 'folding': instead of computing a proof for a long computation directly, fold each step into a running accumulator and only prove the final state. This reduces prover memory dramatically and enables incrementally verifiable computation. Folding-based provers are an active research frontier.

Field Choice and Hardware Acceleration

Proof systems work over a specific finite field. BN254 (early Ethereum SNARKs) and BLS12-381 (Ethereum consensus, Zcash Sapling) are the legacy choices. Newer systems use smaller fields like the Goldilocks field (used by plonky2) that fit in 64-bit registers, making provers dramatically faster on commodity CPUs. The field choice cascades into hardware acceleration potential — dedicated proving hardware and GPU acceleration libraries are emerging (for example Ingonyama's ICICLE).

Production Mappings

What current production systems use: zkSync Era (Boojum, a Plonk-variant arithmetization over a roughly 64-bit field; ZKsync's separate Airbender RISC-V prover, the proving system for ZKsync OS, is built on STARK/FRI); StarkNet (STARK end-to-end with Cairo); Scroll (OpenVM zkVM prover); Aztec (PLONK family, Barretenberg prover); Aleo (Varuna SNARK); Filecoin (Groth16); Zcash (Halo2 for Orchard since NU5 in May 2022, Groth16 for Sapling). Polygon zkEVM, which used PLONK descendants, was sunset in July 2026. Most production rollups use hybrid schemes — proving in one system, verifying in another that's cheaper on-chain. The clean SNARK-vs-STARK distinction blurs in practice.

You Don't Need to Pick — Watch Aggregation

An emerging pattern: proofs from different systems get aggregated together into a single L1-verifiable proof (e.g., recursive aggregation across many rollups, posted to Ethereum). This makes the underlying proof-system choice less load-bearing for downstream users — what matters is total verification cost on L1, not which family generated the first proof. Watch aggregation layers (Polygon's Agglayer, ZKsync Chains) for where this is going.

Key Takeaways

  • PLONK's universal setup spawned a wide family (Plonky2, HyperPlonk, etc.) with diverse tradeoffs
  • Folding (Nova/HyperNova) is the emerging frontier — incrementally verifiable computation
  • Smaller fields (Goldilocks) make provers faster on commodity hardware
  • Production systems are hybrid: prove in one scheme, verify cheaply in another
  • Aggregation layers may make the per-rollup proof-system choice less load-bearing over time

Related Content

Data Availability Sampling

How light nodes can be cryptographically confident that a block's full data was published — without downloading it — and why this is the key unlock for Ethereum's full danksharding and the modular blockchain stack.

Finality and Fork Handling

What it means for a transaction to be 'final,' why different chains finalise differently, how reorgs happen, and the MEV incentives that complicate the picture.

State Pruning and Expiry

Why Ethereum's node storage needs have grown to terabytes, what 'archive,' 'full,' and 'light' nodes actually store, and how proposals like EIP-4444 and new state-tree designs (verkle or binary) aim to keep node hardware accessible for years to come.

ECDSA vs EdDSA vs BLS

The three signature schemes you'll meet across the crypto stack — what each does well, what tradeoffs they impose, and why Ethereum uses three of them simultaneously.

Threshold Signatures and MPC

How t-of-n threshold signatures and multi-party computation let multiple parties sign together without any one holding the full key — the cryptography behind Fireblocks and modern institutional custody.

Verifiable Random Functions

How VRFs produce randomness that's both unpredictable before commitment and cryptographically verifiable after — enabling fair lotteries, leader election, and on-chain randomness without trusted parties.

Hash Functions Compared

SHA-256, Keccak-256, Blake3, and Poseidon — which one each chain uses, why ZK systems needed a new family of 'arithmetic-friendly' hashes, and what tradeoffs each makes.

Stealth Addresses and Confidential Transactions

Privacy primitives that hide who's receiving what — from Monero's foundational stealth addresses to Ethereum's ERC-5564 and the legal context post-Tornado-Cash.

References & further reading