Rollup Stack: The Full Architecture & Top Frameworks

In 2026, four rollup stacks dominate Ethereum's Layer 2 landscape: OP Stack, Arbitrum Orbit, ZK Stack, and Polygon CDK. Optimistic stacks still lead in TVL and developer adoption, while ZK-based stacks are gaining ground as proof generation costs fall and finality speed becomes a competitive advantage.

Today, anyone can launch a production-grade Layer 2 chain in a matter of days – something that once required months of engineering and millions of dollars. Behind that shift is a single architectural idea: the rollup stack.

What Is a Rollup Stack?

The term distinguishes between two things that are easy to conflate:

• A rollup is the Layer 2 chain itself – what users interact with.
• A rollup stack is the framework used to build and run that chain.

Ethereum's OP Mainnet, Coinbase's Base, and zkSync Era are all rollups. OP Stack, Arbitrum Orbit, and ZK Stack are the frameworks that power them.

Before standardized stacks existed, launching an L2 meant:

• forking protocol code,
• writing custom bridge contracts,
• building a sequencer from scratch,
• and maintaining everything indefinitely.

Rollup stacks replaced that with a reusable, audited, modular foundation, letting teams focus on the application layer rather than the infrastructure underneath it.

How a Rollup Stack Works: The Core Components

A rollup stack is not a single program but a collection of discrete modules, each responsible for one function. Understanding each component is the key to understanding why different stacks make different trade-offs.

Execution environment

The execution environment is where transactions are actually processed, where smart contracts run, and account states change.

Most stacks use an EVM-compatible environment, meaning Solidity contracts deploy with minimal or no modification. Some stacks, like Arbitrum's Nitro, go a step further and run a near-unmodified version of go-ethereum (Geth), achieving very high EVM equivalence. Others, like ZK Stack, implement a custom zkEVM that is compatible with Ethereum tooling but uses a different underlying circuit design.

The execution environment determines:

• Which programming languages and tools developers can use
• How closely the chain mirrors Ethereum's behaviour
• What modifications (if any) are needed to port existing contracts

Sequencer

The sequencer is the component that receives, orders, and batches user transactions before they are submitted to Layer 1.

It is the operational heartbeat of a rollup. A fast sequencer means low latency for users. A centralized sequencer (used by most major rollups today) is efficient but creates a single point of failure. If it goes offline, the chain stalls.

All major stacks currently default to a single-operator sequencer. Decentralized sequencer designs, using protocols like Espresso or Radius, are available as optional integrations but are not yet the standard in production deployments.

>> Learn more about Centralized vs Decentralized Sequencers

Proof system

The proof system is what makes a rollup trustless. It gives Layer 1 a way to verify that the transactions posted by the sequencer are actually valid.

There are two primary approaches - fraud proof vs validity proof:

The choice of proof system is one of the most consequential decisions in a rollup stack.

• Optimistic proofs are simpler to implement and maintain full EVM equivalence more easily.
• ZK proofs offer faster finality and stronger cryptographic guarantees, but come with higher prover infrastructure costs.

Data availability layer

The data availability (DA) layer ensures that all transaction data posted to a rollup is accessible, so that anyone can reconstruct the chain state and, if needed, challenge invalid transactions.

There are two main approaches:

• Onchain DA (Ethereum): Transaction data is posted directly to Ethereum as calldata or blobs. Most secure, but historically expensive. After EIP-4844 (the Dencun upgrade, March 2024), blob-based posting cut DA costs by roughly 80–90% for rollups.
• External DA: Data is posted to a separate network, Celestia, EigenDA, or Avail, at lower cost, but with different security assumptions. This is the basis for "validium" designs.

Most rollup stacks support both options, letting operators choose based on their cost-versus-security requirements.

Settlement layer

The settlement layer is the final arbiter of truth. It is the Layer 1 blockchain (most commonly Ethereum) where the rollup's state roots and proofs are posted and verified. For a closer look at how that verification process actually works, see Rollup Verification Layer 1: From Batches to Finality.

Settlement means two things in practice:

