A Sharded L2? How "=nil;" Offers a New Solution to L2 State Fragmentation
TechFlow Selected TechFlow Selected
A Sharded L2? How "=nil;" Offers a New Solution to L2 State Fragmentation
Long live sharding, sharding is dead.
Navigating Web3 tides with focused insightsAuthor: Avi Zurlo, =nil; Foundation
Translation: Alex Liu, Foresight News
Ethereum's shift toward a rollup-centric roadmap has triggered explosive growth in modular scaling designs. This growth was initially successful—eliminating gas fees above $100 and unlocking entirely new application architectures. But just a few years later, Ethereum and its rollups face a new critical challenge: state fragmentation.
At its core, state fragmentation is a scalability problem. Recently, the modular community has pushed middleware solutions that merge existing rollups into a single system, ostensibly achieving blockchain scaling’s holy grail—horizontal scaling. However, these solutions come with significant trade-offs. A new generation of Ethereum L2s is rethinking scalability from first principles, applying both vertical and horizontal scaling techniques to deliver ultimate performance.
Two Paths to Scaling
There are two primary directions for blockchain scaling:
-
Vertical scaling: Increasing the resources of individual nodes. This is Solana’s scaling philosophy—maximizing hardware utilization while parallelizing VM behavior.
-
Horizontal scaling: Distributing workloads across multiple servers. This is the scaling approach used by sharded L1 blockchains like Near and Ethereum (Danksharding).
Rollups are often mistakenly viewed as Ethereum’s horizontal scaling solution. However, each rollup—and indeed every blockchain—is defined by the ledger it maintains, meaning rollups are systems independent of Ethereum. This fundamental misunderstanding of database scaling principles forces the Ethereum ecosystem to confront an ongoing challenge: state fragmentation.
Current Challenges
State fragmentation across L2s has become a major issue for Ethereum. The fragmentation problem manifests in three ways:
-
Dozens (or even hundreds) of L2s connected to Ethereum, each advancing specialized application infrastructure, inevitably degrade network effects around global state—including liquidity and user distribution.
-
The combination of interoperability standards and social coordination complexity has proven to be a catalyst for cross-chain bridge hacks, including attacks resulting in over $2.8 billion in losses.
-
Objectively worse developer and user experience. Developers are forced to use complex network abstraction layers to provide seamless UX, or else users must endure complicated cross-chain interactions involving asset bridging, wallet network management, and multiple gas tokens.
Meanwhile, these problems are worsening. Due to limitations in existing infrastructure, price-sensitive applications are forced to remain isolated to maintain reliably low transaction fees. As the next cycle approaches, a vicious snowball effect looms: as L2 congestion fees rise, more developers will be compelled to build application-specific infrastructures, further exacerbating the pervasive state fragmentation. It would not be surprising if, in a few years, Ethereum’s application dominance erodes due to unresolved state fragmentation at the L2 level.
Solving State Fragmentation
State fragmentation is fundamentally a scaling problem. The burden of scaling without breaking composability now falls on L2s. L2s can take two approaches to address this:
-
Work backward: Merge existing rollups into a single system, achieving “horizontal scaling” retroactively.
-
Start fresh: Redesign a scalable L2 from the ground up.
Working Backward
The first approach is quite popular among existing L2 projects. By using middleware to unify rollups, teams aim to create a theoretical single system. In practice, these solutions facilitate cross-rollup communication through shared consensus guarantees. Examples include shared sequencers, shared provers, and various L3 architectures.
While the teams and projects focused on these solutions are strong, relying on middleware to solve L2 scaling comes with several compromises:
-
The weakest chain becomes the bottleneck: Network security and performance are determined by the weakest component in the stack (the “weakest-link” problem).
-
Fragmented development environment: Middleware can connect different environments but cannot improve the fractured developer experience.
-
Requires global social coordination on cross-rollup standards: Merging existing rollups requires hundreds—or even thousands—of stakeholders to agree on best practices.
More importantly, it distracts L2 teams from addressing open issues such as congestion fee pricing and single-operator censorship—problems that require substantial engineering and research effort.
Starting from Scratch
Ethereum L2s can vertically scale by enhancing the execution environment of rollup nodes, thereby increasing hardware utilization. Projects like Eclipse and Movement Labs pursue this path by building rollups using SVM and MoveVM, respectively. These approaches hold promise for near-term scalability improvements, though they require Ethereum developers to adopt new tech stacks.
Alternatively, L2s can horizontally scale by (re)introducing execution sharding, enabling the network to grow by adding new nodes. This approach promotes decentralization, offers higher theoretical scaling limits, and allows for vertical scaling optimizations when needed. Given these advantages, =nil; Foundation has designed a sharded L2 called =nil;.
=nil; is optimized to preserve Ethereum’s core values—decentralization, censorship resistance, and permissionlessness. Built on zkSharding, a novel and verifiable sharding architecture, =nil; combines the scaling properties of horizontal scaling with a unified, integrated development environment. This enables developers to access thousands of rollups from a single network. More importantly, =nil; ensures users enjoy consistently low transaction fees—even during peak activity.
Furthermore, =nil; dynamically splits and merges state based on access demand, solving the congestion fee problem. This dynamic behavior allows =nil; to maintain persistently low transaction costs (<$0.01). In sum, =nil; Foundation’s mission is to offer an alternative Ethereum L2 scaling path that aligns more closely with Ethereum’s core values and the execution demands of modern L2s.
Conclusion
Despite many challenges ahead, the future of Ethereum L2s looks more promising than ever. As L2 designs mature, our next generation of scaling solutions reveals two prevailing dichotomies: working backward vs. starting from scratch, and horizontal scaling vs. vertical scaling.
Sharding is dead. Long live sharding.
Join TechFlow official community to stay tuned
Telegram:https://t.me/TechFlowDaily
X (Twitter):https://x.com/TechFlowPost
X (Twitter) EN:https://x.com/BlockFlow_News
@nil_foundation
