Understanding Raiku: Solana's High-Performance Edge Computing Layer

Source: SHOALRESEARCH
Compiled by: Zhou, ChainCatcher

Modern blockchains have achieved scalability but have yet to achieve determinism. While Solana leads in throughput and latency, it still lacks reliable execution guarantees for high-risk applications. Raiku introduces a programmable coordination layer that restores determinism, predictability, and trust to on-chain systems without sacrificing performance. Raiku is built as a Sidecar to the Solana validator network, enabling developers to pre-allocate block space, schedule transactions precisely, and avoid all mempool chaos.

This article explores how Raiku brings execution guarantees, MEV resistance, and pre-confirmation to Solana's monolithic architecture, providing a system that emphasizes not only speed but also reliability in a distributed adversarial world.

Current State of Blockchain Architecture and Demand for Execution Determinism

The global market demands determinism. Cryptocurrencies often only bring hope.

Today's blockchain infrastructure is rife with architectural compromises. In pursuit of scalability, the systems we build violate core principles of distributed computing, assuming unlimited bandwidth, ignoring latency ceilings, and forcing applications to use generic state models that they do not require. What is the result? Fragile abstractions, unreliable performance, and a developer experience that feels more about survival than innovation.

Imagine launching a modern financial product and being told that your transactions might fail unless you spam, bribe validators, or simply pray to get included.

Blockchain systems should ultimately abstract away this complexity and provide effective decentralized infrastructure. But in reality, we have replaced server racks with validator nodes, and latency issues have shifted from physical hardware to first-layer congestion.

This is the everyday reality of Web3. Ethereum, as the most widely used smart contract platform, processes only 15-30 transactions per second. During high-demand periods such as NFT drops, liquidations, and memecoin booms, the underlying network becomes congested, fees soar, and Layer-2 is the only escape route. These Layer-2 Rollups provide enormous throughput by moving execution off-chain while lowering gas fees, but they also introduce new trade-offs: liquidity fragmentation, bridging complexity, differentiated trust models, and slightly flawed user experiences.

Meanwhile, Ethereum's re-staking ecosystem has also introduced greater fragility. Protocols like EigenLayer require validators to leverage Ethereum's social consensus to secure third-party systems, which effectively amounts to betting that the community will coordinate a rescue if any issues arise. Even Vitalik considers this practice high-risk. Ethereum's scaling remains a roadmap that will take a decade to complete. Builders need to take action now.

On the other hand, Solana pursues a high-performance monolithic design: it centralizes consensus and execution on a single chain, achieving extremely fast block times and parallel execution. In practice, Solana can typically handle 3,000-4,000 TPS on a global state machine, far exceeding Ethereum's throughput. This design can achieve low fees and near-instant finality under normal circumstances. However, Solana's single-chain architecture also shows stress under extreme loads. During spikes in usage, Solana experiences congestion or even interruptions as all dApps compete for the same global resources.

For example, historically, sharp increases in traffic (such as popular NFT mints or arbitrage bots) have led to block stalls and transaction failures. Notably, in February 2024, a bug triggered by the Solana runtime caused the network to pause for nearly five hours. Even when the network remains operational, users and bots often see transaction failures or timeouts during peak demand, undermining Solana's otherwise strong user experience. In fact, high-frequency traders on Solana have observed failure rates as high as 75% when the network is congested. This occurs because Solana's leader scheduling and QoS (Quality of Service) prioritization favors certain validators, and when too many transactions flood in, many transactions simply cannot be included in a timely manner.

Beyond throughput limitations, both ecosystems face issues of MEV exploitation and unpredictable execution. Despite Solana's use of a public leader scheduling mechanism, it still faces its own MEV dynamics. Solana's stake-weighted transaction scheduling mechanism means that large validators or order flow specialists can negotiate transactions and prioritize certain off-chain trades. This lack of transparency leads to centralization issues, where well-connected bots or firms can access quickly, while ordinary users struggle to get their transactions through. Although Solana has introduced priority fees and Jito (a dedicated MEV-aware client) to create a more open fee market, the underlying issues remain: when the network is busy, inclusivity turns into a bidding war or insider game, leaving ordinary users facing uncertainty and transaction delays.

From a state perspective, Ethereum's rollup-centric model disperses applications across various chains. Each rollup becomes an island that requires bridging, redundant tools, and additional security assumptions. When liquidity and contracts no longer coexist, the magic of DeFi—composability—disappears.

What blockchain lacks is scalability, avoiding latency spikes, state fragmentation, or transaction failures. The precision required by global finance is still lacking in blockchain.

This is the design space that Raiku occupies.

Raiku was born out of years of dissatisfaction with Ethereum's infrastructure and a deep respect for elegant system design, introducing a brand new infrastructure for Solana that focuses not on more rollups but on precise execution. It extends Solana's core by providing programmable building blocks—a edge computing environment—offering dedicated fast lanes, guaranteed bandwidth, and deterministic settlement for applications without the need to manage separate chains or disrupt composability.

