When Ethereum was first built, it could handle maybe 15 to 20 transactions per second. That’s slower than a single PayPal transaction stream. For a global financial network, that’s not enough. So developers started working on sharding - a way to split the blockchain into smaller pieces so more transactions could happen at the same time. The idea was simple: instead of every node processing every transaction, each node would only handle a fraction of the network. And that fraction? That’s a shard.
What Is Sharding, Really?
Sharding isn’t new. Databases have used it for years. Think of it like splitting a giant warehouse into 64 smaller rooms. Each room holds its own inventory, processes its own orders, and doesn’t need to wait for the others. That’s sharding. In Ethereum’s case, each shard would be its own mini-blockchain with its own set of transactions, smart contracts, and account balances. No single node would need to store all of it. Just its shard.
The original plan? Exactly 64 shards. Each one managed by at least 128 validators. These validators wouldn’t stay put. Every 6.4 minutes - an epoch - they’d be randomly reassigned to a different shard. This wasn’t just for load balancing. It was a security move. If you wanted to attack one shard, you’d need to control over two-thirds of its validators. Statistically? That’s a one-in-a-trillion chance. The system was built to make hacking impossible without controlling nearly the whole network.
The Beacon Chain: The Glue Holding It All Together
Shards can’t just run on their own. They need coordination. That’s where the Beacon Chain comes in. Think of it as the air traffic controller for the whole system. It didn’t process transactions. It didn’t store user data. Instead, it managed who was a validator, where they were assigned, and when they rotated. It also handled cross-shard communication - the tricky part of letting users on Shard 3 send ETH to someone on Shard 47.
The Beacon Chain was already live after The Merge in 2022. But its original job - managing shards - was never completed. Instead, it became the foundation for something else: proof-of-stake consensus. And that’s where things changed.
How Sharding Was Supposed to Work - Phase by Phase
The rollout wasn’t meant to happen all at once. It had two clear phases.
Phase 1: Data-Only Shards
Shards would act like data lanes. They’d store transaction data - the list of who sent what to whom - but they wouldn’t execute smart contracts or hold user accounts. Nodes wouldn’t even need to verify the full state. They’d just use a clever trick called data availability sampling to check that the data was actually there, without downloading everything. This reduced bandwidth needs by over 90%.
Phase 2: Full Execution Shards
Then, shards would become full blockchains. Each one could run dApps, process ETH transfers, and host smart contracts. Users wouldn’t know which shard they were on. The system would handle cross-shard transfers automatically. If you bought an NFT on Shard 12 and paid with ETH from Shard 33, the Beacon Chain would coordinate the swap. No more waiting for a single chain to process everything.
Projected throughput? Around 100,000 transactions per second. That’s not just an upgrade - it’s a revolution. Ethereum would go from competing with Visa’s 24,000 TPS to outscaling it.
Why Sharding Got Delayed - The Pivot to Layer 2
Here’s the twist: Ethereum didn’t go ahead with sharding as planned. Not because it didn’t work. But because something better came along.
Layer 2 solutions - like Optimism, Arbitrum, and zkSync - started delivering real results. They weren’t changing the base layer. They were building on top of it. And they were already scaling Ethereum to over 5,000 TPS. With lower fees. With real users. With working apps.
Developers had a choice: wait years for sharding to be tested, coded, deployed, and secured… or use what already worked. They chose the latter. The Merge - switching from proof-of-work to proof-of-stake - became the top priority. It was urgent. Sharding? It could wait.
By 2024, the Ethereum Foundation quietly shifted focus. The old 64-shard model was replaced by Danksharding. This wasn’t just a tweak. It was a redesign. Instead of 64 independent shards, Danksharding uses one unified chain with a new data structure called blobs. These blobs carry transaction data for Layer 2s. Validators still only store a small part of the data, but now everything is coordinated in one place. It’s simpler. Faster to build. And better suited for the Layer 2 future.
Danksharding: The New Sharding Plan
Danksharding isn’t about splitting Ethereum into 64 chains anymore. It’s about making the main chain better at handling data for Layer 2s. Think of it like upgrading the highway so trucks (Layer 2s) can move more efficiently. The main chain doesn’t process transactions anymore - it just stores proof that they happened.
Here’s how it works:
- A single proposer creates a block that includes transaction data from dozens of Layer 2s.
- Validators use data availability sampling to verify that the data was published - no need to download it all.
- Layer 2s then use that data to prove transactions are valid and settle them on-chain.
This reduces the cost of publishing data on Ethereum by 95%. That’s why rollups like zkSync and Optimism are now charging pennies per transaction. Danksharding made that possible.
It’s not traditional sharding. But it achieves the same goal: more throughput. More scalability. Less congestion.
How Other Blockchains Do Sharding
Not every blockchain took the same path. NEAR Protocol, for example, went all-in on sharding. But their approach is different. Instead of 64 separate chains, NEAR splits its state into 4 shards - but every validator still tracks all of them. Every block contains data from every shard. It’s not as scalable, but it’s simpler to secure.
Polkadot uses a relay chain and parachains - a totally different model. Each parachain is its own blockchain with its own rules. Ethereum’s path was always about keeping one unified chain, just smarter.
That’s why Ethereum’s sharding story is unique. It’s not about breaking apart. It’s about evolving.
What This Means for Users Today
You don’t need to wait for sharding to use Ethereum. Layer 2s are already here. If you’re trading ETH, swapping tokens, or using DeFi apps - you’re probably already on Optimism or Arbitrum. Gas fees are low. Transactions are fast. And the base layer? It’s secure. Stable. And now, thanks to Danksharding, it’s better at supporting them than ever.
Sharding wasn’t abandoned. It was upgraded. The original 64-shard plan? It’s on hold. Danksharding is the new roadmap. And it’s already live in testnet. Full implementation is expected by late 2026.
The goal hasn’t changed: make Ethereum scalable, affordable, and global. But the path? It got smarter.
Is Sharding Still the Future?
Yes - but not the way it was first imagined. Ethereum won’t have 64 independent chains running side by side. Instead, it’ll have one powerful base layer, optimized to feed data to hundreds of Layer 2s. That’s the real win. No more bottlenecks. No more high fees. Just a network that scales without breaking.
And that’s the beauty of it. Ethereum didn’t double down on one solution. It adapted. It learned. And now, it’s scaling in a way no other blockchain has.
Is Ethereum sharding still happening?
Yes, but not as originally planned. The old 64-shard model was replaced by Danksharding, which is already being tested on Ethereum’s Goerli testnet. Full implementation is expected by late 2026. Instead of splitting Ethereum into independent chains, Danksharding improves the main chain’s ability to handle data for Layer 2 networks.
What’s the difference between sharding and Layer 2s?
Sharding splits the main blockchain into smaller pieces (shards) so each can process transactions independently. Layer 2s build on top of the main chain and handle transactions off-chain, then settle back on Ethereum for security. Layer 2s are already live and working. Sharding (Danksharding) is the upgrade that helps Layer 2s work better.
Why did Ethereum abandon the original sharding plan?
Because Layer 2 solutions like Optimism and zkSync delivered real-world scaling faster than sharding could be built. The Ethereum community chose to prioritize The Merge and support Layer 2s first. Danksharding emerged as a simpler, more efficient alternative that works with Layer 2s instead of replacing them.
How will Danksharding reduce gas fees?
Danksharding introduces a new data format called "blobs" that lets Layer 2s publish transaction data at a fraction of the cost. Instead of storing full transaction data on-chain, they store compact proofs. This cuts data costs by up to 95%, which directly lowers fees for users on rollups.
Will sharding make Ethereum faster for everyday users?
Not directly - but it will make Layer 2s faster and cheaper. Most users already interact with Ethereum through Layer 2s. Danksharding ensures those Layer 2s can scale without hitting bottlenecks. So yes - you’ll notice lower fees and faster transactions, even if you never see the base chain.
