The rollup-centric roadmap was a strategic decision by the Ethereum community to scale the network faster while preserving its core principles of decentralization and security. The ultimate goal is still the same: to create a scalable Ethereum that can support the entire world. However, achieving this required solving two distinct scaling challenges, execution and data availability (DA), I'll explain both in detail later. Progress on DA was moving much faster than execution. Recognizing this, the community realized that Layer 2 solutions, which operate independently from Ethereum's core protocol, could leverage the advancements made in DA and still tap into Ethereum for security. This approach allowed companies to develop L2 solutions, raise significant funding, and accelerate progress on the execution scaling challenge.

Eventually, these efforts will converge, enabling Ethereum to implement a comprehensive solution: a scalable Layer 1 and a network of blockchains that also benefit from Ethereum’s security. Just as the entire internet doesn’t run on one server, the entire internet of value won’t run on a single blockchain. In the end game, we’ll have a diverse ecosystem of blockchains, all enjoying the security of Ethereum’s L1.

L2s are an integral part of this strategy, and they are Ethereum when they use Ethereum for DA, are derived from Ethereum L1, meaning they build their chain and validate their state transitions based on data from Ethereum’s L1 blockchain, and when their critical verification processes, like fraud proofs and SNARK/STARK verifications, play out on Ethereum L1. However, that doesn’t mean they’ll always be tied to Ethereum. While it’s theoretically possible for L2s to switch DA providers or move critical functions to another chain, doing so would be incredibly complex, disruptive, and unlikely, especially as these rollups become more deeply integrated with Ethereum over time. For now, L2s that rely on Ethereum for DA, derive their state from Ethereum L1, and use Ethereum for these critical verification processes are very much a part of Ethereum.

In order to understand why I believe the rollup-centric roadmap was a no-brainer decision and why L2s are Ethereum, we need to explore the historical context that led to this decision and examine how closely tied L2s are to Ethereum. That’s what I’ll be covering in the rest of this post.

Ethereum’s Vision and the Challenge of Scaling

When Ethereum launched, it had the ambitious goal of creating public good infrastructure where anyone could run a computer in their home, verifying every transfer of digital value on the planet cheaply. The Ethereum Community refuses to give up on the principle that everyone should be able to verify every transfer. This is the cypherpunk nature of Ethereum. If people can’t run a node and verify their transactions, trusting someone else instead, it’s a failure. In this regard, Ethereum and Bitcoin share a common goal.

This approach works on a small scale, but scaling it has always been a challenge. Bitcoin essentially gave up on this by becoming a store of value, which I don’t say to criticize—it still adds immense value to the world. But Ethereum believes that scaling while maintaining decentralization is possible and has been working toward that goal. From day one, Ethereum has aimed to be a decentralized platform accessible to the world, and unlike a store of value, achieving this ambitious goal requires effective scaling.

The Dual Challenge: Execution and DA

In 2015, Ethereum realized that scaling the system required solving two distinct problems: scaling the ability to execute transactions (going from state N to state N+1) and scaling the ability for computers to download any specific transaction and know with certainty that no transactions are missing (DA). Each is a different challenge. At that time, Ethereum was handling around 15 transactions per second (TPS), while Visa was processing an average of 1,700 TPS, with the capability to handle up to 24,000 TPS. To surpass Visa in performance, Ethereum needed to solve both challenges.

In its early years, Ethereum explored scaling execution through a method known as sharding, which involved creating multiple copies of the EVM that would communicate with each other. However, this approach ultimately led to a dead end. Ethereum recognized that the true solution to scaling execution lies in advanced cryptography, which initially seemed a distant goal. Yet, what once appeared far-fetched is gradually becoming a reality. Cryptographic proofs like SNARKs and STARKs, which enable the verification of computations with certainty, are at the core of this breakthrough. Although early implementations were slow and prone to bugs, the potential of these technologies is enormous. If these proofs can be generated quickly and reliably, they would solve the execution scaling problem. However, their readiness for Mainnet deployment remains uncertain, as they must be 100% secure, a milestone that has yet to be fully achieved.

