Ape-tizers:

• Legacy Ethereum L2s like Arbitrum and Optimism just can’t keep up when it comes to latency and throughput.
• RISE takes a different approach: speed is baked in via optimizations to the EVM itself.
• The RISE blockchain is built on the RISE stack, the same high-performance infrastructure powering a growing ecosystem of next-gen rollups.

The alarm bells have never rung louder. It feels as though we are just a tap-in away from crypto going fully mainstream.

Since its inception, the stars have never aligned quite like they are right now.

Stablecoins are taking off, the US is warming up to crypto, and blockchain is finally being used for real-world payments and settlements. For once, it’s all actually starting to make sense.

On the user side, crypto apps are beginning to break through, grabbing mainstream attention and pushing all the technical stuff into the background.

And honestly, that’s the dream. But not just yet.

Things like what network an app is built on still matter, a lot. Especially if we’re trying to bring billions of people on-chain.

Take Robinhood, for example. Their announcement about launching tokenized stocks, first on Arbitrum and eventually on their own Ethereum L2, is easily one of the biggest headlines in crypto lately.

But while it’s exciting, it also raises some serious questions about whether our current infrastructure is ready for what’s coming.

Just think about it, Robinhood has 25.5 million funded users. If even a fraction of them start interacting with tokenized assets on-chain, that’s a massive wave of new activity. And based on how adoption is already trending, that number could easily double, triple, or more over time.

The problem? Legacy L2s like Arbitrum and Optimism might not be ready for that kind of scale. Their current technical limits are going to be tested, hard.

To put things in perspective, the combined throughput of all Ethereum L2s still doesn’t come close to Solana’s verified 1,000 transactions per second (TPS).

So, why not just use Solana then?

Well, for one, 1,000 TPS isn’t exactly the speed we should be aiming for. While it might be a decent start, it is certainly not the finish line. And two, Solana hits that number by making a major tradeoff; prioritizing scalability over decentralization.

In other words, it’s relatively fast, but not in the slightest ideal.

If we’re serious about building next-gen crypto apps that can scale globally and run smoothly for billions of users, they need to be built on infrastructure that’s not just fast, but also secure, decentralized, and truly scalable.

It is based on this premise that our attention is captured by RISE, an Ethereum L2 attempting to redefine on-chain speed without tradeoffs.

What is RISE?

RISE chain is an EVM-compatible layer-2 network chain, optimized for speed and reliable performance through a high-level architecture known as the RISE stack, that achieves 100,000 transactions per second (TPS) and sub-second finality, without compromising on decentralization.

To really optimize for speed and performance, RISE takes a “if it’s not broken, don’t fix it” approach, focusing its efforts on the parts of the tech stack that matter most for those goals, while outsourcing other components like data availability (DA) and sequencing to L1 proposers.

In implementation, this basically means that apps built on the RISE stack can plug into external DA providers and even customize their own sequencers. But when it comes to raw speed and performance? All of that stuff would be handled natively by RISE.

But before we get into the how? Let’s look at the ailments of a sub 1k TPS rollup like Arbitrum and Optimism.

Challenges with L2 performance

Even with DA and sequencers out of the way, L2s still deal with a bunch of performance issues that result in congested networks and painfully slow throughput that make on-chain experiences feel… honestly, kinda terrible.

The root of these problems spans everything from execution and storage to block size, interoperability, decentralization, you name it.

I won’t bore you with all the details (yet), but let’s break down a few key ones, just to respect your time.

• If a network is going to be truly fast, execution has to be optimized for such. However, most rollups still rely on single-threaded EVM execution, where performance has no other option than to routinely follow a schedule, thereby clogging execution.
  
• Another big issue with how rollups currently work is block gas limits. These limits are directly tied to the network’s throughput, so if you try to boost throughput by increasing block size, you run into a new set of problems.
  
• For one, it can mess with the fraud-proof system. And even if that’s handled, you’re still bound by Ethereum’s own block size limits, which puts a hard cap on how far you can scale.
  
• Another issue with legacy rollups is in the mid choice of sequencing, opting for off-chain centralized sequencers, thereby lacing in fraud-proof and compromising on decentralization.

RISE believes that the aforementioned and several other challenges and opportunities set the tone for a new approach to scaling L2s, something different that takes the work legacy rollups have done even further.

The RISE stack solution

RISE develops its solution to scaling the EVM using both the Optimism approach and the ZK approach, building unique and complementary variables that drive ETH L2s to 100k TPS and beyond, while being decentralized.  

Quite like other L2s, RISE utilizes its own native version of the Ethereum token, in the form of Reth as the execution client.

The variables cut across execution, database, sequencers, data availability, and other additional improvements.

Execution

In terms of execution, RISE takes a threefold approach to optimizing rollups for rapid performance without compromising on decentralization. This cuts across:

• Parallelizing the EVM (PEVM): RISE replaces single-threaded execution with an EVM-specialized parallel executor that is implemented in Rust.
  
  By parallelizing the EVM, RISE’s stack is able to unlock the fastest EVM execution throughput possible (55 Gigagas /s) for both RISE chain and/or rollups using the stack.

• Continuous Block Pipeline (CBP): In this case, RISE takes a new approach to block production by executing transactions without waiting for consensus to request a new block.
  
  This process is called a continuous block pipeline wherein execution and block production are performed concurrently, pre-executing transactions while they reside in the mempool.