1. State finalization: A commitment to the current L2 state is recorded on-chain and becomes canonical.
2. Dispute resolution: If a fraud proof is submitted (optimistic rollups) or a validity proof fails (ZK rollups), the settlement layer resolves the outcome.

Some advanced designs allow L3 chains to settle on an L2 rather than directly on Ethereum. Arbitrum Orbit, for instance, supports both patterns.

Bridge

The bridge is the user-facing entry and exit point between Layer 1 and the rollup. It is a set of smart contracts that lock assets on the source chain and unlock (or mint) equivalent assets on the destination chain.

• For optimistic rollups, canonical withdrawals from L2 to L1 require waiting out the 7-day fraud-proof window. In practice, most users bypass this delay by using third-party fast bridges (like Across or Hop), which provide instant liquidity for a small fee.
• For ZK rollups, native withdrawals are faster, typically 15 to 45 minutes, because validity proofs allow L1 to confirm correctness as soon as the proof is verified.

The 4 Major Rollup Stacks Compared

The four dominant rollup stacks in 2026 are OP Stack, Arbitrum Orbit, ZK Stack, and Polygon CDK. Each reflects a distinct set of trade-offs around proof model, EVM compatibility, ecosystem design, and governance.

OP Stack

OP Stack is the open-source rollup framework maintained by OP Labs, the team behind Optimism. It is built around a modular architecture where each layer is a discrete module that can be swapped or upgraded without forking everything else.

Its defining strategic feature is the Superchain: a network of OP Stack chains (called OP Chains) that share security, upgrade governance, and a native cross-chain messaging layer.