Ethereum has significantly impacted research in this area. In its early years, Ethereum sparked renewed interest in making these proofs faster and more reliable. But while progress has been made, at this point it is still years, maybe decades, away from being ready. Let’s put a pin in this story and shift focus to scaling DA.

By 2017, efforts to scale DA were gaining significant momentum. The challenge was to handle large blocks of data—larger than any single node could practically download—while still allowing even small, resource-limited computers to know all the transactions are available to be downloaded and nothing is missing. DA is crucial because if any part of the data is missing, it could compromise the system entirely. For instance, if a transaction that prints 1000 ETH is missing, the state transition might be incorrect, leading to catastrophic outcomes. 

Even if the network can't process an invalid state transition because they include a cryptographic proof, it's still essential that all transactions are available so that nodes maintaining the state can update their records accurately. This also ensures that nodes have access to any specific transactions they might need, such as for tracking their own state data. Every node downloads the entire block of data, which typically ranges from around 20 KB to 80 KB depending on network activity. However, as block sizes increase, this becomes impractical for many nodes, especially those with limited resources.

To address this, researchers focused on how to ensure that even if a node only downloads a small portion of the data, it can still verify the block’s integrity and ensure that nothing is missing. The solution that emerged is known as data availability sampling (DAS). DAS allows nodes to verify large datasets by only sampling a small portion of the data. If the sample passes verification, it’s statistically highly likely that the entire dataset is intact. However, if any part of the data is missing, nodes that sample that specific part can raise an alarm, signaling to the rest of the network that something is wrong.

This approach is not only efficient but also extremely scalable. Individually, it’s not resource-intensive for nodes since they only need to download a small portion of the data. However, when many nodes participate in sampling, they can collectively cover a vast amount of data, allowing the block size to grow in proportion to the number of nodes. This means that as the network scales with more nodes, the block size can increase accordingly, while the network can still statistically ensure that all the data is available and intact, further enhancing the system’s capacity. Major breakthroughs in this area were made in 2017, culminating in the publication of a pivotal paper in 2018, which detailed the mechanics of DAS (see the paper here). 

To grasp the concept, Vitalik offers a helpful analogy: Imagine you're an orange farmer with 5,000 oranges. Instead of checking each one, you randomly pick 25. If all 25 are ripe, it’s likely the whole batch is ripe. Now, imagine you use a special pesticide (in reality this is polynomial jedi magic) that ensures the entire harvest is ripe if at least 50% are ripe. After picking 25 random oranges and finding them all ripe, you can start to build confidence that a large portion of the harvest is ripe. If your goal is to ensure at least 50% are ripe, the more random oranges you find that are ripe, the higher your confidence grows, eventually reaching near certainty (99.99%) that at least half of the harvest is ripe. This is similar to how DAS will work in Ethereum.

Looking forward, Ethereum's endgame solution to the DA side of the scaling problem involves DAS within a framework known as Danksharding. While Ethereum blocks previously reached up to 80KG, this solution could allow blocks to grow up to 32MB. Thanks to DAS and some polynomial jedi magic that’s beyond the scope of this post—nodes will be able to verify with 99.99% certainty that no transaction data is missing. This is over a 400x improvement.

Why A Rollup-Centric Roadmap?

Fast forward to 2019: scaling DA was progressing faster than scaling execution. Ethereum recognized that by prioritizing the scaling of DA on its Mainnet, it could provide immediate benefits to the ecosystem. L2s solutions could start leveraging this improved DA to achieve scalability now, while still ensuring that no invalid state transitions could occur. This strategic move allowed Ethereum to maintain its core principles of decentralization and security while enabling L2s to offload execution tasks. At the same time, the emergence of a robust L2 ecosystem provided a unique opportunity to accelerate progress in scaling execution. By creating a thriving L2 environment, Ethereum opened the door for these projects to attract significant investment and resources. 

