Tools/Explorers

ZK Proof Systems Compared: SNARKs vs STARKs vs Bulletproofs

Compare ZK proof systems by proof size, verification time, trusted setup requirements, and blockchain applications. Covers Groth16, PLONK, Halo2, STARKs, Bulletproofs, and Nova.

Spark Team

Zero-Knowledge Proof Systems at a Glance

Zero-knowledge proof systems let one party (the prover) convince another party (the verifier) that a statement is true without revealing any information beyond the validity of the statement itself. Different zero-knowledge proof systems make fundamentally different tradeoffs across proof size, verification speed, prover cost, setup requirements, and cryptographic assumptions. Choosing the right system depends on your application: on-chain verification favors small proofs, privacy protocols prioritize no trusted setup, and rollups need fast recursive proving.

The table below summarizes the most widely deployed proof systems. All figures are approximate and reflect typical implementations rather than theoretical limits, since performance varies significantly by circuit design, field choice, and hardware.

Proof SystemFamilyProof SizeVerificationTrusted SetupQuantum Resistant
Groth16zk-SNARK~128–200 bytes~O(1), fastestYes (per-circuit)No
PLONKzk-SNARK~400–800 bytesO(1), fastYes (universal)No
Halo2zk-SNARK~9 KB (IPA) / ~4 KB (KZG)O(1), moderateNo (IPA) / Yes (KZG)No
zk-STARKSTARK~40–200 KBO(poly-log n)NoYes
BulletproofsBulletproofs~1–1.5 KB (log n)O(n), linearNoNo
Plonky2/3STARK + PLONK hybrid~50–100 KB (before wrap)O(poly-log n)NoYes (FRI layer)
NovaFolding / IVC~11 KB (compressed)O(1) per stepNo (IPA) / Yes (KZG)No

Groth16: The Compact Workhorse

Groth16, published by Jens Groth in 2016, remains the most widely deployed SNARK in production. Its proofs consist of just three elliptic curve group elements (roughly 128–200 bytes depending on the curve), making it the smallest proof system in common use. Verification requires a constant number of pairing operations regardless of circuit size, which translates to low gas costs for on-chain verification on Ethereum.

The tradeoff is a circuit-specific trusted setup ceremony. Every time the circuit changes, a new multi-party computation ceremony must be run to generate proving and verification keys. If all participants in the ceremony collude or their secret randomness ("toxic waste") is recovered, an attacker could forge proofs. Zcash ran the most prominent Groth16 ceremony (Powers of Tau) with hundreds of participants to mitigate this risk.

Groth16 is used by Zcash (Sapling shielded pool), Filecoin (storage proofs), Tornado Cash, and Semaphore. Many modern systems also use Groth16 as a final "wrapper": they generate a large STARK proof internally and compress it into a Groth16 proof for cheap on-chain verification.

PLONK: Universal Setup

PLONK (Permutations over Lagrange-bases for Oecumenical Noninteractive arguments of Knowledge), published in 2019, introduced a universal and updatable structured reference string. Unlike Groth16, a single PLONK ceremony can serve any circuit up to a given size bound, and the parameters can be extended later without starting from scratch. This eliminates the need for per-circuit ceremonies.

PLONK proofs are roughly 2–3x larger than Groth16 (approximately 400–800 bytes) and verification is slightly slower, though still constant-time. The prover is also slower: benchmarks show the PLONK prover in snarkjs running roughly 13–17x slower than the equivalent Groth16 prover. In practice, optimized PLONK implementations (such as gnark or Barretenberg) close much of this gap.

PLONK's "PLONKish" arithmetization has become the foundation for a family of related systems. Halo2, Kimchi (used by Mina), and Barretenberg (used by Aztec's Noir language) all build on PLONKish constraint systems with custom gates and lookup arguments that extend the original PLONK design.

Halo2: Eliminating the Ceremony

Halo2, developed by the Electric Coin Company for Zcash, combines PLONKish arithmetization with a polynomial commitment scheme that can operate without a trusted setup. In its original form, Halo2 uses Inner Product Arguments (IPA) over the Pallas/Vesta curve cycle, requiring no ceremony at all. The Ethereum Foundation's Privacy and Scaling Explorations (PSE) team forked Halo2 and swapped in KZG commitments, reintroducing a universal trusted setup but achieving smaller proofs (~4 KB vs ~9 KB with IPA).