As of early 2025, more than 40 production chains had adopted OP Stack, including Base (Coinbase's L2, with $14.5B+ in TVL as of mid-2025), Zora, Mode, Redstone, and Fraxtal.

OP Stack currently uses optimistic fraud proofs with a 7-day challenge window. OP Labs is developing a ZK proof backend using SP1 (a RISC-V ZK VM from Succinct Labs) under the OP Succinct project, which would reduce the withdrawal window to approximately 1 day. This is in testnet as of early 2025 and has not yet shipped to OP Mainnet or Base in production.

Best for: Teams that want the largest ecosystem of interoperable chains, proven tooling, and maximum open-source flexibility without licensing fees.

Arbitrum Orbit (Nitro Stack)

Arbitrum Orbit is Offchain Labs' framework for deploying customizable L2 and L3 chains. It runs on the Nitro execution stack, which compiles Geth to WASM for fraud-proof adjudication, achieving very high EVM equivalence and making it easy to port existing Ethereum contracts.

Two features distinguish Orbit from its peers:

• Stylus VM: Introduced in 2025, Stylus extends Arbitrum's execution environment to support WASM-compiled contracts written in Rust, C++, and other languages — opening the door to performance-critical contract architectures that Solidity cannot efficiently express.
• AnyTrust mode: Chains can opt into a Data Availability Committee (DAC) setup instead of posting data to Ethereum, significantly reducing DA costs for high-throughput applications.

Arbitrum One leads all L2s in TVL, holding approximately $12.4B as of May 2026, with some of the deepest DeFi liquidity across Aave v3, GMX, Pendle, and Camelot. Robinhood recently announced it is building its tokenized assets platform on Arbitrum Orbit.

One trade-off: Orbit chains that settle to Ethereum (rather than to Arbitrum One as an L3) are subject to a revenue-sharing arrangement with the Arbitrum Foundation, which adds a long-term cost consideration for commercial deployments.

Best for: Teams that need maximum EVM equivalence, flexibility at the DA layer, and access to deep DeFi liquidity and are comfortable with the licensing model.

ZK Stack (Matter Labs/zkSync)

ZK Stack is Matter Labs' framework for deploying ZK-powered chains using the same circuits that underpin zkSync Era. It is the only major stack that is ZK-native from the ground up, meaning every batch submitted to L1 is accompanied by a cryptographic validity proof.

Native withdrawals take 15 to 45 minutes (depending on proof batching frequency), compared to 7 days on optimistic stacks. For applications where capital velocity matters, particularly DeFi and cross-chain transfers, this is a meaningful advantage.

ZK Stack chains can operate in two modes:

• Sovereign: Self-contained finality, no shared liquidity.
• Connected (Elastic Chain): Share liquidity and ZK bridges with the broader zkSync network.

The primary challenge with ZK Stack is cost. Running a prover is computationally intensive and adds operational overhead that optimistic stacks avoid entirely. As of 2026, most ZK rollups, including those built on ZK Stack, still operate centralized provers run by the founding team.

Best for: Applications that require fast native finality, cryptographic security without a trust window, or privacy-preserving transaction designs.

Polygon CDK (Chain Development Kit)

Polygon CDK is Polygon Labs' modular toolkit for deploying ZK-powered chains. Like ZK Stack, it uses validity proofs, offering fast finality without a fraud-proof challenge window. Its defining architectural feature is the Agglayer – a shared validity-proof aggregation layer that allows CDK chains to interoperate natively without going through a bridge.

CDK supports multiple execution environments, including an OP Stack mode (optimistic execution with ZK security added at the proof layer) and an Erigon-based ZK mode, giving builders more flexibility to match their existing tooling.

Notably, Agglayer CDK does not impose a revenue-sharing model or licensing fee, positioning it as an alternative to OP Stack and Arbitrum Orbit for teams that want sovereignty without ecosystem lock-in.

Best for: Teams that prioritize native cross-chain interoperability, ZK security, and full economic autonomy from day one.

Rollup Stack vs Building a Rollup From Scratch

That said, the contrast is worth understanding clearly.

Before standardized stacks existed, launching an L2 required a team of protocol engineers, six to nine months of development, and infrastructure costs in the millions.

You needed to write the sequencer, deploy bridge contracts, configure a DA layer, build a fraud or validity proof system, run nodes, and maintain everything indefinitely. Only well-funded teams with deep protocol expertise could attempt it.

Rollup stacks changed the calculus entirely. The core trade-offs:

The modular nature of modern stacks means most customization needs can be met without forking the entire codebase. Teams can swap the DA layer, replace the sequencer, or integrate a custom execution environment while staying on audited, maintained infrastructure.

The only scenario where building from scratch makes sense is when a team has a fundamental architectural requirement that no existing stack supports. In practice, that bar is very high.

Rollup-as-a-Service (RaaS) takes this further still. Platforms like Conduit, Caldera, Gelato, AltLayer, and Ankr RaaS wrap rollup stacks into managed deployment products. Conduit, for instance, allows teams to deploy a production-grade L3 rollup for around $3,000/month on mainnet, handled through a web UI.

Rollup Stacks and the Modular Blockchain Thesis

The rise of rollup stacks is the direct expression of a broader architectural shift in blockchain design: from monolithic to modular.

A monolithic blockchain (Ethereum L1 pre-rollups, Solana) handles execution, data availability, consensus, and settlement in a single integrated system. This is simple, but creates a fundamental bottleneck: every node must process everything, capping the network's throughput.

A modular architecture separates those functions across specialized layers. A rollup stack is the practical implementation of this idea:

User Transaction

      ↓

Execution Layer     ← runs EVM, updates state

      ↓

Sequencer               ← orders and batches transactions

      ↓

DA Layer                  ← stores data (Ethereum blobs, Celestia, EigenDA)

      ↓

Proof System           ← fraud proof or validity proof

      ↓

Settlement Layer     ← L1 finalizes state (Ethereum)

The Dencun upgrade (EIP-4844, activated March 13, 2024) was a pivotal moment for modular rollup economics. By introducing blob-carrying transactions, a cheaper data lane specifically sized for rollup payloads, Dencun cut DA costs for rollups by roughly 80–90%.

Average user-facing fees across major L2s compressed to $0.001–$0.05, making L2 DeFi economically viable for retail-scale transactions for the first time.

This cost shift triggered a wave of new chain deployments and made external DA layers (Celestia, EigenDA, Avail) more attractive for teams that want even lower costs with different trust assumptions.

Fee revenue no longer flows by default to the base layer. It distributes across whichever modules a rollup uses, creating a new competitive landscape where DA providers, proof networks, and sequencer protocols each have their own economic model.

How to Choose a Rollup Stack for Your Project

The decision breaks down across five considerations.

1. Proof model: Optimistic or ZK?

• Choose Optimistic (OP Stack or Arbitrum Orbit) if developer velocity is the priority. Full EVM equivalence, mature tooling, and the largest installed bases of liquidity are all on the optimistic side.
• Choose ZK (ZK Stack or Polygon CDK) if your application requires fast native finality (DeFi with frequent L1 settlement, cross-chain payments) or cryptographic security without a trust window.

2. EVM compatibility requirements

All four major stacks offer high EVM compatibility, but the details vary. Arbitrum Orbit runs the closest to unmodified Geth. ZK-based stacks may require minor adjustments to some precompiles and gas accounting. If you're porting a complex, gas-optimized protocol from Ethereum mainnet, Arbitrum Orbit or OP Stack will produce the fewest surprises.

3. Ecosystem and interoperability

• Superchain (OP Stack): Native cross-chain messaging across 40+ chains; strong for apps that want to operate across multiple OP Chains.
• Arbitrum Orbit: Access to Arbitrum One's $12B+ DeFi liquidity pool; strong for applications where depth of existing markets matters.
• Elastic Chain (ZK Stack): Shared liquidity and ZK bridges for ZK-native interoperability.
• Agglayer (Polygon CDK): Cross-chain native with no licensing fees or revenue share.

4. Licensing and economic terms

• OP Stack: MIT license, no fees.
• ZK Stack: Open, no fees.
• Polygon CDK: Open, no fees.
• Arbitrum Orbit: Open-source, but chains settling to Ethereum (not to Arbitrum One) are subject to a revenue-sharing agreement with the Arbitrum Foundation.

5. Not ready to self-manage? Use RaaS.

If your team lacks the infrastructure expertise to run a sequencer, configure DA, and maintain a chain in production, Rollup-as-a-Service (RaaS) is the practical path. Conduit, Caldera, Gelato, AltLayer, and Ankr RaaS handle all of that, letting your team ship an app-specific chain without building rollup infrastructure from scratch.

Closing Perspective

The most interesting thing about the rollup stack landscape in 2026 is how quickly the differentiation has shifted from technology to ecosystem. Two years ago, the debate was about fraud proofs versus validity proofs, EVM equivalence percentages, and finality times. Those gaps still exist, but they have narrowed faster than most expected. ZK stacks now support full EVM tooling. Optimistic stacks are integrating ZK backends.

What has not closed is the liquidity and network-effect gap. Arbitrum One holds $12B+ in TVL. Base processes more daily transactions than any other L2. OP Stack powers 40+ production chains in the Superchain. Those numbers are a reflection of which ecosystems developers found first, stayed in, and built liquidity within.

For anyone choosing a rollup stack today, the technical question and the ecosystem question are equally important. A ZK stack with perfect cryptographic properties and no users is less useful in practice than an optimistic stack embedded in a network with deep DeFi markets. The real decision is which stack connects you to the users and capital you need.

— ByteByByte, CryptoThreads

Sources and Further Reading

• Ethereum.org – "Layer 2 Rollups" https://ethereum.org/en/layer-2/
• Ethereum.org – "EIP-4844: Shard Blob Transactions" https://eips.ethereum.org/EIPS/eip-4844
• Vitalik Buterin – "An Incomplete Guide to Rollups" https://vitalik.eth.limo/general/2021/01/05/rollup.html
• Vitalik Buterin – "A Rollup-Centric Ethereum Roadmap" https://ethereum-magicians.org/t/a-rollup-centric-ethereum-roadmap/4698
• OP Labs – "OP Stack Documentation" https://docs.optimism.io/stack/getting-started
• Offchain Labs – "Arbitrum Orbit: Introduction" https://docs.arbitrum.io/launch-orbit-chain/orbit-gentle-introduction
• Matter Labs – "ZK Stack Documentation" https://docs.zksync.io/zk-stack
• Polygon Labs – "Polygon CDK Documentation" https://docs.polygon.technology/cdk/