What Is Eclipse Blockchain? SVM Ethereum L2 Guide 2026

Imagine a blockchain that runs Solana's Virtual Machine for execution, settles transactions on Ethereum for security, stores data on Celestia, and verifies fraud proofs with RISC Zero zero-knowledge technology. That blockchain exists, and it is called Eclipse. Launched as Mainnet Beta in November 2024, Eclipse is the first general-purpose Layer 2 to run the Solana Virtual Machine (SVM) on top of Ethereum, and in 2026 it has become one of the most discussed modular rollup projects in crypto.

Eclipse occupies a strange position in the blockchain landscape. It looks like Solana when you use it (you connect with Backpack, swap on Solana-style AMMs, transactions confirm in sub-second blocks), but it inherits Ethereum's settlement guarantees, uses ETH as gas, and ties its security to canonical bridges. For developers, Solana programs written in Rust deploy almost unchanged. For users, it feels like Solana with Ethereum bridges. For the ecosystem, it is the clearest test yet of the thesis that the SVM is a superior execution layer for any chain, not just Solana itself.

In this guide, you will learn what Eclipse is, who is behind it, how its modular architecture combines four stacks (Solana for execution, Ethereum for settlement, Celestia for data availability, RISC Zero for fraud proofs), how to add Eclipse to your wallet, what dApps live there, how the ES token launch and airdrop work, and how Eclipse compares to Solana mainnet, Monad, and MegaETH.

What Is Eclipse Blockchain?

Eclipse is a general-purpose Ethereum Layer 2 rollup that uses the Solana Virtual Machine for execution while settling on Ethereum, with Celestia for data availability and RISC Zero for zero-knowledge fraud proofs. It is the first production SVM rollup, lets developers deploy Solana programs almost unchanged, uses ETH as the gas token, and offers sub-second finality with fees orders of magnitude cheaper than EVM Layer 2s.

That paragraph is dense, so let us unpack the key idea. A traditional Ethereum Layer 2 like Arbitrum, Optimism, or Base uses the Ethereum Virtual Machine (EVM) for execution. It runs Solidity smart contracts the same way Ethereum mainnet does, just on its own faster chain. Eclipse breaks this pattern. It throws away the EVM as the execution engine and replaces it with the Solana Virtual Machine, which processes transactions in parallel rather than sequentially. The result is a Layer 2 that feels nothing like Arbitrum and everything like Solana, but anchored to Ethereum's security.

This is what people mean when they call Eclipse a modular rollup. Instead of bundling execution, settlement, and data availability into a single monolithic design, Eclipse picks the best component for each role. Solana wins on execution because the SVM is parallel and fast. Ethereum wins on settlement because it has the most economic security of any chain. Celestia wins on data availability because it offers cheap, scalable blob storage. RISC Zero provides the cryptographic glue that lets Ethereum verify what happened on the Eclipse SVM through zero-knowledge proofs.

The Story Behind Eclipse: Founders and Backers

Eclipse Labs was founded by Neel Somani in 2022. Before Eclipse, Somani worked as a software engineer at Citadel and Airbnb and researched modular blockchain design. His thesis: the SVM is the best general-purpose execution environment for a Layer 2, but no one had built it that way because the Solana and Ethereum communities historically saw themselves as competitors rather than complementary stacks.

Somani assembled engineers from Solana Labs, Jump Crypto, and various L2 startups. Eclipse raised over $65 million across multiple rounds led by Polychain Capital and Tabula. The cap table includes Anatoly Yakovenko (co-founder of Solana), Hasu (researcher and Flashbots strategy lead), Tribe Capital, Maven 11, and Delphi Ventures. Having both Anatoly and Hasu on the cap table signals that the Solana camp and the Ethereum-aligned modular camp both see strategic value in Eclipse.

The project had a turbulent leadership transition in mid-2024 when Somani temporarily stepped down amid internal disputes, but he returned by year-end and Eclipse pushed forward to Mainnet Beta launch in November 2024. Since then, the focus has been growing native dApps, onboarding bridge liquidity, and preparing the ES token launch.

The Modular Architecture: Four Stacks Working Together

Eclipse's design is the clearest example of modular blockchain composition in production. Most chains try to do everything themselves. Eclipse delegates each major function to whichever protocol does it best, then stitches them together.

Solana Virtual Machine for Execution