• Shreds: CBP (Concurrent Block Processing) lets transactions start executing while still in the pipeline, but RISE takes it a step further with Shreds.
  
  Shreds are essentially broken-down blocks without a state root, allowing for rapid preconfirmations of transactions.
  
  Instead of waiting for full blocks to form, RISE rollups can validate and propagate these smaller, connected segments—kind of like sending pieces of a puzzle that fit together later.
  
  This process results in improved latency, faster execution, and better performance without compromising security.

RiseDB

The RISE stack also levels up storage compared to previous rollups and even Ethereum itself. At the core of this is RiseDB, a custom-built database designed for speed and efficiency.

The choice to go the custom route with the database for the RISE stack is due to the impact that Ethereum’s current state access (whereby the key-value data is encoded to an MPT and stored in memory) has on network throughput.

RISEdb speeds up state updates and access by replacing Ethereum’s Merkle Patricia Trie (MPT) with a more efficient versioned Merkle tree, while unifying world state and Merkle storage into a single architecture piece.

This approach is lightweight, designed to run smoothly even on consumer-grade machines. That means lower hardware requirements and a much lower entry barrier for anyone who wants to participate and use the network.

Sequencers (based sequencing)

The sequencer is at the core of a rollup network’s functionality. They perform multiple activities such as ordering, executing, batching, and preconfirming transactions while updating the network state.

Legacy rollups utilize centralized sequencers for obvious reasons, their ability to handle a high volume of transactions, responsiveness, and how easy they are to set up and operate.

Unfortunately, they come with a lot of limitations and sensitive risks. Centralized sequencers are a single point of failure, a threat in waiting for the entire network, as they are prone to attacks.

This can lead to situations where the network is halted, leading to suboptimal performance.

A rollup using a centralized sequencer can also not deny the censorship accusations, as the setup allows for censorship of transactions. All of these risks are quite anti-cyberpunk and impede the core ethos of permissionless systems.

RISE navigates this through a system called based sequencing. This system utilizes a subset of L1 proposers to perform sequencing operations.

These L1 proposers will be able to order transactions, compress data, generate blocks, and also post the compressed data, while the network’s execution node processes the transactions off-chain and updates the network’s state.

Using based sequencing in place of centralized sequencers allows RISE to achieve decentralization as rollups built on the RISE stack inherit the decentralization of the L1 (Ethereum) through the proposer infrastructure.

Using L1 proposers for sequencing brings a bunch of added benefits. For starters, rollups inherit the liveness and censorship resistance of the L1, meaning they’re more resilient and reliable by design.

It also boosts economic alignment since MEV flows back from rollups to the L1, keeping incentives well-balanced. And with shared sequencing handled by L1 validators, you get stronger composability across the entire ecosystem.

Based preconfirmations

In addition to based sequencing, RISE improves on network latency through based preconfirmations. This means, rather than waiting for L1 confirmations, which lead to delays, RISE adopts a process called a preconf, whereby the L1 proposer issues a promise that a transaction will be confirmed at a specific timestamp.

This entire system shifts RISE from operating a clogged trust-based system to a more concurrently configured trustless-based system that is optimized for reduced latency and increased performance.

In a situation where a proposer fails to honor their promise, slashing is introduced in one of two events: liveness faults and safety faults.  

Celestia DA

RISE utilizes Celestia for data availability, leveraging its throughput ability, which is significantly better than Ethereum blobs at the moment. This allows RISE to focus on other aspects of scaling the network rather than building a DA layer from scratch like Nara Smith would.

However, in the event that Celestia is unavailable, RISE is designed to handle such a situation by falling back to posting transactions to Ethereum’s Blobs.

RISE Testnet

RISE is currently live on testnet, and users can get test tokens, interact with apps built on the testnet, and check how everything is pieced together.

If you’re interested in checking the testnet out, there are a handful of exciting projects being built on the chain like Centauri Labs, an on-chain, fixed-rate lending protocol; For the Kingdom, a fully on-chain MMORPG; and ChessOnChain, a chess game literally on-chain with exciting features.  

Concluding thoughts on RISE

Well, if we’re keeping it a buck, we still think that Grant’s thesis on this year being the year for based rollups is still pretty valid.

RISE has already raised $8 million in its seed round, with names like Vitalik and Sandeep backing the project. The signals are loud and clear.

But beyond the noise, from a technical standpoint, RISE and the RISE stack genuinely feel like the natural next step for rollups, purpose-built for speed, scalability, and real-world adoption.

While the race to build a real-time network is heating up, with projects like MegaETH and Monad dominating most of the Crypto Twitter spotlight, RISE, as a based-rollup stack, brings some key technical advantages to the table.

RISE offers decentralized sequencing by design and maintains closer alignment with Ethereum, giving it a strategic edge in both infrastructure integrity and long-term ecosystem compatibility when placed side by side with the aforementioned competitors.

That said, there’s still work to do. RISE needs to show more innovative grit through the projects building in its ecosystem, because at the end of the day, it’s the apps that truly validate the technical strength of any network.

Still, it’s early. And until RISE chain is live on mainnet, we’ll have to hold off on any final judgments. But so far, the foundations look promising.