Original title: Simplifying the L1
Original article by Vitalik Buterin
Compiled by: Asher ( @Asher_0210 )
Editors note: Once upon a time, Bitcoin amazed us - a protocol that even high school students can understand can support the operation of the global decentralized financial system. When we look back at Ethereum, the world computer that was once promised is now trapped by complexity: from the cumbersome virtual machine, the difficult-to-maintain consensus mechanism, to the layers of pre-compiled contracts, data structures and gas mechanisms. Its time to start again and get Ethereum back on track to be simple, not only scalable, but also understandable, maintainable and verifiable.
Ethereums goal is to become the worlds ledger - a platform that carries civilization assets and records, and supports the underlying protocol of key infrastructure such as finance, governance, and high-value data authentication. To achieve this vision, two core capabilities must be taken into account: scalability and resilience.
The Fusaka hard fork will bring a 10-fold increase in L2 data space, and the 2026 roadmap also plans to make similar expansions to L1. At the same time, Merge has turned Ethereum to PoS consensus, client diversity has rapidly improved, ZK verifiability and quantum attack resistance research have continued to advance, and the application layer has become more powerful. But in addition to expansion and performance, there is another easily overlooked but equally important foundation for resilience: the simplicity of the protocol.
Simplicity is the ultimate shield of decentralization
The most amazing thing about Bitcoin is the extreme simplicity of its protocol:
The blockchain consists of a string of blocks;
Each block is linked to the previous block via a hash;
The block is verified by PoW, that is, checking whether the first few bits of its hash are 0;
Each block contains transactions, which consume coins generated by mining or previous transactions.
A high school student who knows code can fully understand how the Bitcoin protocol works, and a programmer can even implement a client on his own as a side project. This simplicity brings the following benefits:
It is easier to be widely understood, lowers the threshold for research and development, and prevents it from being dominated by technocrats;
Reduce the cost of developing new clients, validators, tools, and other interface infrastructure;
Reduce the complexity of long-term maintenance;
Reduce the risk of major security vulnerabilities and make it easier to verify the correctness of the protocol;
Reduce the social attack surface that can be manipulated by special interests.
Historically, Ethereum has not done well in this regard, which has led to unnecessary development costs, security risks, and a closed research culture. In the next five years, Ethereum has the potential to become almost as simple as Bitcoin, and we can start from two levels: the consensus layer and the execution layer.
Simplifying the consensus layer
The new consensus mechanism of the future (formerly known as the beam chain) combines the deep accumulation of consensus theory, ZK-SNARK, staking economics, etc. in the past decade. Its goal is to build a long-term optimal and significantly simplified consensus layer. Key initiatives include:
3-slot finality: removes the complex logic of slots and epochs; no longer requires committee shuffles, synchronization committees, and other mechanisms; the basic implementation can be written in about 200 lines of code; and has closer to optimal security than the current Gasper protocol.
Simplified fork choice and network structure: Fewer active validators allow for simpler fork selection rules; STARK aggregation allows anyone to become an aggregator without the need for trust and complex payments; more robust p2p architecture.
Simplify the logic related to state transition: redesign the mechanisms for validator joining, exiting, withdrawing, key switching, etc.; reduce code complexity, and express key behaviors such as subjective cycles more clearly.
The benefit of the consensus layer is that it is relatively independent from the EVM execution, allowing for these upgrades to be made more freely. The real difficulty lies in how to simplify the execution layer.
Simplify the execution layer
The execution layer is the real gathering place of black magic: complex EVM instruction set, lengthy and difficult to understand precompiled contracts, difficult to expand SELFDESTRUCT, and heavy historical compatibility burden. Therefore, a concise, high-performance, ZK-native-friendly VM is used to replace EVM, such as RISC-V, which has the following advantages:
Performance is directly improved by 100 times;
Seamlessly integrate with mainstream programming languages;
Can run natively on zero-knowledge proof systems;
The static structure is clear, which is conducive to auditing and security verification;
There is almost no need to pre-compile contracts, and even quantum-resistant algorithms can be deployed natively in the future.
However, the migration is not a hard fork, but allows the old contract to continue to run in an EVM interpreter, which itself is a contract written in RISC-V. Just as Apple used Rosetta to transition to ARM chips, Ethereum can upgrade its virtual machine painlessly.
Shared components for a more elegant system chassis
In the future, the Ethereum protocol should integrate more “shared components” to completely reduce the complexity of the system:
Unified erasure code: used for data availability sampling, historical storage, P2P broadcast acceleration, and avoiding duplicate design;
Unified Serialization Format (SSZ): Similar to the current ABI, with good compatibility but more efficient, and conducive to L2 decoupling;
Unified state tree structure (binary tree): more suitable for ZK proof, faster and simpler.
This means that the underlying layer of Ethereum is no longer made up of “various patched compromises”, but rather “protocol building blocks” truly built with engineering aesthetics.
When complexity comes to an end, it is the best time to start simplifying
Simplicity is similar to decentralization in many ways, and both are upstream values that lead to system resilience. Truly valuing simplicity requires a cultural shift, and its benefits are often difficult to quantify immediately, while the cost of giving up flashy features and paying extra effort is immediately apparent. But over time, the value of simplicity will gradually become apparent, and Bitcoin is the best example.
Drawing on the ideas of tinygrad , we set a maximum number of lines of consensus code for Ethereums long-term specifications, aiming to make the complexity of the consensus key path as close to the simplicity of Bitcoin as possible. The logic related to historical rules will still be retained, but should be isolated from the non-consensus path. At the same time, the overall design should adhere to the concept of giving priority to simpler solutions, tend to local encapsulation rather than systemic complexity, and give priority to architectural choices with clear properties and verifiability.