The SVM powers Solana mainnet. It is famous for parallel transaction execution through Sealevel, and an account-based model where transactions declare exactly which state they will touch, so non-conflicting transactions can run simultaneously. The EVM, by contrast, executes transactions one at a time. This is why Solana can process tens of thousands of TPS while EVM L2s top out at a few thousand.

Eclipse takes the SVM almost verbatim. Solana programs written in Rust with Anchor deploy to Eclipse with minimal changes. Tooling like the Solana CLI, web3.js, and Backpack work out of the box. Most new L2s force builders to learn a new toolchain. Eclipse plugs into the Solana developer ecosystem and inherits years of accumulated tooling.

Ethereum for Settlement

Settlement is where Eclipse posts state commitments and where the canonical bridge lives. When you bridge ETH from Ethereum mainnet, your ETH locks in a contract on Ethereum and an equivalent amount appears on Eclipse. When you bridge back, a withdrawal is initiated and after the fraud proof window expires, ETH unlocks on Ethereum. Same pattern as Arbitrum, adapted for an SVM execution environment.

Because settlement happens on Ethereum, Eclipse inherits Ethereum's economic security for finalized funds. This is why Eclipse is an L2 rather than a separate chain like Solana mainnet. If the Eclipse sequencer fails catastrophically, users can recover funds via the Ethereum-side bridge contracts, assuming the fraud proof system functions.

Celestia for Data Availability

Data availability (DA) is the often-overlooked third leg of any rollup. Every rollup must publish enough transaction data somewhere that anyone can reconstruct chain state independently. Without DA, a malicious sequencer could withhold data and prevent users from challenging fraud or exiting.

Eclipse posts transaction data to Celestia rather than Ethereum, the same modular DA approach used by Manta Pacific and Mantle. Celestia's blob storage is dramatically cheaper than Ethereum calldata or even EIP-4844 blobs, a major reason Eclipse fees are fractions of a cent. The tradeoff: Celestia's economic security is smaller than Ethereum's, so users place some trust in Celestia validators to keep historical data available.

RISC Zero for Zero-Knowledge Fraud Proofs

This is the most technically novel piece. Eclipse is optimistic-ish: transactions are valid by default, but challenges are allowed. Instead of replaying the disputed transaction step by step on Ethereum (expensive and slow for SVM execution), Eclipse uses RISC Zero to generate a zero-knowledge proof showing the disputed state transition is incorrect. The Ethereum contract only verifies the ZK proof.

This hybrid design gives Eclipse optimistic-rollup developer ergonomics (no need to write ZK-friendly versions of every SVM operation) while keeping on-chain verification cheap. RISC Zero's general-purpose zkVM makes it practical because it can produce proofs for arbitrary Rust code, which is exactly what Solana programs are.

Why SVM on Ethereum? The Performance Case

The argument for SVM on Ethereum boils down to performance versus security. Solana mainnet is fast but has suffered network outages and is seen as having weaker decentralization than Ethereum. EVM L2s are secure (they inherit Ethereum's guarantees) but their execution is fundamentally sequential.

Eclipse splits the difference: Solana-class execution performance (sub-second blocks, parallel processing, fractions-of-a-cent fees) plus Ethereum-class settlement security. This is the SVM-on-Ethereum thesis. Solana's runtime is too good not to use, but Ethereum's security is too valuable to leave behind.

Theoretical TPS numbers always assume idealized conditions, and real-world throughput is lower. What matters is whether the chain stays responsive under load, and Eclipse's SVM-based design has structural advantages because parallel execution scales better than sequential execution.

ETH as the Gas Token (Not a Native Coin)

A strategically important choice was to use ETH as the gas token, not a custom asset. When you pay fees on Eclipse, you are paying in ETH bridged from mainnet. This aligns Eclipse with the broader Ethereum economic stack, where ETH burned or paid as fees on L2s benefits the long-term ETH narrative.

This contrasts with Solana, where SOL captures all fee value within its ecosystem. By using ETH, Eclipse signals that it is fundamentally an Ethereum L2, not a competing chain. It also simplifies onboarding: anyone holding ETH can use Eclipse without acquiring a new asset just to pay gas, a friction point that bedevils chains like Solana and Sui.

Stablecoins mostly come through canonical bridges. USDC is supported via Circle's CCTP. Other stablecoins like USDT are bridged via Hyperlane. The mix of native ETH gas plus canonical stablecoin bridges keeps liquidity flowing between Eclipse and the rest of the Ethereum L2 stack.

The Eclipse Ecosystem: Native dApps in 2026

An L2 is only as useful as its applications. Eclipse spent 2024 and 2025 building out a portfolio of native and ported dApps, and by 2026 the ecosystem covers DEXs, lending, perpetuals, infrastructure, and consumer apps.

Eclipse also hosts ports of major Solana protocols. The Solana ecosystem's permissive licensing means many DeFi primitives are available as forks tuned to Eclipse. Rather than build the DeFi stack from scratch, Eclipse can bring in mature protocols and adapt them.

Bridging to Eclipse: Hyperlane and the Canonical Bridge

The canonical bridge is the official Eclipse bridge for ETH and core assets. It locks tokens on Ethereum and mints them on Eclipse. Deposits are processed within minutes. Withdrawals go through a fraud proof challenge window (hours to days during Mainnet Beta). This is the trust-minimized path: you only trust the Eclipse and Ethereum protocols themselves.

Hyperlane is the third-party interoperability protocol used for additional assets, especially stablecoins from chains like Solana or Arbitrum. Hyperlane is faster but adds trust in its validator set. For daily activity, Hyperlane handles stablecoins quickly while the canonical bridge handles larger ETH transfers where settlement guarantees matter more.

If you have used 1inch or other DEX aggregators, the experience will feel familiar. The destination address is in Solana format (base58), not Ethereum hex format, which trips up new users.

The ES Token: Airdrop, Tide Points, and Drift Drop

Eclipse's native ecosystem token is called ES. At the time of writing, the token has not launched, but the airdrop framework is public. The launch is planned alongside the move from Mainnet Beta to full mainnet during 2026.

The airdrop has two main mechanisms. Tide points is an on-chain program that rewards users who bridge to Eclipse, provide liquidity to native DEXs and lending markets, trade on perp platforms like Plasma, and use other ecosystem dApps. Points accrue based on TVL contribution and trading volume, and convert to ES allocations at the airdrop event.

The Drift Drop snapshot is a cross-chain airdrop targeted at Drift Protocol users on Solana mainnet, designed to bootstrap initial Eclipse usage by rewarding active Drift traders with ES at launch. Similar in spirit to Optimism and Arbitrum airdrops, adapted for the SVM cohort.

A word of caution: the ES launch has not happened yet, so anyone claiming to sell ES tokens or offering early allocation is running a scam. Treat any "Eclipse airdrop" link from outside the official domain as suspicious by default. The same address poisoning and phishing techniques that target other ecosystems are heavily active around Eclipse.

How to Use Eclipse: Step-by-Step Guide

Using Eclipse for the first time is straightforward if you already have Ethereum experience. Here is the full flow from zero to swapping on a native DEX.

One gotcha: the Eclipse address format is base58 (looks like a Solana address), while the Ethereum-side bridge contract uses your Ethereum hex address. Never paste an Ethereum address into a Solana-format field or vice versa. Funds sent to the wrong format are typically unrecoverable. Always copy and paste directly from the bridge interface to minimize manual transcription errors.

Eclipse vs Solana Mainnet: Sovereign vs Settled

Why use Eclipse when Solana mainnet has the same execution environment? The answer comes down to where you place security trust and how you think about long-term ecosystem alignment.

Solana mainnet is a sovereign chain. It produces its own blocks, its validator set is independent, and SOL captures all economic value from fees and staking. It has stronger network effects, deeper liquidity, and far more dApps than Eclipse. It also has historical reliability concerns and relies entirely on its own validator set rather than inheriting from a larger chain.

Eclipse is a settled L2. Security depends on Ethereum, Celestia, and RISC Zero. ETH is the gas token. The sequencer is centralized in Mainnet Beta. The ecosystem is much smaller. In exchange, you get Ethereum settlement guarantees, ETH-aligned tokenomics, and the modular architecture story.

For developers, the question is whether your dApp benefits more from Ethereum economic security and ETH-aligned liquidity, or from Solana's deeper ecosystem. For users, the question is whether Eclipse's Ethereum security alignment outweighs the smaller ecosystem and L2 withdrawal challenge windows.

Eclipse vs Monad and MegaETH: SVM vs Custom EVM

Eclipse is one of several high-throughput chains competing for attention in 2026. The most direct comparisons are Monad and MegaETH, both EVM-native.

Monad is a sovereign L1 that rebuilds the EVM from scratch with parallel execution, optimized state access, and faster consensus. EVM-compatible at the bytecode level. The bet: keep the entire Ethereum developer ecosystem while delivering Solana-class performance.

MegaETH is an Ethereum L2 with similar parallel-EVM ambitions, targeting 10ms block times. Uses Ethereum for settlement and EigenDA for data availability, positioning itself as the EVM answer to high-frequency on-chain applications.

Eclipse takes the opposite bet: don't make the EVM faster, just use the SVM, which is already parallel and fast. The tradeoff is Rust instead of Solidity. The advantage is that the SVM is battle-tested at scale.

None of these projects has decisively won. Each represents a different theory of how to scale Ethereum-aligned blockchains. Eclipse's distinguishing claim is that it does not require rewriting any virtual machine. The SVM works, the tooling exists, and Solana has proven it scales. The job is just plugging it into the Ethereum security stack.

Decentralization Roadmap and Validators

In Mainnet Beta, Eclipse runs a single sequencer operated by Eclipse Labs. This is the same starting point as Arbitrum and Optimism in their early days, and the most common criticism leveled at L2s.

The roadmap moves Eclipse toward a decentralized sequencer set over time. Step one: make the sequencer permissionless for reading state and submitting transactions, while still centralized in block production. Step two: rotate sequencer duty among approved operators. Long term: a permissionless sequencer market, potentially using a leader-based consensus algorithm or a shared sequencer network like Espresso.

In parallel, Eclipse has discussed letting ETH-aligned operators validate Eclipse state through restaking, similar to how some L2s plan to use EigenLayer. The exact design is not finalized, but the direction is clear: Eclipse will not remain a single-sequencer chain forever, and decentralization milestones are tied to the move from Mainnet Beta to full mainnet.

Risks and Tradeoffs

Eclipse is technically ambitious and that ambition comes with risk. Anyone using Eclipse should understand the failure modes clearly before depositing significant funds.

The multi-stack dependency deserves emphasis. Eclipse depends on four protocols working correctly. If Ethereum fees spike, Eclipse settlement costs go up. If Celestia experiences a DA failure, Eclipse cannot post valid blocks. If RISC Zero has a bug, fraud proofs may misbehave. Each protocol is strong individually, but composing them creates new failure surfaces.

By comparison, a monolithic chain like Solana mainnet has one failure mode. Eclipse has four. That is the inherent tradeoff of modular design: best of each component, union of their risks.

How Eclipse Fits the Modular Blockchain Thesis

Eclipse is also a demonstration of the modular blockchain thesis. The thesis says monolithic designs (one chain does everything) are fundamentally limited, and the future belongs to chains that pick specialized components and compose them.

Ethereum itself moved this way with its rollup-centric roadmap. EIP-4844 added blob storage for L2 DA needs. Restaking protocols like EigenLayer let security be rented across chains. Shared sequencers, intent layers, and zk co-processors are all parts of the modular vision. Eclipse is one of the cleanest end-to-end implementations of this vision in production.

If the modular thesis is correct, more chains will look like Eclipse over time: one execution environment optimized for performance, one settlement layer optimized for security, a DA layer optimized for cost, and a proving system optimized for verification. Eclipse may not be the final winner, but it will be remembered as one of the earliest and most aggressive bets on the modular future.

Eclipse and the Broader L2 Landscape

Eclipse competes with EVM L2s like Arbitrum, Optimism, and Base on TVL and attention. The differentiator is performance and developer experience. EVM L2s offer the largest developer ecosystem and deepest liquidity, but their execution model is sequential. Eclipse offers a structurally different model that scales better, but requires Rust development and has a smaller ecosystem.

Eclipse also interacts interestingly with restaking economies. Native Eclipse infrastructure can be secured by ETH stakers through restaking, letting the chain piggyback on Ethereum's economic security without bootstrapping its own validator economy. This contrasts with chains like NEAR Protocol and Sui, which had to bootstrap their own stake economies (a slower process).

Developer Experience: Building on Eclipse

For developers, Eclipse offers the Solana toolchain on top of Ethereum settlement. Write your program in Rust with Anchor, compile to BPF bytecode, deploy via the Solana CLI pointed at the Eclipse RPC endpoint. dApps interact through the same web3.js or Solana SDK libraries you would use on Solana.

Wallet integration is the big difference. Backpack is the gold standard because it speaks both SVM (Eclipse and Solana) and EVM (Ethereum bridging). Other wallets are adding Eclipse support, but Backpack is the smoothest experience today.

Porting a Solana mainnet program is usually minimal: change the RPC endpoint, recompile against any Eclipse-specific dependencies, redeploy. Some programs depending on mainnet-specific features may need adaptation. Most do not. Pyth Network oracle support, for example, is being extended to Eclipse.

Pros and Cons of Eclipse

Security Practices for Eclipse Users

Because Eclipse is a young chain in the middle of an airdrop hunt, it is a heavy target for phishing and scam attempts. A few practical security habits will save you from most common attacks.

Always reach Eclipse-affiliated apps through eclipse.xyz or the project's verified official social accounts. Bookmark URLs once you have verified them. Watch out for sponsored ads in search results that impersonate Eclipse, Solar, Save, or other native dApps. Scammers regularly buy ads under official-looking domain names and drain wallets via signature requests.

Use a separate burner wallet for early ecosystem activity if you are point farming. A burner wallet strategy isolates the funds you put at risk and keeps your main holdings safe in a hardware wallet. Never sign blind transaction requests in unknown dApps, and learn how to read transaction simulations before approving.

Be especially careful with bridge transactions. Always double-check the destination address format. Eclipse uses base58 addresses (Solana style), while the Ethereum side of the bridge uses hex. Sending to the wrong format on a different chain is usually unrecoverable. For best practices, see our general crypto wallet security tips and the guide on address poisoning attacks.

Future Outlook: What to Watch in 2026 and Beyond

Several events will determine Eclipse's trajectory over the next 12 to 24 months. The most important is the move from Mainnet Beta to full mainnet, expected to coincide with the ES token launch. That moment finalizes tokenomics, decentralization roadmap, and validator economy.

Sequencer decentralization is second. As long as Eclipse runs a single sequencer, it is structurally similar to a centralized chain with Ethereum-backed exits. The L2 thesis depends on moving toward a permissionless sequencer set with strong liveness and censorship-resistance properties.

Ecosystem growth is third. Eclipse needs more native dApps and more bridged liquidity. The current set (Solar, Save, Plasma Finance, Wireshark, Underdog) covers basics, but the chain needs flagship apps that pull users in for their own sake, not just airdrop farming. L2 ecosystem maturity typically takes 18-36 months from launch.

Competition is fourth. Monad's eventual mainnet, MegaETH's progress, and continued evolution of Solana mainnet all affect Eclipse's position. If Monad delivers a high-performance EVM L1 with strong traction, Eclipse's value proposition becomes contested. If Solana keeps gaining share and reliability, the "use Solana directly" argument strengthens.

Frequently Asked Questions

Conclusion: Eclipse as the SVM-on-Ethereum Bet

Eclipse represents one of the boldest bets in modular blockchain design. It rejects the assumption that an Ethereum L2 has to use the EVM, and instead pairs Solana's proven execution environment with Ethereum's settlement security, Celestia's data availability, and RISC Zero's zero-knowledge proving. The result is a chain that performs like Solana while inheriting Ethereum's economic guarantees, and that lets Solana-native developers deploy to Ethereum-aligned infrastructure with minimal friction.

Whether Eclipse becomes a dominant L2 or one of several interesting experiments depends on factors that will play out over the next 12 to 24 months. The ES token launch, the sequencer decentralization roadmap, the maturation of native dApps like Solar and Plasma Finance, and the broader competition with Monad, MegaETH, and Solana mainnet will all matter. So will the success of the underlying modular components, particularly Celestia and RISC Zero, which Eclipse depends on for its security model.

For users today, Eclipse is worth exploring as both an active product (cheap and fast Ethereum-aligned chain with growing dApps) and as a potential airdrop opportunity through Tide points and the Drift Drop snapshot. For developers, Eclipse is the easiest way to deploy SVM programs into an Ethereum-secured environment without rewriting code. For ecosystem watchers, Eclipse is one of the most interesting tests yet of the modular blockchain thesis, and whether or not it wins, the lessons from its design choices will shape how the next generation of rollups is built.

If you are starting out, the right path is to install Backpack, bridge a small amount of ETH, swap on Solar, deposit into Save, and observe how the SVM feels under real fees and real finality. The chain rewards firsthand experience more than reading about it, and the gap between theoretical descriptions and what it actually feels like to use Eclipse is large enough that no amount of articles (including this one) fully bridges it.

Related Guides

• Tezos (XTZ) Explained: Self-Amending Blockchain
• Sui Network Architecture: Object-Centric Design, Parallel Execution and DeFi Apps (2026)
• What Is Sui? Move-Based L1 and SUI Guide 2026
• What Is Stellar (XLM)? Cross-Border Payments Guide
• How Blockchain Sharding Works: Parallelization, Throughput and Design Tradeoffs (2026)