Zcash activated Halo2 for its Orchard shielded pool in the NU5 upgrade (2022), making Zcash the first major blockchain to ship a proof system with no trusted setup for its privacy protocol. Scroll, an Ethereum ZK rollup, uses the KZG variant of Halo2 for its zkEVM prover.

zk-STARKs: Transparent and Quantum-Resistant

STARKs (Scalable Transparent Arguments of Knowledge), developed by Eli Ben-Sasson and colleagues at StarkWare, take a fundamentally different approach. They rely solely on hash functions and algebraic coding theory (specifically FRI, the Fast Reed-Solomon Interactive Oracle Proof), avoiding elliptic curve pairings entirely. This gives STARKs two major advantages: no trusted setup (transparency) and plausible resistance to quantum computers, since hash functions are not broken by Shor's algorithm the way elliptic curve discrete logarithms are.

The tradeoff is proof size. STARK proofs range from roughly 40 KB to 200 KB depending on the circuit and security parameters, orders of magnitude larger than SNARK proofs. Verification time scales polylogarithmically with the computation size, which is fast but not constant. For on-chain verification on Ethereum, the gas cost of verifying a raw STARK is prohibitively high, which is why production systems like StarkNet and StarkEx wrap their STARK proofs inside a SNARK (typically Groth16 or PLONK) through recursive proof composition.

StarkNet uses Cairo, a purpose-built language that compiles to an algebraic execution trace optimized for STARK proving. StarkEx powers dYdX (v3), Immutable X, and Sorare. The STARK-then-SNARK-wrap pattern has become the dominant architecture for ZK rollups that want both STARK-scale prover performance and SNARK-scale verification costs.

Bulletproofs: Compact Range Proofs

Bulletproofs, introduced by Bünz, Bootle, Boneh, Poelstra, Wuille, and Maxwell in 2017, produce short proofs without a trusted setup. Proof size scales logarithmically with the statement size, typically landing around 1–1.5 KB for the range proofs used in confidential transactions. This makes them well-suited for proving that a transaction amount falls within a valid range without revealing the amount.

The critical limitation is verification time: Bulletproof verification is linear in the size of the statement, O(n). This makes them impractical for large computations or on-chain batch verification where thousands of proofs must be checked. Bulletproofs also rely on the discrete logarithm problem, making them vulnerable to quantum attacks.

Monero adopted Bulletproofs in October 2018 and upgraded to Bulletproofs+ in 2022, reducing proof size and verification time by roughly 6% and 6% respectively. Grin and Beam (MimbleWimble implementations) also use Bulletproofs for confidential transactions.

Newer Systems: Plonky2/3, Nova, and zkVMs

Plonky2 and Plonky3

Plonky2 (Polygon) and Plonky3 (Succinct) combine PLONK-style arithmetization with FRI-based polynomial commitments, creating a hybrid that inherits STARK transparency (no trusted setup) with the flexibility of PLONKish custom gates. They operate over small fields (Goldilocks for Plonky2, BabyBear for Plonky3) for fast native arithmetic, then recursively aggregate proofs and wrap the final result into a Groth16 or PLONK proof over BN254 for Ethereum verification.

SP1, Succinct's zkVM built on Plonky3, proves arbitrary RISC-V programs. The prover splits the execution trace into chunks, proves them in parallel, and recursively aggregates the results. RISC Zero follows a similar architecture: STARK-based proving of RISC-V execution with a Groth16 wrapper for on-chain settlement.

Nova and Folding Schemes

Nova, introduced by Abhiram Kothapalli, Srinath Setty, and Ioanna Tzialla in 2022, takes a fundamentally different approach through folding schemes. Rather than producing a proof at each step and recursively verifying it, Nova "folds" two relaxed R1CS instances into one, deferring the expensive proof generation until the end. This makes the per-step prover cost independent of the total number of steps, which is dramatically cheaper for iterative computations like VM execution or state transitions.

A compressed Nova proof is roughly 11 KB. Follow-on work includes SuperNova (supports multiple circuit types within a single IVC chain), HyperNova (folding for CCS, a generalization of R1CS), and ProtoStar (folding for PLONKish constraints). These systems are mostly in the research and prototype stage but represent the frontier of ZK proof design.

