Native rollups are the latest buzzword in the Ethereum ecosystem. In this post, you will get an understanding of:

1. What are native rollups?
2. Why are native rollups are important?
3. How native rollups work?
4. When will they arrive?

​

What are native rollups?

First and foremost, can we stop calling them 'programmable execution shards'? It’s not obvious what that even means and adds unnecessary complexity to a topic that already demands a fair bit of background knowledge. Now that that's out of the way, let’s unpack what a native rollup actually is.

​

"Okay, what is it then?"

A native rollup is an L2 on Ethereum that makes use of a new EXECUTE precompile, a built-in function designed to act as a verifier for rollup state transitions.

​

"Firstly, what is a precompile?"

Precompiles are special contracts that are bundled with the EVM, for example, ecrecover. They’re more efficient than normal smart contracts and are often used for cryptographic functions.

​

"Okay, what is the EXECUTE precompile?"

The EXECUTE precompile acts as a verifier for EVM state transitions, allowing rollups to plug directly into Ethereum’s native infrastructure rather than relying on their own verification methods (like fraud proofs). It’s basically the Ethereum state transition function reimplemented as a precompile. An EVM inside the EVM, if you like.

​

"Got it, so where does this precompile live?"
​It’s part of the node software and would be accessible on Ethereum L1. That means when you're writing smart contracts on mainnet, you’d be able to call this precompile just like any other.

​

Why are native rollups important?

Native rollups address key challenges faced by current L2s:

• 🔐 Enhanced Security & Decentralization: Leveraging the EXECUTE precompile on Ethereum mainnet means L2s would inherit all the security guarantees of this precompile. L2s wouldn't have to rely on custom built verification mechanisms (like fraud proofs) to know if the proposed L2 state transitions were valid or not.
• 🧠 Simplified Governance: Current rollups often rely on governance mechanisms to manage upgrades. Which introduces complexity and risk. Native rollups reduce the surface area for governance by embedding verification logic directly into Ethereum.
• 🔁 Streamlined Interoperability​
  With shared infrastructure and a common execution verification method, native rollups can easily verify each other’s state transitions. This reduces trust assumptions and enables seamless cross-rollup communication, fostering a more composable and efficient L2 ecosystem.

​

By integrating tightly with Ethereum's infrastructure, native rollups offer a scalable, secure, and decentralized solution that aligns with the network's core principles.

How do native rollups work?

​

Optimistic rollups process transactions off-chain and assume they’re valid unless someone submits a fraud proof during a dispute window. If challenged, Ethereum re-executes the transaction to check for correctness.

Native rollups take a simpler path. They use the EXECUTE precompile to re-execute transactions directly on Ethereum, no fraud proofs or dispute games required. This reduces complexity and tightly aligns rollup security with Ethereum itself.

​

🔍 Transaction Verification​
Instead of submitting just a final state root, native rollups submit a transaction trace (a list of L2 txs) to Ethereum. The EXECUTE precompile re-executes this trace using Ethereum’s execution engine to verify correctness. No external verifier needed.

🧩 Simplified Proof Mechanisms​
Unlike optimistic rollups (which rely on fraud proofs) or ZK-rollups (which use cryptographic proofs), native rollups skip custom verification systems altogether.

​

🚀 Future Enhancements

Re-executing every transaction on Ethereum creates a throughput bottleneck for native rollups. Validators need to process each transaction trace submitted by the rollup, which limits scalability. This somewhat defeats the purpose of using rollups in the first place.

Over time, native rollups can adopt zero-knowledge proofs for greater efficiency. Instead of replaying every transaction, the EXECUTE precompile would verify a zero-knowledge proof that proves L2 execution.

​

When will they arrive?​
Native rollups have generated a lot of interest, but I suspect they're still a few years away. As with any major upgrade, coordinating Ethereum development is a monumental task. Even if the EXECUTE precompile were ready and implemented tomorrow, we’d still be waiting on advancements in zero-knowledge proof generation to unlock native rollups' full potential.

That said, we're definitely trending in the right direction.

An interesting thought experiment:​
What if Base became a native rollup tomorrow, the EXECUTE precompile was live, but SNARK verification wasn’t available yet? How much would it actually cost to run the chain?

Today, Base operates as an Optimistic Rollup. It batches transactions and posts blobs and state roots to Ethereum. But as a native rollup, every transaction batch would need to be fully re-executed on Ethereum using the EXECUTE precompile.

I haven’t worked out the cost yet, but one thing’s clear: it wouldn’t be cheap. Even a rough estimate would be tough to pin down, but if you’ve got thoughts or want to take a stab at it, drop me a reply. I’d love to feature a few responses.

​

References:

• ​2077 Research​
• ​Cointelegraph​
• ​Ethereum Magicians​
• ​L2Beat​
• ​ethproofs​