L2 projects like ZKsync, Polygon, StarkNet, ZKsync, Optimism, and Arbitrum were able to raise substantial amounts of capital—$458M, $451M, $261M, $178M, and $124M, respectively. This influx of funding allowed these projects to push the boundaries of cryptographic proof technologies like SNARKs and STARKs, as well as other aspects of execution scaling. With access to millions of dollars in funding, these L2 projects could build dedicated teams of top-tier cryptographers and engineers, focusing on making SNARK and STARK technology faster, more reliable, and more scalable, while also advancing execution scaling in other innovative ways. This level of concentrated effort and financial backing was something that the Ethereum Foundation and academic researchers, despite their early contributions, could not have matched on their own.

The rapid development driven by these L2 companies resulted in significant breakthroughs. Proof generation times decreased, bugs were ironed out, and the overall reliability of cryptographic proofs improved dramatically. What might have taken decades under the slower pace of academic research was being achieved in a fraction of the time. The competitive and well-funded L2 ecosystem created an environment where innovation thrived, directly contributing to the acceleration of execution scaling.

By scaling DA on the mainnet, Ethereum not only supports current L2s but also speeds up the development of execution scaling. Eventually, these zkEVM rollups will develop a robust zkEVM (using SNARKs) that can be integrated into Ethereum, enabling true in protocol execution shards and realizing Ethereum’s full scalability potential, when combined with the final version of DAS (Danksharding). For more on the end state of Ethereum execution scaling, Justin Drake’s comment on a reddit AMA provides a great overview: link. In the meantime, L2s serve as out of protocol execution shards.

You can think about the rollup-centric roadmap as a form of decentralizing the R&D needed to scale Ethereum. Initially, the Ethereum Foundation and academic researchers, both with limited resources, were the primary drivers of scaling efforts. However, by embracing the rollup-centric roadmap, Ethereum effectively roped in private companies that could raise millions from venture capitalists to accelerate progress. This influx of funding and talent has led to faster advancements in scaling technologies like SNARKs, STARKs, and execution environments.

The end state, after execution scaling is fully integrated into Ethereum, will be a system that not only scales but also supports out of protocol chains that can tap into Ethereum’s security. This will be crucial as Ethereum scales to onboard the entire world. Even with a fully scaled Ethereum, the demand will likely outstrip supply, so having additional chains that leverage Ethereum’s security is a win in all directions.

Was the Rollup-Centric Roadmap a Mistake? 

To recap, if we consider whether the rollup-centric roadmap was a mistake, let's review the decisions the Ethereum ecosystem could have made:

1. Abandon Scaling L1: Scaling L1 is hard enough that it might not be worth the effort. Ethereum could have become a store of value, similar to Bitcoin, and focused only on a few applications. 

2. Focus Solely on L1 Upgrades: The ecosystem could have focused only on introducing upgrades to both the DA and execution on L1 together, without involving L2 solutions. It’s unclear how long it would have taken to solve execution scaling problems.

3. Leverage DA Scaling Progress: Recognizing that DA scaling was progressing faster, Ethereum could allow L2s to take advantage of it. This approach would enable companies to start leveraging L2 solutions, raise millions to accelerate execution scaling, and experiment with different execution environments to cater to various developer needs. This strategy would speed up the eventual end game of a fully scaled Ethereum and allow other chains to access Ethereum’s security in the midterm.

The Ethereum community went with option 3, which, even in hindsight, seems like the smart choice to me. By decentralizing scaling R&D and enabling a thriving L2 ecosystem, Ethereum has positioned itself to achieve its scalability goals faster and more effectively, while also opening up new opportunities for innovation and security.

But What Does This Mean for the Identity of L2s?

