Sharding breaks atomic composability. Splitting a blockchain into parallel shards creates isolated execution environments. A transaction requiring assets across Shard A and Shard B requires complex cross-shard communication, destroying the atomic state transitions that define a single ledger.
comparison-of-consensus-mechanisms
Blog
Why DAGs Make Traditional Blockchain Sharding Obsolete
A technical analysis comparing Directed Acyclic Graph (DAG) architectures to traditional blockchain sharding, arguing that DAGs offer a more elegant and fundamentally scalable path to high throughput by eliminating cross-shard complexity.
introduction
THE SHARDING FALLACY
The Scalability Trap
Traditional blockchain sharding sacrifices atomic composability for throughput, a trade-off DAG-based architectures eliminate.
DAGs are inherently sharded. Protocols like Narwhal/Tusk (Sui, Aptos) and Hashgraph process transactions as a directed acyclic graph. This structure allows concurrent execution of non-conflicting transactions without predefined shard boundaries, achieving parallelization without fragmentation.
The evidence is in finality. Ethereum's sharding roadmap pivoted to data availability (Danksharding) for rollups, conceding execution sharding's complexity. In contrast, Solana's Sealevel and Aptos' Block-STM demonstrate that parallel execution on a single state, enabled by DAG-like scheduling, delivers scalability while preserving composability.
key-insights
WHY DAGS MAKE SHARDING OBSOLETE
Executive Summary: The DAG Advantage
Traditional blockchains hit a scalability trilemma wall; sharding is a complex, brittle patch. DAG-based consensus is the architectural evolution.
01
The Sharding Dead End
Sharding fragments state and liquidity, creating a nightmare for cross-shard composability and security. It's why Ethereum's roadmap has de-prioritized it for years.
- Fragmented Liquidity: Breaks DeFi's network effect, akin to forcing Uniswap onto 64 separate chains.
- Security Dilution: Validators are split, reducing the cost to attack a single shard.
- Developer Hell: Forces apps to manage complex cross-shard logic, killing UX.
64x
Complexity
Fragmented
Security
02
DAGs: Parallel Execution by Default
Directed Acyclic Graphs process transactions as a web, not a chain. This enables true parallelization without fragmenting global state.
- Native Parallelism: Like Solana, but without a single bottleneck; think Aptos' Block-STM on a network level.
- Atomic Composability: All transactions see a consistent global state, enabling complex DeFi interactions that sharding breaks.
- Linear Scalability: Throughput increases near-linearly with node count, unlike blockchain's logarithmic decay.
10k-100k
TPS Potential
~1s
Finality
03
Kaspa & The GHOSTDAG Protocol
Kaspa implements a live example, using a DAG-based Nakamoto Consensus to achieve speed without sacrificing decentralization.
- Fastest L1: ~1 Block Per Second with ~10s finality, proving DAG throughput.
- No Finality Gadgets: Security derives from pure PoW and heaviest-DAG rule, not a trusted committee.
- Monolithic Security: All miners secure the entire DAG, avoiding sharding's security trade-offs.
1 BPS
Block Rate
PoW
Security
04
The Finality Illusion
Sharding often relies on 'finality gadgets' or super-committees (e.g., Ethereum's beacon chain), creating new centralization vectors and complexity. DAGs offer probabilistic finality that strengthens with time, a more robust model.
- Reduced Trust Assumptions: Avoids the Ethereum validator committee as a single point of failure.
- Simplicity = Security: Fewer moving parts than Celestia's data availability layer + execution shards + rollup stack.
- Economic Security: Attack cost is securing the entire network, not a slice of it.
-1
Trust Layer
Monolithic
Security
thesis-statement
THE ARCHITECTURAL SHIFT
The Core Argument: Parallelism Over Partitioning
DAG-based architectures achieve scalability through parallel transaction processing, rendering the complexity of sharded blockchains obsolete.
Sharding fragments network state into isolated partitions, creating a coordination nightmare for cross-shard transactions and composability. This is the fundamental flaw in Ethereum's roadmap and protocols like Near Protocol, which trade atomicity for throughput.
DAGs process transactions concurrently by ordering them based on causal dependencies, not sequential blocks. This is the core innovation behind projects like Solana's Sealevel and Aptos' Block-STM, which achieve high throughput without partitioning the global state.
Parallel execution eliminates sharding's overhead of cross-shard messaging and complex finality gadgets. The result is a simpler, more deterministic programming model where applications like Uniswap or Aave operate on a single, unified state.
Evidence: Aptos' Block-STM parallel execution engine demonstrated 160k TPS in controlled benchmarks, a throughput target that would require Ethereum to successfully deploy and coordinate dozens of shards.
CONSENSUS SCALING
Architectural Comparison: Sharding vs. DAG
A first-principles comparison of two dominant scaling architectures for transaction throughput and finality.
| Architectural Feature | Traditional Sharding (e.g., Ethereum 2.0, Zilliqa) | DAG-based Ledger (e.g., Hedera, Fantom, Kaspa) | Monolithic L1 (Baseline, e.g., Solana) |
|---|---|---|---|
Core Data Structure | Linear chain of blocks per shard | Directed Acyclic Graph of transactions | Single linear chain of blocks |
Transaction Throughput (Peak TPS) | ~100,000 (theoretical, all shards) | 10,000+ (Hedera), 300+ (Fantom Gossip) | ~65,000 (Solana, theoretical) |
Time to Finality (Typical) | 12.8 minutes (Ethereum, cross-shard) | < 5 seconds (Hedera), ~1-2 seconds (Fantom) | ~400 milliseconds (Solana) |
Cross-Shard/Cross-Tx Communication | Required, complex messaging (e.g., beacon chain) | Inherent; transactions reference parents directly | Not applicable; single global state |
Security Model | Committee-based per shard, 1/3 honest assumption | Leaderless or virtual voting (e.g., Hashgraph, GHOSTDAG) | Single validator set securing entire chain |
State Bloat Management | Shard-level state partitioning | Prunable history, full state often required | No partitioning, requires archival nodes |
Developer Experience (State Access) | Asynchronous cross-shard calls, complex | Synchronous, atomic (within a DAG 'bubble') | Synchronous, atomic, global |
deep-dive
THE ARCHITECTURAL DIVIDE
Deconstructing the Complexity: Cross-Shard Headaches vs. Native Flow
DAGs eliminate the fundamental coordination problems that make blockchain sharding a developer and user nightmare.
Sharding creates artificial complexity. Blockchains like Ethereum 2.0 and Near Protocol shard state to scale, but this introduces the cross-shard communication problem. Transactions spanning shards require complex atomic commit protocols, creating latency, unpredictable finality, and a fragmented developer experience.
DAGs have native concurrency. Protocols like Kaspa and Hedera use a DAG structure where transactions reference multiple parents. This creates a native flow of state where all transactions are part of a single, globally ordered ledger from inception, removing the need for artificial shard bridges or complex cross-shard messaging.
The cost is in coordination, not computation. Sharded L1s spend significant resources on consensus for cross-shard finality, a problem DAGs never have. This is why sharded systems see TPS bottlenecks during inter-shard activity, while DAG throughput scales linearly with network participation.
Evidence: Ethereum's roadmap delays sharding execution, focusing instead on rollup-centric scaling via Arbitrum and Optimism, implicitly acknowledging the intractable UX and complexity of native cross-shard composability that DAGs solve by design.
protocol-spotlight
BEYOND LINEAR BLOCKS
Protocol Spotlight: DAGs in Production
Directed Acyclic Graphs (DAGs) are redefining scalability by enabling parallel transaction processing, making the sequential bottlenecks of sharded blockchains a legacy concern.
01
The Problem: Shard Synchronization Overhead
Sharded blockchains like Ethereum 2.0 and Near Protocol require complex cross-shard communication, creating latency and security fragmentation.\n- State Finality requires multiple block confirmations across shards.\n- Atomic Composability between shards is slow and expensive, breaking DeFi.
2-12s
Cross-Shard Latency
High
Orchestration Cost
02
The Solution: Parallel Finality with Narwhal & Bullshark
Sui and Aptos use a DAG-based mempool (Narwhal) decoupled from consensus (Bullshark/Tusk). This allows for massive parallelization of transaction dissemination and execution.\n- Throughput scales linearly with added workers, reaching 100k+ TPS in benchmarks.\n- Low Latency finality achieved in ~500ms, independent of network congestion.
100k+
Peak TPS
~500ms
Finality
03
The Problem: MEV in Sequential Blocks
Linear blockchains are vulnerable to maximal extractable value (MEV) as proposers can see and reorder pending transactions. This creates a toxic environment for users and dApps.\n- Front-running and sandwich attacks are systemic.\n- Proposer-Builder-Separation (PBS) adds complexity as a patch.
$1B+
Annual MEV
Inefficient
Market Design
04
The Solution: Leaderless Consensus & DAG-based Ordering
Protocols like Kaspa (GHOSTDAG) and Aleph Zero use DAGs for near-instant, leaderless consensus. Transactions are gossiped and ordered without a single powerful block proposer.\n- Reduced MEV Surface: No single entity controls transaction ordering.\n- Fairness: Native resistance to front-running via deterministic, time-based ordering rules.
1 Block/s
Kaspa BPS
Leaderless
Consensus
05
The Problem: Monolithic Execution Bottlenecks
Even with parallel transaction dissemination, execution is often single-threaded. This creates a bottleneck where hardware cannot be fully utilized, capping scalability.\n- EVM is inherently sequential.\n- Solana's parallel execution (Sealevel) is still bound by a global state schedule.
Single-Threaded
Execution
Capped
Hardware Use
06
The Solution: Move VM & Object-Centric State
Sui's DAG architecture pairs with the Move VM and an object-centric data model. Transactions that touch independent objects are executed in parallel without conflict.\n- Horizontal Scaling: Validators add cores to increase throughput linearly.\n- Sub-second Finality: For simple payments, achieved in 390ms by bypassing consensus entirely via owned object transfers.
Linear
Core Scaling
390ms
Simple Tx Finality
counter-argument
THE LEGACY SCALING ARGUMENT
Steelman: The Case for Sharding (And Why It's Fading)
Sharding was the canonical scaling solution for monolithic blockchains, but its architectural complexity and the rise of superior paradigms have rendered it obsolete.
Sharding partitions state and computation across multiple chains to scale a monolithic L1. The core argument was horizontal scaling via parallel execution, avoiding the centralization pressures of simply increasing block size or lowering block times.
The fundamental flaw is cross-shard communication. Every atomic transaction spanning shards requires complex consensus overhead and synchronous messaging, creating a latency and finality tax that negates scaling gains for DeFi's composable logic.
Ethereum's pivot to rollups validated this critique. The ecosystem chose specialized execution layers like Arbitrum and Optimism over implementing sharding, proving that modular separation of concerns is a more pragmatic scaling path.
DAG-based architectures like Narwhal-Bullshark make sharding obsolete. They achieve parallel execution by separating data dissemination from consensus, enabling sub-second finality without the cross-shard coordination hell that plagues blockchain sharding designs.
FREQUENTLY ASKED QUESTIONS
Frequently Challenged Questions
Common questions about why Directed Acyclic Graphs (DAGs) are making traditional blockchain sharding obsolete.
A DAG processes transactions asynchronously in a graph, while sharding splits a linear blockchain into parallel chains. DAGs like Hedera Hashgraph and Nano achieve parallelism at the transaction level, eliminating the need for complex cross-shard communication and state synchronization that plagues sharded systems like Ethereum 2.0.
future-outlook
THE SHARDING ENDGAME
The Road Ahead: A Multi-Chain World of Specialized Primitives
DAG-based architectures render traditional blockchain sharding obsolete by solving its core coordination problems.
DAGs eliminate sharding's consensus overhead. Traditional sharding splits a chain into partitions, creating a massive cross-shard communication and finality problem. DAGs like Narwhal (used by Sui/Aptos) or PHANTOM inherently process transactions in parallel without partitioning state, making sharding an unnecessary complexity.
The bottleneck shifts to execution, not consensus. Projects like Monad and Sei optimize execution layers after adopting high-throughput consensus. This specialization mirrors how Arbitrum and zkSync outsourced security to Ethereum while focusing on speed, creating a clearer modular stack.
Sharding creates unmanageable liquidity fragmentation. A sharded L1 still operates as a single chain for users, but Cosmos and Solana show that applications demand dedicated throughput and governance. A multi-chain world of specialized chains (DeFi on Solana, gaming on ImmutableX) is the inevitable scaling outcome.
Evidence: Ethereum abandoned execution sharding. The Ethereum roadmap pivoted to rollup-centric scaling and Danksharding for data availability, conceding that execution sharding's complexity outweighs its benefits. This validates the DAG approach of parallelization without fragmentation.
takeaways
WHY DAGS WIN
TL;DR: Key Takeaways for Architects
Directed Acyclic Graphs (DAGs) like Avalanche, Fantom, and Hedera are not just faster blockchains; they represent a fundamental architectural shift that renders traditional sharding obsolete.
01
The Problem: Sharding's Consensus Fragmentation
Sharding splits the network into isolated shards, each with its own validator set and consensus. This creates cross-shard communication overhead and security fragmentation, where a single shard can be 51% attacked with far less capital. Projects like Ethereum 2.0 and Near Protocol must engineer complex solutions to mitigate this.
1/N
Shard Security
100ms+
Cross-Shard Latency
02
The Solution: DAG-Based Virtual Voting
Protocols like Avalanche use a metastable consensus where every validator samples the entire network. Transactions are gossiped and validated in parallel, forming a DAG. Finality is achieved through repeated sub-sampling, making the entire network secure as one unit.
- Global Security: Attack cost scales with the entire validator set, not a shard.
- Atomic Composability: All transactions exist in a shared state DAG, eliminating cross-shard delays.
1-3s
Finality
1000+
TPS
03
The Problem: Sequential Block Production Bottlenecks
Traditional blockchains (L1s, rollups) are fundamentally sequential. A single leader or committee produces one block at a time, creating a hard throughput ceiling. Parallel execution engines (Solana, Monad) help but don't solve the consensus bottleneck. This is the core scalability wall.
~12s
Block Time (Eth)
~15
TPS (Eth)
04
The Solution: Parallel Consensus & Validation
In a DAG, there is no single block. Nodes gossip transactions and votes concurrently, building the DAG in parallel. Validators work on multiple parts of the transaction history simultaneously.
- Native Parallelism: Throughput scales with network bandwidth, not block time.
- No Leader: Eliminates leader-based bottlenecks and MEV centralization points seen in Solana or Binance Smart Chain.
10,000+
Theoretical TPS
~500ms
Latency
05
The Problem: State Bloat & Storage Overhead
Sharding and high-TPS chains push state growth onto full nodes, creating unsustainable hardware requirements. Ethereum archive nodes require ~12TB. This centralizes node operation and hurts decentralization.
10+ TB
State Growth/Year
$1k+/mo
Node Cost
06
The Solution: Prunable Transaction Histories
DAGs naturally separate transaction history from state. Once a transaction is finalized and its effects are applied to state, the raw transaction data can be pruned from the DAG. Only the current state and a compact cryptographic proof (like Hedera's hashgraph) need to be stored.
- Constant Storage: Node storage grows with state, not with total transaction history.
- Light Client Friendly: Pruned proofs enable efficient verification, similar to zk-SNARKs but for consensus.
<1 TB
Node Storage
-90%
Storage Cost
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall