6 Innovations That Make MagicBlock the Real-Time Engine for Solana

Solana redefined what's possible for high-performance blockchains, delivering speed, composability, and low fees at internet scale. Yet a large class of applications still has constraints: onchain social, high-frequency trading, real-time money-based games, and privacy-first apps to name a few.

Historically, developers building these applications write the application logic offchain on traditional servers and rely on Solana for liquidity or asset issuance.

MagicBlock was created to entirely replace the traditional server stack and enable a "Zero-to-one" experience that can benefit from the global liquidity and composability of Solana. Rather than building a general-purpose rollup with bridges and fragmented liquidity, MagicBlock extends Solana's execution capabilities on demand through Ephemeral Rollups (ERs), high-performance SVM runtimes that operate on specific delegated accounts while maintaining programs and state on Solana.

Ephemeral Rollups are capable of sub-50ms latency, elastic TPS through horizontal scaling, gasless execution, and on-demand privacy, all while preserving access to Solana's unified liquidity and state.

There are 6 core innovations that are part of the novel architecture that make this possible:

• Just-In-Time State Cloning for efficient state delegation and synchronization

• Dynamic Node Colocation for dynamic geographic provisioning for minimal latency

• Runtime Plugins to customize the execution runtime on demand

• Magic Router for intelligent transaction routing across ER instances

• Magic Actions, composable post-commit execution on the base layer

• Private Ephemeral Rollups, TEE-backed confidential execution with compliance controls

In this article, we'll go over each of the above. For implementation details, refer to the MagicBlock documentation.‍

Just-In-Time State Cloning

Traditional appchains require developers to redeploy smart contracts and attract liquidity, forcing users to bridge, toggle between different RPCs in their wallet, or use different tools altogether. MagicBlock takes a different approach by letting programs delegate specific Solana accounts to an Ephemeral Rollup. Any account can be delegated to an Ephemeral Rollup validator via the Delegation Program. The ER clones delegated accounts only when first accessed. During the session, transactions execute at sub-50ms latency while the account remains readable on Solana L1. State is committed back to Solana programmatically. As a result, assets never leave Solana, users don’t have to bridge, and programs maintain native composability.

Dynamic Colocation

Network latency is constrained by physics (a Tokyo-to-New York round trip adds ~150–200 ms) before any computation occurs. MagicBlock addresses this through dynamic colocation, provisioning Ephemeral Runtimes in geographic proximity to users.

Regional validators operate across Asia, Europe, United States, and wherever users are. The containerized validator weighs less than 50MB, so it’s fast to warm up, and it can start executing transactions in 1-3ms. The result is end-to-end latency under 50ms wherever users are.

Runtime Plugins & Customizations

‍General-purpose blockchains provide a one-size-fits-all runtime, so applications inherit the same execution rules and constraints.

MagicBlock's ERs support runtime customizations, like automations, privileged accounts, sequencing rules, or more relaxed limitations of the execution environment.

Examples include:

• Cranks to enable automated, time-based execution without manual intervention, like periodic state updates for game mechanics or DeFi operations

• Oracles to ingest price feeds at 50ms intervals, without paying for transactions. The architecture supports arbitrary data sources, available by default and for free.

• Sequencing to support FCFS ordering logic or introduce priority fees if desired.

Magic Router

Magic Router eliminates RPC integration complexity through automatic transaction routing. When an account is delegated, Magic Router matches the request with the closest execution environment. Subsequent write instructions to the delegated state will be sent to the active node operator in charge of that session.

Users sign transactions with existing wallets, unaware of the underlying routing. Developers can incrementally adopt Ephemeral Rollups without re-architecting applications.

Magic Actions

Magic Actions enable developers to attach instruction handlers that execute automatically on Solana's base layer immediately after an ER commit. The committed state becomes available as inputs, enabling multi-step workflows spanning both environments in a single atomic operation.

This unlocks state synchronization, cross-program composition, automated workflows, and event-driven actions, all while maintaining access to Solana’s state.

Private Ephemeral Rollups

There are several approaches to onchain privacy: ZK proofs, FHE, MPC, and TEEs. Each one comes with tradeoffs. MagicBlock's Private Ephemeral Rollups combine the JIT-cloning and blazing-fast SVM of “vanilla” ERs with Intel TDX’s architecture to achieve private state transitions that are high-performance, easy to implement, and compliant.

By running the ER validator inside a TEE, MagicBlock provides hardware-secured enclaves that prevent interference even by the host OS, and achieves confidentiality with near-native performance and a familiar developer UX. Accounts are public unless programs explicitly define access rules.

Private ERs enforce additional compliance safeguards: jurisdiction controls via IP geofencing, real-time AML/sanctions screening, and an onchain access control so developers can specify exactly who can read/write over the delegated private state. Businesses get confidential execution while preserving performance and composability with Solana.

Summary

As a result of these 6 innovations, MagicBlock provides a real-time engine that extends Solana's capabilities without fragmenting its ecosystem. State delegation enables transparent movement between execution environments. Geographic colocation eliminates network latency. Runtime plugins bring crank, real-time oracle, and sequencing customization without appchains. Magic Router abstracts routing complexity from developers. Magic Actions maintain composability between ER and Solana. Private Ephemeral Rollups enable confidential execution with institutional-grade compliance.

The system is designed to get out of the way and let users interact with apps that have the same look and feel of Web2. No bridges, no new tokens, no fragmented liquidity. Just faster execution where needed, with the full Solana ecosystem still a CPI call away.

For a deeper explanation of these innovations and implementation guides, refer to the documentation:

• Delegation, Commitment & Undelegation — state lifecycle management

• Magic Router — intelligent transaction routing

• Cranks — automated scheduled execution

• Oracles — real-time data feeds

• Magic Actions — post-commit execution

• Private Ephemeral Rollups — TEE-backed confidential execution

‍