Which Blockchains Use Which Proof System

Production blockchains and L2s have converged on a small number of proof systems, with many using hybrid architectures that combine a fast prover backend with a compact verification wrapper.

Blockchain / L2Proof SystemSetupNotes
Zcash (Sapling)Groth16Per-circuitPowers of Tau ceremony
Zcash (Orchard)Halo2 (IPA)NoneNo trusted setup since NU5
StarkNetSTARK (Cairo)NoneSTARK proofs wrapped in SNARK for L1
StarkEx (dYdX v3)STARKNoneApplication-specific STARK circuits
ScrollHalo2 (KZG)UniversalEVM-equivalent zkEVM
zkSync EraBoojum (custom SNARK)None (FRI)Plonk + FRI hybrid
Polygon zkEVMCustom SNARK proverVariesMigrated to CDK framework
LineaCustom SNARK (Vortex)VariesConsenSys Type 2 zkEVM
MinaKimchi (PLONK variant)UniversalSuccinct blockchain (~22 KB state proof)
MoneroBulletproofs+NoneConfidential transaction amounts
FilecoinGroth16Per-circuitProof-of-replication and proof-of-spacetime
SP1 (Succinct)Plonky3 + Groth16 wrapHybridRISC-V zkVM, BabyBear field
RISC ZeroSTARK + Groth16 wrapHybridRISC-V zkVM
Citrea (Bitcoin)STARK (RISC Zero) + BitVMHybridZK rollup on Bitcoin via BitVM

ZK Proofs on Bitcoin

Bitcoin's scripting language lacks the opcodes needed to directly verify ZK proofs on-chain. This creates a unique challenge for bringing validity proofs and ZK rollups to the Bitcoin ecosystem. Two primary approaches have emerged.

BitVM: Optimistic ZK Verification

BitVM enables Turing-complete computation on Bitcoin without a soft fork by using an optimistic challenge-response protocol. A prover posts a claim (such as "this SNARK proof verifies correctly") along with a bond. If no one disputes the claim within a challenge period, it is accepted. If a verifier disputes it, a bisection protocol plays out on-chain until the disagreement is narrowed to a single step that Bitcoin Script can evaluate. The dishonest party forfeits their bond.

In practice, BitVM runs a Groth16 verifier circuit decomposed into Bitcoin Script fragments. Citrea, which launched on Bitcoin mainnet in early 2026, uses this approach: it generates STARK proofs of execution via RISC Zero, wraps them into Groth16 SNARKs, and settles on Bitcoin through BitVM's challenge mechanism. For a deeper comparison of Bitcoin L2 architectures, see the Bitcoin rollup comparison tool.

OP_CAT and Native Verification

A more direct path would be re-enabling OP_CAT, a Bitcoin opcode that was disabled early in Bitcoin's history. OP_CAT would allow concatenating stack elements, enabling on-chain construction of Merkle proofs and, by extension, direct STARK verification in Bitcoin Script. This approach has been demonstrated on Bitcoin Signet but requires a soft fork for mainnet activation, which remains a subject of community debate.

The practical implication for builders: ZK rollups on Bitcoin currently operate through optimistic verification (BitVM) rather than native validity proofs. This introduces a challenge period (typically days) before finality, unlike Ethereum's ZK rollups where SNARK verification is a single smart contract call. Spark takes a different approach to Bitcoin scaling, using a shared UTXO model with cooperative signing rather than ZK proofs, achieving instant finality without waiting for on-chain proof verification.

Choosing a Proof System

The right proof system depends on what you are optimizing for. Here is a practical decision framework:

Minimize on-chain verification cost:

  • Groth16 produces the smallest proofs and cheapest verification, ideal when gas cost dominates
  • Accept the per-circuit trusted setup or use Groth16 as a final wrapper around a STARK

Avoid trusted setup entirely:

  • STARKs require no setup and are quantum-resistant, at the cost of larger proofs
  • Halo2 with IPA commitments eliminates the ceremony while staying in the SNARK family
  • Bulletproofs work well for small range proofs but are too slow for large circuits

Prove general-purpose computation (zkVM):

  • SP1 (Plonky3) and RISC Zero (STARK) let you write proofs in Rust against a RISC-V target
  • Both wrap their final proof in Groth16 for cheap Ethereum settlement