If Solana is the global highway, then Raiku is the intelligent traffic control system, providing fast lanes for the applications that need them most.

This is not another Rollup, nor a sidechain. Raiku is a rethinking of blockchain execution: fast, modular, programmable, and predictable. The system is built not to chase trends but to meet the needs of institutions, developers, and globally scaled applications that require determinism rather than hope.

From Limitations to Vision: The Origin of Raiku

Raiku was born from a simple observation: not all blockchain workloads need to operate in the same crowded kitchen. At the end of 2023, a group of researchers and Solana veterans began to ask how they could offload heavy computations from Solana's L1 without losing on-chain advantages. The plan initially started as a research project (supported by Superteam and the Solana Foundation), stemming from their frustration with Ethereum-centric infrastructure being "stagnant." While Ethereum's ecosystem boasts a rich array of Layer-2 solutions, it has not achieved the leaps in performance or developer experience that these researchers hoped for; rollups are making incremental progress but still rely on a relatively slow and congested base layer. In contrast, Solana represents an opportunity to try something different: its L1 is already fast and has proven that a network-scaled blockchain is possible, but it can also improve by refining its architecture.

The Raiku team noted that by January 2024, many Solana applications were "naturally inclined" to extend their architecture, or in other words, projects were attempting to build their own mini rollups or isolated execution layers to further scale the throughput of the base layer. Due to the lack of an official framework, some teams attempted to repurpose tools like the Sovereign SDK (for independent chains) to create Solana extensions or rollups. The results were less than ideal: misusing Ethereum-oriented rollup frameworks on Solana led to poor performance and significant friction. Each project launching its own extension resulted in state fragmentation (essentially encountering all the issues present in Ethereum) and duplicated work. More importantly, these DIY solutions could not integrate cleanly with Solana's design, encountering data throughput limitations, timing issues, and the inability to share state or accounts with Layer 1.

This pattern highlighted a clear design problem: Solana needs a purpose-built extension framework rather than a framework forcibly shoved in from elsewhere.

