Fantastic post which completely changed my thinking on native rollups. There's an inherent tension in Ethereum between the following goals: (1) Embrace diversity of people and opinions and enjoy the innovation that comes with it. (2) Make Ethereum (and all of its L2s) feel like a single, unified ecosystem. Ethereum is the only ecosystem today with dozens of independent (and independently funded!) core development teams building the protocol. This is a huge strength and the talent of the people contributing to Ethereum is unmatched anywhere. But does this also create some tension? Absolutely. While there's a lot that unites them, each L2 team has its own vision, its own goals, and its own tech stack. It would be a lot easier to build a single unified ecosystem with one spec (and even one developer team). But if we did that, we'd lose the diversity and innovation that makes Ethereum stand out. The EVM and Solidity emerged from Ethereum devs, but so did @CairoLang, so did @fhenix's FHE-powered EVM, so did @fuel_network's FuelVM, and so did Arbitrum Stylus which enables WASM/Rust/C/C++ programs on Ethereum. In Vitalik's words: Instead, Vitalik advocates for taking the step to unify the Ethereum experience while maintaining its unique character and diversity. Some of this is in the form of concrete technical features like chain-specific addresses. But the bulk of this is deep coordination between teams, finding common ground between them and working together to build interop tech that unites us. Enter native rollups. Before today, I was pretty bearish on the notion of native rollups to be honest, as the way I had heard them pitched was a push for all chains to become homogenous and unify around a specific implementation of the EVM. I thought this was a bad idea because while it might make interop easier in the short term, it would stifle Ethereum's innovation in the long term. But Vitalik presented it a bit differently than I had understood: The way I understand Vitalik's view of native rollups is kinda like "refactoring" code. There are a lot of rollups that utilize the EVM and we should coordinate around a standard for that. Rather than have each rollup build this out independently, we should factor out this common feature and even add more native support for these functionalities. But importantly we should do it in a way that allows rollups to extend the VM, and build a culture that continues to value innovation. Native rollups doesn't mean that that everyone has to be homogenous; it just means that we should find the "common core" and build those components together so we can waste less time on reinventing the wheel. Some rollups may stop there and just use the shared code, while others will innovate on top of it, building custom execution environments. There's still a lot of research that needs to go into "can we do this". Can we actually build a "common core" rollup that enables innovation? What does this common core look like and how can we build it in a way that all existing EVM rollups can get behind it and benefit from it. Yes, it's early days. Yes there's a ton of research to be done. But as a vision, I think this is fantastic and I'm excited about the future of an Ethereum that's both interconnected and diverse.