Prove iterative or repeated computation (IVC):

  • Nova and its successors (SuperNova, HyperNova) fold computation steps cheaply
  • Best for VM execution traces, recursive state transitions, and long-running programs

For further reading on how these proof systems fit into rollup architectures, see our research on zero-knowledge proofs for Bitcoin applications and the rollup vs state channel scaling tradeoffs analysis.

Frequently Asked Questions

Do STARKs make SNARKs obsolete?

No. STARKs offer transparency and quantum resistance, but their proofs are 200–1000x larger than Groth16 proofs. For on-chain verification where every byte costs gas, SNARKs remain the standard for final settlement. The dominant pattern in production is to use STARKs for proving (leveraging their fast prover and no-setup properties) and wrap the result in a SNARK for verification. STARKs and SNARKs are complementary, not competing.

Can ZK proofs work on Bitcoin without a soft fork?

Yes, through optimistic verification via BitVM. BitVM decomposes a SNARK verifier into Bitcoin Script fragments and uses a challenge-response protocol to verify correctness. If no one challenges the proof, it is accepted. If challenged, the dispute is resolved on-chain through bisection. Citrea uses this approach for its Bitcoin ZK rollup. The tradeoff is that settlement requires a challenge period rather than instant on-chain verification, and the trust model assumes at least one honest verifier will challenge invalid proofs.

What is the difference between a trusted setup and no trusted setup?

A trusted setup is a one-time ceremony that generates cryptographic parameters needed for proving and verification. If the secret randomness from the ceremony is compromised, an attacker could forge proofs. Groth16 requires a new ceremony for each circuit. PLONK uses a universal ceremony that works for any circuit up to a size bound. STARKs, Bulletproofs, and Halo2 (with IPA commitments) require no trusted setup at all, deriving their security solely from hash functions or standard cryptographic assumptions.

Which ZK proof system is quantum resistant?

Only STARKs are considered quantum-resistant among production proof systems. STARKs rely on collision-resistant hash functions, which are not efficiently broken by known quantum algorithms. SNARKs (Groth16, PLONK, Halo2) and Bulletproofs rely on the elliptic curve discrete logarithm problem or pairing assumptions, both of which Shor's algorithm can break on a sufficiently powerful quantum computer. Research into lattice-based and hash-based SNARKs is active but not yet production-ready.

What is a folding scheme and how does Nova differ from SNARKs?

A folding scheme compresses two instances of a relation into a single instance without producing a full proof at each step. Nova uses this technique for incremental verifiable computation (IVC): instead of recursively verifying a SNARK proof inside each step (which is expensive), the prover folds the current step's witness into a running accumulator. The full proof is generated only once at the end. This makes the per-step cost nearly constant regardless of how many steps have been executed, which is ideal for proving long-running computations like VM execution.

Why do most ZK rollups wrap STARKs inside SNARKs?

STARK proofs are large (40–200 KB), and posting them to Ethereum L1 would cost significant gas. By recursively verifying the STARK inside a SNARK circuit and posting only the small SNARK proof (~128–800 bytes) on-chain, rollups get the best of both worlds: STARK transparency and prover speed during execution, plus SNARK compactness for settlement. This STARK-then-SNARK pattern is used by StarkNet, SP1, RISC Zero, and Citrea.

What proof system does Ethereum use for ZK rollups?

Ethereum itself does not mandate a specific proof system. Each ZK rollup chooses its own. Scroll uses Halo2 (KZG), zkSync Era uses Boojum (a custom Plonk + FRI hybrid), StarkNet uses STARKs with a SNARK wrapper, and Linea uses a custom SNARK prover called Vortex. The Ethereum protocol verifies whichever proof the rollup's on-chain verifier contract accepts, typically a Groth16 or PLONK proof over the BN254 curve because Ethereum has precompiled contracts for BN254 pairing operations (EIP-196 and EIP-197).

This tool is for informational purposes only and does not constitute financial or technical advice. Performance figures are approximate, vary by implementation and hardware, and reflect publicly available benchmarks and documentation. Proof systems are an active area of research: always consult project documentation and academic papers for the latest specifications before making architectural decisions.

Build with Spark

Integrate bitcoin, Lightning, and stablecoins into your app with a few lines of code.

Read the docs →