The founding team of Raiku, led by Robin A. Nordnes and others, set out to address this issue by fundamentally building an "edge computing" layer tightly coupled with Solana. After researching other new L1s like Aptos and Sui, they chose Solana, believing it had unique advantages to support their vision. Solana has a large user base, a strong developer community, and a solid architectural foundation (often compared to early Ethereum's rapid improvements). Importantly, Solana's leadership and ecosystem are open to innovation, with core developers releasing updates every few weeks and being enthusiastic about new extension methods. Their idea was not to launch another independent L1 or create a completely separate shard, but to extend Solana in a complementary way.

As one team member put it, "We are neither L2 nor L1… we are somewhere in between." More formally, Raiku positions itself as a block-building architecture, an infrastructure protocol that connects validators, applications, and the base chain to coordinate high-performance execution, surpassing the capabilities that the base layer itself can provide. If Solana L1 is the highway, then Raiku builds the fast lanes and traffic control systems, allowing certain applications to run faster and more predictably when needed.

A key insight in Raiku's design is that many high-scale dApps do not need to continuously interact with the entire global state. Some applications can operate largely independently (their own order books or game engine logic) as long as they can occasionally settle to the main chain and leverage its security and liquidity when needed. As Nordnes explained, "Most use cases with large-scale potential do not require constant state composability." You can sandbox the execution of applications in their own areas (like L2) but still benefit from the main chain's advantages in settlement finality, shared user accounts, on-chain price data, and asset security.

This realization underpins Raiku's architecture: it aims to provide applications with their own sovereign execution environments (so they are not bottlenecked by other environments) while retaining the advantages of Solana's Layer 1 (a unified asset and identity space, and a high-performance settlement layer). In the Ethereum world, one might try to achieve similar goals by launching an Optimistic Rollup or ZK Rollup, but as the team pointed out, "You can build Layer 2 on Ethereum, but you are still severely constrained by the underlying Layer 1." Even the best rollups are limited by Ethereum's data publishing throughput, latency, and upgrade timelines (fixing Layer 1 will take a decade). The Raiku team did not wait; they saw an opportunity to leverage Solana's current advantages and innovate on top of them.

Raiku will introduce a new layer that runs in parallel with Solana's consensus, operated by the validator community (and economically aligned with it) to coordinate advanced execution capabilities. Its vision is bold: to leverage Web2 and TradFi systems (like AWS or NASDAQ) to make on-chain applications "faster, more reliable, and more competitive in the market," all while not compromising decentralization.

By early 2024, this vision gained widespread attention. The concept of scaling Solana became a hot topic, and the community ultimately decided to use this term (or network scaling) to replace L2, emphasizing scaling on top of L1 rather than forking. Raiku became one of the leading projects to implement this concept.

Technically, scaling is similar to Rollup or sidechains, but it has been labeled in a way that perhaps underestimates the capabilities that the Raiku team is building. Raiku adopted the term "edge computing" to describe its execution zones. The term "edge computing" borrows from traditional IT (referring to computing done at the edge of the network, closer to where the computation is needed). Raiku's edge computing environment is not an independent blockchain competing with Solana, but a modular execution zone located at the edge of the Solana network, built specifically to handle certain workloads with deterministic performance. This term resonates with Web2 infrastructure teams and institutional participants, bridging the conceptual gap between Rollups and familiar edge servers. Essentially, Raiku provides a custom Rollup-like environment integrated into Solana's edge computing zones (extensions). This grants developers the autonomy to execute their logic and scheduling freely without the hassle of launching an entirely new chain or dispersing users across ecosystems.

Redefining Rollups: From "Scaling" to "Edge Computing Environment"

It is worth mentioning that Raiku is reshaping the landscape of custom execution environments. In the Solana circles, the term "scaling" is used to describe these Solana-customized rollups. However, the Raiku team believes this term is somewhat narrow (even stigmatized due to early rough attempts). To capture the imagination of both cryptocurrency and traditional Web2 audiences, Raiku is building not just scaling but "edge computing environments."

Source: https://x.com/owocki/status/1830621049190560061

With Raiku's edge computing environment, we no longer view Layer-2 networks as external add-ons above Layer-1, but as an integral part of the network architecture, an extension of Layer-1, located at the edge of the network, close to users and applications. Raiku refers to this as "modular execution zones," emphasizing that you can insert different modules (each module being an execution runtime/virtual machine) into a unified system. These modular execution zones allow developers to insert different execution runtimes or custom virtual machines into a unified system, enabling them to shape the underlying application logic with unparalleled control.

The Raiku team believes that high-scale performance is not an afterthought but built from the ground up. Raiku's starting point is precisely where other technologies have stalled: breaking through the physical limits of bandwidth, geography, and time inherent in distributed networks. Specifically, Raiku is able to provide:

• System reliability that remains strong even under extreme loads and stress.
• Deterministic execution guarantees that every transaction has predictable outcomes.
• Low latency by placing high-performance edge computing (HPEC) capabilities directly at the edge of the Solana network, enabling transaction processing in just a few milliseconds.
• Developers are free to customize low-level logic, providing unparalleled flexibility and control.

Raiku's coordination engine can precisely coordinate transactions, ensuring that transactions are sent, scheduled, and confirmed quickly, supported by a well-developed pre-block space market that guarantees transaction packaging (more on this in later sections). Validator plugins support Ahead of Time (AOT) and Just-in-Time (JIT) execution. Combined with streaming proofs, these plugins can achieve instant pre-confirmation of transactions, transforming today's unreliable, best-effort interactions into reliable and schedulable executions.

The edge computing environment has practical significance. It helps narratively distinguish Solana's approach from Ethereum's: Ethereum adopts "Layer-2 Rollups," while Solana (through Raiku) adopts "edge computing." The latter implies enhancement rather than separation. This is a term that traditional finance can understand. In enterprise computing, edge computing is a positive concept that means speeding up responses by moving computation closer to where it is needed.

Raiku is essentially saying: we are moving execution closer to applications (in a logical sense), while still anchoring in the main network.

Therefore, in this report, we will alternately use "edge computing environment," "scaling," and "modular execution zones" to reflect the specific implications of the Raiku concept. Looking ahead, as Raiku's mainnet goes live and more marketing occurs, you may see "Raiku Edge Computing" become a branded term, akin to Polkadot's "parachains" or Avalanche's "subnets." This terminology also makes it easier to express new features: for example, Raiku could say "deploy your own edge computing environment on Solana within a week," which sounds like setting up a cloud environment, making it familiar to developers.

By emphasizing "edge computing," Raiku aligns with the broader trend in Web infrastructure: to improve speed, logic is moving closer to users (edge networks, CDNs, etc.), with "users" here referring to application transactions, and the edge being a special area in the network. This is a powerful analogy that can help more people understand how Raiku differs from ordinary scaling hacks.

Key Principles Underpinning Raiku's Design:

Not all dApps need continuous global state:

Some of the highest throughput applications (exchanges, games, payment networks) can operate in isolated environments for most activities, only using the main chain when necessary. Raiku addresses this by providing selective isolation mechanisms, freeing these applications from competing in the global memory pool while still allowing them to access Layer-1 liquidity/state when needed. This is in stark contrast to the Ethereum DeFi philosophy, where everything is highly intertwined on a single chain (this philosophy, while powerful, does not scale when every small application requires global atomic composability). Raiku recognizes that temporal or contextual composability (only when needed) is sufficient in many cases, leading to significant performance improvements.

Maintain the feel of a single network:

Despite introducing modular partitions, Raiku still strives to avoid the user experience challenges that come with multi-chain setups. A global account and orchestration engine ensure that from the user's perspective, Solana remains a single network. You do not need to manage multiple tokens across different chains/partitions to pay gas, nor do you need to manually switch RPC endpoints. You interact with Solana, and Raiku will route your transactions to the extension chain or main chain based on your situation in the background. This is in stark contrast to the Cosmos application chain model, or even Ethereum's Layer-2 architecture, where using a new chain means new tokens, new block explorers, and a shift in mindset.

Raiku's edge computing zones are more like "network extensions" rather than independent networks, indicating that they extend Solana rather than compete with it. Its architectural advantage lies in preserving network effects: the utility of the SOL token still supports the whole (fees, staking), and Solana's community will not splinter into dozens of small chains. This addresses a common criticism of Ethereum's rollup-centric roadmap, which is that Ethereum might merely become a settlement layer while user activity migrates to various Layer-2 tokens and ecosystems, potentially undermining Ethereum's economic security. Raiku's approach increases capacity while placing it under Solana's economic umbrella.

Leverage existing security, do not reinvent it:

Raiku will not create a new base consensus mechanism, nor will it require users to delegate funds to a brand new set of validators (in fact, Raiku will not hold funds separately; assets remain on Solana). This is more advantageous than launching an autonomous application chain or a new Layer-1. If a project chooses to launch its own chain now (whether through Cosmos SDK, Avalanche subnets, or some autonomous rollup scheme), it faces a daunting task: onboarding validators, incentivizing them (often through inflationary new token rewards), and ensuring bridge connections with other ecosystems. Raiku simplifies this process by building on Solana's validator community and bridging natively through global accounts.

There is no need for separate bridging contracts; the extension is logically part of Solana. This significantly reduces security risks and development overhead compared to sovereign chain approaches. For example, some teams have attempted to use the Sovereign SDK on Solana, ultimately leading to state fragmentation and poor performance because the Sovereign SDK was not designed for Solana's scenarios. Raiku's custom solution avoids these pitfalls and maximizes the reuse of Solana's battle-tested components (like the network, validator incentives, etc.).

Predictability and transparency as core features:

Both builders and users value knowing what will happen in the future. Raiku achieves predictability at the protocol level. Inclusion signals eliminate guesswork in the transaction submission process. The design of MEV makes it more efficient (no private mempools, all transactions are conducted through auctions or known channels). This fosters a healthier ecosystem.

On Ethereum, despite improvements, users still worry about being front-run by arbitrage bots when sending Uniswap transactions. On Solana, users worry that transactions "won't complete" when the network is busy. Raiku aims to eliminate these concerns, allowing the blockchain to feel reliable and "boring" in the best way, much like AWS infrastructure—if you schedule a task, you can trust it will run on time. This is a key selling point for institutional adoption (which requires SLAs and predictability) and for the broader consumer base (no one wants to keep hitting "submit" hoping a transaction will succeed).

Practical Use Cases Supported by Raiku's Edge Computing Design

What can developers actually achieve with Raiku that was previously impossible? The answer is: build on-chain applications at the speed and assurance of off-chain systems, deploying new types of services on Solana that might have previously required separate chains or centralized solutions. Let’s explore some illustrative use cases envisioned by the Raiku team and community, highlighting how the edge computing approach plays a role:

High-frequency trading and exchanges (e.g., Drift Protocol's Swift):

Drift is a leading Solana-based perpetual contract exchange that handles massive trading volumes. In early 2025, they launched the Swift protocol, a direct on-chain ultra-low latency matching engine built on Solana. It keeps the order book and matching logic on-chain, then routes completed trades to Drift's perpetual contract program for settlement. While Swift is innovative, it still faces a limitation: when it needs to settle these matched trades on Solana Layer 1, it is subject to the usual network conditions and may experience delays or contention (especially during market volatility when many exchanges are active).

Enter Raiku: similar DEXs like Drift can deploy dedicated edge computing extensions for their trading engines. In this extension, orders can be matched and completed on-chain (in the extension) with microsecond precision, even faster than Solana's 400-millisecond block time. This extension can utilize a Light SVM optimized for trading, achieving thousands of operations per second (e.g., matching buy/sell prices, updating trader positions) with deterministic timing. Crucially, with Raiku's guaranteed inclusion feature, once a trade is matched, it can be scheduled for settlement in the next Solana block with no uncertainty. No more racing against the clock or praying for transactions to be included; trade settlements will be pre-reserved and confirmed.

Payment and fintech infrastructure (e.g., "Stripe-like" payments, Squads):

Payment applications require both high throughput and high reliability. Imagine a scenario like Stripe on Solana, a service that processes thousands of transactions per second for merchants, payroll, micropayments, etc. On Solana Layer 1, this is theoretically feasible (given the high TPS), but in practice, if the network is congested, or if a particular program in a payment workflow consumes too many compute units, other programs may crash.

With Raiku, a payment extension can be created, essentially a (edge computing) zone dedicated to payment transactions. This extension can be optimized for simple token transfers, including specialized/optimized environments or lightweight SVMs to maximize efficiency. Through Raiku's bandwidth reservation, payment operators (like stablecoin issuers or CBDC platforms) can continuously reserve throughput, e.g., 500 TPS, to ensure their transactions always proceed smoothly, regardless of external demand. Users sending funds will receive instant confirmations (no transaction stalls).

For enterprise or institutional use, Raiku can enable private settlement networks on Solana: "private settlement channels with deterministic finality and encrypted flows between major financial institutions."

Imagine large banks settling forex trades or securities on a shared Solana extension, where they can have their own Raiku extension, with trades visible only to the parties involved (encrypted but still verifiable), ensuring finality. This would unlock use cases like cross-border payments, remittances, or interbank settlements on public chains, while maintaining the predictability of SWIFT or FedWire.

On the consumer side, tools like SquadX (a popular Solana multi-signature and coordination tool) can use Raiku to ensure multi-signature transactions (which may involve multiple instructions) are reliably executed even during network peak times. A major pain point for DAO treasuries or multi-signatures is that complex transactions often fail due to network issues. Raiku can eliminate this problem by allocating a dedicated time slot once all signers approve, allowing multi-signature transactions to complete atomically.

Additionally, through RFQ-like liquidity integrations, Raiku can empower new payment models: for example, decentralized payment applications can query market makers through Raiku's RFQ system for the best rates on currency swap trades, all operations can be completed within a single extension without slippage or MEV. This is similar to how Stripe routes payments through various banks to optimize fees and success rates, allowing Raiku to route cryptocurrency payments to various liquidity sources in a controlled, deterministic manner.

DeFi protocols and services (beyond trading):

Beyond exchanges, many DeFi protocols can benefit from Raiku's edge computing environment. Lending platforms can leverage it for instant liquidations through dedicated channels (Raiku can even achieve "microsecond precision automated risk management," meaning lending protocols can monitor positions and execute liquidation trades within guaranteed time windows, reducing bad debts). Options and derivatives platforms can use the edge computing zones as coordination centers, orchestrating complex multi-branch strategies across platforms, with Raiku guaranteeing that all branches execute atomically over continuous time periods.

For example, a decentralized options exchange (DEX) can ensure that users' trades during rollovers (closing one option and opening another) occur consecutively without price fluctuations interrupting. This level of control is currently only feasible in centralized systems. Stablecoin issuers can also benefit: imagine USDC using a Raiku extension to manage its large-scale minting/redemption processes in priority order, ensuring that large redemptions do not congest the network or get front-run. By allocating block space, they can maintain smooth operations even during times of stress.

Hybrid CEX/DEX and institutional access:

Raiku may blur the lines between centralized exchanges and DeFi. Its architecture allows for models like "regulated DeFi zones," where only KYC-verified entities (like institutions) participate, thus ensuring compliance while still settling on Solana. This hints at the vision of "hybrid centralized exchange/decentralized exchange" with an excellent user experience, where liquidity is provided by centralized exchanges (or alliances), but trades settle on public network extensions. With edge computing, such platforms can offer the speed of centralized exchanges (matching engines on dedicated hardware) while retaining the transparency and custodial advantages of DeFi (settling on Solana).

Non-financial applications (real-time gaming, social, AI agents, IoT):

While Raiku's focus seems initially on DeFi and financial markets, the framework has a wide range of applications. For real-time games or virtual worlds, Raiku can support extensions that handle rapid game state updates (imagine a fully on-chain fast-paced game, where Raiku's scheduling mechanism ensures operations are completed in a timely tick system). For social networks or messaging applications on Solana, Raiku can provide throughput to handle activity spikes (for example, a popular post that triggers thousands of replies can be processed through the extension to prevent the main chain from being overwhelmed).

The website's use cases explicitly mention bringing "AI agents, DePIN, social networks, payment infrastructure, capital markets, high-frequency trading, and the internet to Solana." This grand vision indicates that Raiku believes it can support any high-demand application that may currently feel that blockchain cannot meet its scale or speed.

For instance, AI agents executing dozens of on-chain operations per second (like participating in auctions, rebalancing portfolios, etc.) can leverage Raiku to reliably handle these operations. DePIN (projects like Helium or decentralized Uber/Airbnb concepts) often require a lot of microtransactions and device interactions, and Raiku can ensure IoT devices have reserved throughput to continuously log data or settle payments.

The common thread across all these cases is that Raiku achieves levels of performance and trust that a single Layer-1 cannot. It allows developers to envision on-chain services that rival the response speeds of centralized servers.

Raiku's Innovative Approach: Predictable Performance through Execution Consensus Separation

Raiku introduces a new block-building architecture that improves Solana's base layer from within. It achieves this by enabling programmable coordination, allowing validators and applications to execute with greater determinism without introducing separate consensus mechanisms or fragmented environments.

We can think of the Raiku network as a dedicated execution layer running in parallel with Solana's main chain, driven by the same set of validators, requiring only the Raiku Sidecar to join. This way, Raiku liberates dense application logic from competing with all traffic on Solana, but it is not an island; it is tightly synchronized with Solana to ensure finality and data availability.

Unlike other ecosystems still grappling with modular trade-offs or fragmented execution models, Solana provides a high-performance, monolithic base layer. It offers sub-second block times, ultra-low fees, and parallel execution achieved through Sealevel. These features make it the most likely blockchain to implement concepts like instant (JIT) or ahead of time (AOT) block auctions at scale without incurring high latency.

While Solana achieves fast block generation times, low fees, and parallel execution through Sealevel, the current block-building process still has limitations:

• Validator profitability remains unstable, heavily reliant on native inflation subsidies and occasional MEV peaks.
• Transaction inclusion is unpredictable, especially for applications requiring atomicity, deterministic ordering, or pre-confirmation.
• Off-protocol coordination is rising, with protocols like Jito stepping in to address the lack of robust auction mechanisms and bundled execution guarantees.

What is missing is a programmable coordination layer that can provide validators with more consistent revenue opportunities, offer dApps reliable execution capabilities, and integrate into Solana's native architecture without compromising its low-latency, high-throughput characteristics.

Under the guidance of a series of key Solana Improvement Proposals (SIMD), Solana's incentive and economic framework is rapidly evolving. These proposals reshape core validator incentive mechanisms, transaction prioritization mechanisms, and reward distribution, laying the groundwork for a more competitive and robust ecosystem:

• SIMD-0096: Redirecting 100% of priority fees to validators, significantly improving validator profitability and preventing off-chain transactions.

• SIMD-0123: Introducing a native, scalable protocol mechanism for validators to directly allocate rewards to stakeholders, enhancing economic consistency and transparency.
• SIMD-0228: Introducing a dynamic, market-driven issuance schedule that adjusts inflation rates based on staking participation to improve economic efficiency and security. (However, this proposal failed to achieve the required two-thirds supermajority in the March 2025 vote and has not yet been initiated.)

While these changes focus on coordinating incentive mechanisms, they also intensify competition among validators, prompting them to seek new external revenue sources, which is particularly important when MEV and priority fee opportunities diminish during bear markets.

The ongoing evolution of Solana's market structure lays the foundation for Raiku's orchestration engine, designed to achieve reliable, predictable, and high-performance decentralized execution.

The benefits of this execution and consensus separation are profound.

First is predictable inclusion: typically, a user's transaction might linger in the mempool or queue, hoping to be included in the next block (or discarded due to a surge in load), while Raiku's design aims to provide hard guarantees on inclusion and timing. Transactions submitted through Raiku can receive "pre" inclusion confirmations, essentially reserving them in the upcoming block. This is achieved through Raiku's novel scheduling and auction mechanisms (which we will discuss later). For users and dApp developers, this means no longer needing to send spam transactions or anxiously await whether a critical transaction will be mined; you can know within milliseconds whether your transaction is scheduled for a specific time slot in the future. This focus on deterministic and predictable execution is its key differentiator. Traditional L2s on Ethereum can improve fees and throughput, but they often cannot accurately guarantee when transactions will reach L1 (especially for challenging Optimistic Rollups). In contrast, Raiku provides time slot guarantees on Solana, which is known for its 400-millisecond block time. Raiku essentially extends Solana through a "global scheduler," allowing applications to leverage this scheduler to reserve block space.

Another major advantage is fault isolation. In a monolithic L1, if one application (like a popular NFT minting program) suddenly consumes a lot of resources or crashes, it can degrade or halt the entire chain. We have seen this on Solana, where the workload of one dApp can slow down the entire network. With Raiku, applications can run in isolated execution zones (also known as edge computing). If one of these zones encounters issues, such as an out-of-control program consuming too much compute, it will not directly block Solana's main chain or other zones. Faults are contained within that extension environment. Solana's consensus remains unaffected, and other extensions continue to operate normally. This fault isolation is akin to having multiple "sandboxes" on the network: each application (or group of applications) can use dedicated capacity segments and even have custom parameters without jeopardizing overall stability.

Crucially, Raiku's architecture retains the goals of security and sovereignty pursued by both L1 and L2. Each Raiku extension environment possesses execution sovereignty, meaning application developers can customize execution logic, virtual machines, and parameters according to their needs (in this sense, it is their "own chain"), but they do not need to build a new set of miners or validators from scratch. Raiku leverages a network of validators that work in sync with Solana's validator set. In practice, Raiku validators will be Solana validators that choose to run Raiku software (the validator client's Sidecar) and may earn additional fees as a result. This means that from day one, security is specialized and robust, with an experienced set of validators at the helm, and there is no need to use separate tokens for security.

By separating consensus (still responsible for final blocks by Solana's PoH/PoS mechanism) from execution (handled by Raiku's scheduling and validator network), throughput is significantly enhanced. Solana no longer needs to execute every instruction of every program personally; it can outsource the execution of certain programs to Raiku extensions, only needing to verify the results or proofs.

In summary, Raiku is neither an independent L1 nor a typical L2; it is Solana's execution layer, introducing:

• (a) Separation of execution from consensus (liberating applications from L1's throughput limitations),
• (b) Predictable inclusion and scheduling (eliminating probabilistic mempool games), and,
• (c) Strong fault isolation (a problem in one extension does not threaten the whole)

It transforms Solana from a single-layer network into a multi-layer system: a base layer for consensus and global state, and an upper layer for high-performance application-specific execution.

Inside the Raiku Tech Stack: Deterministic Settlement and Modular Execution

To deliver on its promises, Raiku introduces several novel components and transaction types. These components and transaction types can be seen as building blocks of infrastructure that work together to enhance Solana. Let’s analyze the key elements of the Raiku tech stack:

1. Pre-block Auctions and Inclusion Signals:

At the core of Raiku is a new way of managing block space. Raiku discards the temporary first-come-first-served mempool model and instead implements a slot auction market. Applications or users can bid in advance for upcoming slots on Solana (or more precisely, for Raiku-coordinated scheduling), ensuring priority for their transactions. Winning bidders receive "inclusion signals" in advance, effectively guaranteeing that their transactions (or transaction bundles) will be included in specific future blocks or sequences of blocks. These auctions are stake-weighted and atomic, meaning scheduling follows the distribution of Solana's stakes (validators with more stakes have greater capacity to include reserved transactions, thus coordinating the incentive mechanism), and transactions can be reserved in bundles and executed in order without interruption. The result is that Raiku users can now receive confirmations faster because their execution "tickets" are guaranteed.

Comparing this to traditional experiences: on Ethereum, you send a transaction and hope miners pick it up quickly (if you are in a hurry, you might raise the fees), and even on Solana, you might send multiple transactions to ensure one gets through during congestion.

With Raiku, the entire process is like pre-booking a train seat, avoiding the need to jostle on a crowded platform. The system significantly reduces transaction failure rates and uncertainty, and one of Raiku's core goals is to guarantee transaction execution.

Streaming Proofs: Unlocking Large Payload Execution through Sequential Block Space

A fundamental limitation of Solana today is the strict block data constraints designed to ensure fast block propagation. For applications that need to submit large numbers of state updates (like settlement engines or ZK rollup proofs), this can become a bottleneck.

Raiku addresses this issue through sequential block space reservation, a concept realized by its Ahead of Time (AOT) block auction model. By reserving a series of upcoming block spaces, applications can reliably transmit large proofs or payloads in smaller, verifiable block forms without hitting Solana's single-block capacity limits.

The idea is to break down large transactions or proofs into smaller blocks for streaming and verification across multiple time slots, thus bypassing Solana's strict per-block data limits. In practice, this means applications can submit very large state updates or proofs (like zero-knowledge proofs or batches of hundreds of transactions) through Raiku, which will input this data into Solana in forms that validators can handle.

Applications can schedule and transmit structured data across multiple slots, while validators process and verify it in a controlled manner, rather than submitting large transactions that risk failure or inflation.

2. Fast and Deterministic Settlement ("Guaranteed Execution"):

Many of the next-generation applications that Solana aims to support, such as high-frequency trading platforms, real-time gaming systems, and institutional payment networks, require strict guarantees that transactions will land accurately at the expected time and place. In these areas, execution uncertainty is not just a user experience flaw; it is a transaction failure.

Unpredictable network congestion and transaction pool dynamics can lead to transaction failures, reordering, or delays. For advanced use cases like automated liquidations, synchronized asset exchanges, or arbitrage strategies, this unpredictability can result in missed opportunities and inefficient capital.

Raiku addresses this issue by guaranteeing transaction inclusion through Ahead of Time (AOT) and Just-in-Time (JIT) reserved time slots. For example, bots operating based on real-time price movements may prefer JIT inclusion, while external systems may opt for pre-scheduled AOT slots. In both cases, users need to pay for the precision of timing and bandwidth (using a combination of Raiku tokens and SOL).

When a guaranteed inclusion transaction is submitted through Raiku, it is assigned a reserved execution window to ensure it is processed at the scheduled time and will not be lost or reordered due to validator behavior or network congestion. While only the slot leader can include transactions, all validators running Raiku Sidecar will propagate and confirm the transaction arrangements in advance. Raiku uses a pre-consensus scheduling system to coordinate transaction plans, which are then executed by the slot leader during block production.

By pre-reserving block space and allocating deterministic execution time slots, Raiku can alleviate peak failure scenarios; historically, the failure rate for high-frequency users on Solana has exceeded 90%. Even during extreme loads, it can provide guaranteed bandwidth, precise latency, and predictable settlement.

The guaranteed execution mechanism is also designed to introduce MEV resistance. Since transactions are pre-arranged and confirmed across the network, it can reduce front-running and offset sandwich attacks by incorporating expected value extraction into the auction mechanism itself. Private order flow trading that previously operated outside the protocol is no longer necessary. Instead, the inclusion of order flow will be conducted transparently through fair scheduling auctions or reservation systems.

3. Global Account Model and Unified State:

One of Raiku's most groundbreaking aspects is its global account module. This component (planned for rollout in V2 alongside streaming proofs) directly addresses the issue of state fragmentation. Its concept allows users and applications to maintain a unified identity and state across multiple execution environments.

In practice, users will still have a Solana wallet/address for the main Layer 1 and any Raiku extensions they interact with. Assets and data can move seamlessly between the main chain and extensions without the need for traditional "bridging." The global account model will enable composability across extensions, so two Raiku extensions can interoperate or access shared user states as needed.

This stands in stark contrast to typical L2 systems. In a typical L2 system, each rollup is like a closed garden, requiring bridges to transfer assets, and account/contract addresses may only be relevant to specific chains. Raiku's extensions are more like "zones" within the Solana ecosystem, so the user experience remains consistent. Developers can deploy in extension environments and still easily integrate with Solana's native programs or account sets.

For example, thanks to the unified account, orders placed in a Raiku-driven order book extension can settle into the user's Solana main wallet or be recognized by programs on Layer-1. Technically, this can be achieved by allowing Raiku to share Solana's account address space and signature verification or by establishing a mechanism for synchronizing state roots between extensions and Layer-1.

The end result is a solution to the state fragmentation problem, yielding a single composable state that includes multiple execution environments. As the Raiku team describes, this achieves composability across extension environments, which is something Ethereum Layer-2 (where all Layer-2s operate independently) and early Solana Rollup attempts could not achieve. This is a first-principles approach designed to ensure that scaling does not lead to the fragmentation of user bases or liquidity.

The global account module also supports multi-VM functionality. Raiku is not limited to Solana's native virtual machine (SVM); it can also host different virtual machines under the same coordination framework. In fact, Raiku aims to support EVM-compatible extensions, allowing projects from the Ethereum world to deploy their Solidity code as Solana extensions.

Mentioning that "projects like Arbitrum Orbit will deploy on Solana" indicates that Ethereum L3 or custom chains can effectively tap into Solana through Raiku. This is significant: it means Ethereum dApps can enjoy Solana's performance and user base without abandoning their codebase. All of this is made possible by the global account, allowing users to interact without switching wallets or bridging tokens; EVM extensions will recognize the same wallets (possibly through address derivation or mapping) and can utilize Solana's native assets.

This indicates that Raiku has a certain degree of layered node architecture: ordinary users/applications communicate with Ackermann nodes (or clusters), which then interact with validators to arrange execution. This is an interesting design that can scale input processing capabilities and ensure the system can handle surges in transactions by effectively distributing transactions among validators.

Conclusion

The emergence of Raiku marks a turning point for Solana and the entire blockchain architecture. It showcases a vision where decentralized networks can achieve reliability, speed, and flexibility—qualities that were once the exclusive domain of Web2 clouds or traditional financial systems. By introducing a coordination engine with deterministic execution, Raiku enables Solana to transcend the label of "just another L1" and become a true platform for mission-critical, high-performance applications.

Consider what this means for developers: building on Solana with Raiku is like building on scalable cloud services.

• Need more throughput? Just launch an extension and reserve the slots you need.
• Need custom execution logic or different virtual machines? Insert it as an edge computing zone.
• Concerned about user experience during peak times? Provide guaranteed transaction inclusion so users never see failed transactions again.

The developer experience is significantly enhanced. Developers can build with confidence, knowing that the infrastructure can meet the demands of their applications, rather than the other way around. The Solana base chain serves as a stable infrastructure, while Raiku provides flexible, programmable scaffolding to help them push the limits.

This has the potential to attract not only crypto-native developers but also those from Web2 who have strict performance requirements. They can confidently use Solana without worrying about network speeds degrading. In fact, Raiku can position Solana as the go-to platform for any application that requires decentralization and high throughput.

At the institutional level, Raiku may be the key to Solana being seriously adopted by enterprises. Banks, hedge funds, gaming companies, social media newcomers—all of these can ultimately build on-chain with peace of mind, as the performance and control they need are in place. Solana has already become one of the more institution-friendly blockchains (with companies like Jump investing in its technology); Raiku promises fine-grained execution control and high reliability, further enhancing Solana's appeal. Institutional-grade means 99.999% uptime, transaction deadlines, necessary privacy protections, compliance hooks—all of which Raiku can deliver (through isolated extensions, scheduling, etc.).

The journey has just begun; Raiku is currently in the testnet phase, with the mainnet planned to launch by the end of 2025, but the infrastructure and solutions are already in place. It addresses the pain points we listed at the beginning: scaling limitations (solved by increasing modular throughput), MEV exploitability (minimized through predictable ordering and auction mechanisms), re-staking challenges (avoided through more controllable methods), fragmented states (solved through global accounts), and performance issues (addressed through guaranteed inclusivity and fault isolation). Thus, Raiku is a holistic solution rather than a patchwork of fixes.

Click to learn about ChainCatcher's job openings