Combining sharding technology with L2? 「=nil;」 proposes a new L2 state fragmentation solution

Default:Avi Zurlo,=nil; Foundation

Compiled by Alex Liu, Foresight News

Ethereum’s shift toward a Rollup-centric roadmap sparked an explosion of modular scaling designs. This growth was initially successful, eliminating $100+ gas fees and unlocking entirely new application designs. But just a few years later, Ethereum and its Rollup faced a new critical problem: state fragmentation.

Fundamentally, state fragmentation is a scaling problem. Recently, the modularity community has promoted some middleware solutions that merge existing Rollups into a single system, (ostensibly) achieving the holy grail of blockchain scaling - horizontal scaling. However, these solutions come with major compromises. A new generation of Ethereum L2 is rethinking scalability from first principles, applying vertical and parallel scaling techniques to provide final performance.

Two major expansion directions

There are two major directions for blockchain expansion:

1. Vertical expansion: Increase the resources of a single node. This is Solana’s expansion concept, which is to maximize hardware utilization while parallelizing the behavior of VMs (virtual machines).
2. Horizontal expansion: Distribute the workload across multiple servers. This is the expansion concept of sharded L1 blockchains such as Near and Ethereum (Danksharding).

Rollups are often mistakenly considered to be Ethereum's horizontal scaling solution. However, each Rollup, and each blockchain, is defined by the ledger it maintains, which means that Rollup is a system independent of Ethereum. This major neglect of the basic principles of database scaling requires the Ethereum ecosystem to solve an existing challenge: state fragmentation.

Current Challenges

State fragmentation across L2 has become a major problem for Ethereum. The problem of fragmentation manifests itself in three aspects:

1. Dozens (or even hundreds) of L2s connecting to Ethereum to advance specific application infrastructure are bound to damage the network effects of the global state, including liquidity and user distribution.
2. The combination of interoperability standards and the complexity of social coordination was the catalyst for the over $2.8 billion cross-chain bridge hack.
3. Objectively worse developer and user experience. Developers are forced to use complex network abstraction technology to provide a seamless user experience, otherwise users will be forced to face complex cross-chain interactions including cross-chain assets, wallet network management, and multiple gas tokens.

At the same time, these problems are getting worse. Limited by existing infrastructure, price-sensitive applications are forced to remain isolated in order to obtain reliable low transaction fees. As the next cycle approaches, a vicious snowball effect is about to occur; as L2 congestion fees increase, more developers will be forced to choose infrastructure customized for their applications, exacerbating the widespread state fragmentation problem. In a few years, it would not be surprising if the Ethereum ecosystem application loses its dominance because L2 cannot solve state fragmentation.

Solving state fragmentation

State fragmentation is fundamentally a scaling problem. The burden of scaling without destroying composability lies with L2. L2 can solve the scaling problem in two ways:

1. Work in reverse and merge existing Rollups into a single system to achieve "horizontal expansion".
2. Redesign a scalable L2 from scratch.

Working backwards

The first solution is quite popular in existing L2. Rollups are merged by using middleware to establish a theoretical single system. In practice, these solutions facilitate communication across Rollllups through shared consensus guarantees. These solutions include shared sorters, shared provers, and various L3 architectures.

Although the teams and projects focused on these solutions are powerful, there are many compromises in solving L2 scalability issues with middleware as the core, including:

1. The weakest link becomes the weakest link: The security and performance of the network are determined by the worst part of the stack. (Barrel effect)
2. Fragmented development environment: Middleware can connect different environments, but it cannot improve the fragmented development experience.
3. Global social coordination of cross-Rollups standards is needed: In order to merge existing Rollups, hundreds (or even thousands) of stakeholders need to agree on best practices.

More importantly, it distracts L2 teams from solving open problems like congestion pricing and single-player review, which require significant engineering and research work.

Start from the beginning

Ethereum L2 can scale vertically by changing the execution environment of the Rollup node to increase hardware utilization; these projects include Eclipse and Movement Labs, which use SVM and MoveVM to build rollups respectively. Such solutions have great hope of improving scalability in the near future; however, they require Ethereum developers to adopt a new technology stack.

Additionally, L2 can be scaled horizontally by (re)introducing execution sharding, which will allow the network to scale by adding new nodes. This approach promotes decentralization, has a higher theoretical scalability limit, and allows vertical scalability optimization when necessary. Given these advantages, the =nil; Foundation has designed a sharded L2 called =nil;.

=nil；Optimized to maintain Ethereum's core values of decentralization, censorship resistance, and permissionlessness. =nil；is based on zkSharding, a newly designed first verifiable sharding architecture. It combines the scalability features of the above horizontal scalability solutions with a single, integrated development environment. This allows developers to access thousands of Rollups from a single network. More importantly, =nil；ensures users receive reliably low transaction fees even during peak trading periods.

Additionally, =nil; dynamically splits and merges states based on demand for state access, solving the congestion fee problem. This dynamic behavior allows =nil; to keep transaction fees consistently low (<$0.01). In summary, the =nil; Foundation's mission is to provide an alternative path to Ethereum L2 scaling that is more closely aligned with Ethereum's core values and L2 execution requirements.

Conclusion

Despite the many challenges ahead, the future of Ethereum L2 looks more promising than ever. As L2 designs mature, there are two popular divisions in our next generation of scaling solutions: working backwards vs. starting from scratch, and horizontal scaling vs. vertical scaling.

Sharding is dead, long live sharding.