However, as we shift back to the question of whether L2s are truly Ethereum, it’s important to recognize that while switching DA layers is theoretically possible, in practice, it’s a monumental task. The decentralized governance structures of major rollups mean that any decision to switch DA providers would need to undergo rigorous community scrutiny, requiring multiple rounds of voting and discussions. Even if a decision were to pass, users would have ample time to exit the rollup if they disagreed with the move. This process is not only time-consuming but also potentially disruptive, making it unlikely that an established rollup would easily switch from Ethereum. The level of coordination, community consensus, and technical adjustments required to switch DA layers underscores the deep ties between these L2s and Ethereum.

Additionally, L2s are deeply intertwined with Ethereum because they are derived directly from Ethereum L1. The L2 chain is constructed using data from Ethereum L1, including L1 block attributes, deposits, sequencer batches, and system configuration updates. You can see this in the OP Stack Specs. 

Moreover, the bridge contracts on Ethereum L1, which facilitate deposits, withdrawals, and proof verifications, are critical to the functioning of these rollups. The massive amounts of value locked in these bridges—billions of dollars in ETH and other ERC20 tokens—highlight the dependence of L2s on Ethereum. For example, Arbitrum’s bridge holds about ~2m ETH (~$6bn), Base’s bridge holds ~550k ETH (~$1.4bn), and OP Mainnet’s bridge holds ~510k ETH (~$1.3bn). And these figures only account for ETH balances, the bridge also secure other ERC20 tokens worth billions more. These bridges serve as the ultimate safety net, allowing users to exit the rollup back to L1 if necessary. 

For zkRollups, Ethereum L1 is also where the SNARK/STARK verifiers reside, which are responsible for verifying the correctness of state transitions. Similarly, for optimistic rollups, L1 is where the fraud proof game plays out, ensuring that any disputes about state transitions are resolved securely. It’s crucial that these smart contracts are free of bugs and remain safe because any failure could result in an invalid state transition, undermining the entire rollup. As these contracts become more battle-tested and prove their security over time, the likelihood of moving away from Ethereum decreases. The longer these rollups operate on Ethereum, the more entrenched they become, making a switch increasingly unlikely.

While it’s theoretically possible for rollups to switch their DA layers or even move their proof verifiers to another chain, such a shift would be incredibly complex and messy, akin to a major hardfork. The longer these rollups operate on Ethereum, the more entrenched they become, making a switch increasingly unlikely.

Josh Stark frames it well, he’s been tweeting stats with this format for months: “Ethereum is ____ (insert metric) L1 plus ______ (insert metric) on all L2s under its security.” As long as these execution environments use Ethereum, they are Ethereum. But it’s true—theoretically nothing is stopping them from leaving in the future.

Sure, but They Don’t Feel Like Ethereum

A reasonable counterpoint to my argument that rollups are Ethereum is that, while technically true for the reasons I laid out, it doesn’t matter if they don’t feel like Ethereum to the user. From the user’s perspective, it can often feel like navigating 30 different chains, which is a real pain in terms of user experience. I agree with this, but it’s important to recognize that the entire Ethereum community is aware of this issue and is actively working on a solution.

There are two standards in development that will allow users to make transactions without needing to worry about which chain they’re on, as long as it’s within the Ethereum ecosystem. The wallet will handle everything behind the scenes, making the experience seamless and truly feel like Ethereum. 

For example, once these standards are adopted and built into apps and wallets, the experience will be seamless. Let’s say you visit an application built on Zora and want to collect a photograph for 0.001 ETH, but you’ve never used Zora before, and all your ETH is on Base. You just click mint, and it works as if your ETH is already on Zora. In the background, the wallet is handling the bridging of the 0.001 ETH to Zora, but you won’t even notice it happening.

Vitalik has been advocating for the adoption of these standards for months, and there’s an active Telegram group with 76 wallet developers, researchers, and application developers who are working on finalizing and implementing these standards.

Before long, using an L2 will feel like using Ethereum itself, with the complexities hidden in the background.

Conclusion

2015: "Ethereum is a scam ICO that will never ship."

2016: "Ethereum is dead after the DAO hack, there's no coming back."

2017: "Ethereum is only used for scam ICOs."

2018: "Ethereum will never scale, EOS, Cardano, or Polkadot will overtake it."

2020: "Proof of Stake will never work or ship."

2021: "Ethereum has abandoned its users despite supporting them in the past."

2024: "Ethereum is a security, it will never get an ETF."

Today: "The rollup-centric roadmap was a mistake. L2s aren't Ethereum, and the UX is a real pain."

That's the FUD timeline, but I don’t subscribe to a world of FUD. Instead, let’s look at the reality of Ethereum’s scaling journey:

2015: Ethereum Mainnet launched with a transaction throughput of approximately 12-15 TPS, setting an ambitious goal to scale beyond Visa's capability of 24,000 TPS.

2015: Ethereum community realized that scaling required solving two distinct problems: DA and execution.

2017/2018: Efforts to solve the execution problem through sharding hit a dead end. The community identified advanced cryptographic solutions like SNARKs and STARKs as the future of scaling execution, although they were considered decades away from readiness. Meanwhile, DA research thrived, leading to the publication of the DAS paper.

2019: It became clear that DA could be scaled independently of execution. This realization allowed rollups to begin leveraging Ethereum's security while solving the execution problem.

2020: Ethereum researchers recognized that they could decentralize Ethereum’s scaling R&D by allowing L2s to form corporations, raise millions from venture capital, and focus on solving the execution problem and advancing cryptography. Researchers continued working on scaling DA.

2020-2022: L2 projects like ZKsync, Polygon, StarkNet, Optimism, and Arbitrum raised substantial amounts of capital—$458M, $451M, $261M, $178M, and $124M, respectively.

2021: 

• The "end game" solution to the DA problem was proposed: Danksharding. 

• Optimism launched as the first rollup on Ethereum.

2022: The Proto-Danksharding plan was introduced as an intermediate step toward Danksharding. From the perspective of rollups, this would mark their final interface with Ethereum, with the introduction of blob data space.

2023: 

• The first zkEVM rollup, ZKsync, launched, followed by other zkEVM rollups like Polygon zkEVM, Scroll, and Linea. Just a few years earlier, zkEVMs were considered a distant possibility. 

• Base was announced, bringing the publicly traded giant Coinbase into the arena of helping to scale Ethereum execution.

2024: 

• The Ethereum network, comprising Ethereum L1 and L2s, reached 138 TPS before Proto-Danksharding went live. After its implementation, the network hit an all-time high of 360 TPS.

• Despite the thriving rollup ecosystem, users experienced the network as navigating individual chains rather than one cohesive Ethereum. In response, the community began actively working on and implementing standards to abstract away the different chains, aiming to create a seamless, unified Ethereum experience.

• Execution scaling also made significant strides, with Base, announcing its goal to reach 1 Ggas/s, a 400x increase from current levels.

• New L2 projects, such as MegaETH and Reddio, raised significant funds and set ambitious targets to push the limits of execution scaling, aiming for 100k+ TPS through innovative approaches like advanced node specialization and optimizing parallel execution.

• Meanwhile, zkEVM rollups continued to mature, with developers focusing on refining and finalizing their smart contract designs, bringing them closer to a fully optimized and secure state.

2025: PeerDAS is expected to go live, bringing DAS to Mainnet, further advancing Ethereum’s DA scaling.

It once looked like Ethereum would never scale. The prevailing thought was that the only way to scale these systems would require data centers to verify transactions. The cypherpunk vision, where anyone in the world can cheaply verify the internet of value and know their digital property will never be taken from them, seemed dead. But I’ve just laid out where Ethereum currently stands and how it got here. Do you think this vision is dead? I think you know where I stand.

Thank you to YB, Paul Dowman, Shazow, Samuel, and the Farcaster community for their comments on earlier drafts.