The debate over whether Solana should embrace modularity—through Layer 2s (L2s), rollups, or application-specific chains (appchains)—has gained significant momentum, especially after Vibhu, founder of DRiP (Solana’s top consumer app), publicly argued that Solana urgently needs rollups. His reasoning? Soaring SOL prices and persistent network congestion have cost DRiP nearly $20,000 per week in lost value.
As Solana’s ecosystem grows, so do the trade-offs:
- Pros: Increased liquidity, capital inflow, and composability-driven transaction volume.
- Cons: Soaring infrastructure costs, degraded user experience, and network congestion.
DRiP, which distributes millions of free NFTs from top artists to thousands of wallets weekly, relies on Solana purely as infrastructure. It doesn’t benefit much from composability, making it disproportionately vulnerable to rising fees and latency.
Vibhu pointed out: “Composability has diminishing returns.” Behind closed doors, many Solana developers are now discussing the need for rollups—not just for scalability, but to:
- Increase transaction throughput and reduce block space competition
- Lower transaction fees
- Retain more of the economic value their apps generate
Recent congestion spikes—from JUP airdrops to ORE mining and memecoin mania—have exposed the limits of Solana’s monolithic architecture. While Firedancer promises future scalability, its timeline remains uncertain, and even then, it may only deliver 10x improvements. For now, Solana stands as one of the last major chains still operating as a single, unified layer.
So, should Solana stay monolithic—or evolve into a modular ecosystem with L2s and appchains? Let’s break it down.
👉 Discover how the next wave of blockchain innovation is shaping up on Solana.
The Reality of Solana’s Congestion Problem
Solana has faced repeated congestion events, leading to:
- High latency
- Increased transaction failure rates
- Skyrocketing priority fees
Despite this, Solana consistently handles 1,000–2,000 TPS, surpassing the combined throughput of all EVM chains. This is a good problem to have—it validates demand—but it also tests the limits of its monolithic design.
The Solana Foundation has urged projects to optimize performance by:
- Using priority fees to avoid delays
- Reducing compute unit (CU) consumption
- Leveraging stake-weighted Quality of Service (QoS) to prioritize user transactions
Yet these are stopgap measures. A more fundamental fix is coming: a new transaction scheduler, expected in the v1.18 release (April 2025). This scheduler will run alongside the current one, allowing validators to monitor performance and roll back if needed. It aims to pack blocks more efficiently, addressing bottlenecks in the existing system.
Anza, a spin-off from Solana Labs, is also tackling congestion at the protocol level—particularly issues tied to QUIC implementation and how Agave (Solana’s validator client) handles traffic surges.
While Anza and Solana Labs focus on vertical scaling—optimizing base layer throughput and latency—the door remains open for horizontal scaling via rollups. In fact, Solana’s ultra-fast block times (~400ms) make it an ideal settlement or data availability (DA) layer for L2s. This hybrid future—where Solana powers both monolithic execution and modular rollups—is not only possible but increasingly likely.
The Path to a Modular Solana
Modularity for Solana is no longer theoretical—it’s underway. Anza engineers are working to decouple the SVM (Solana Virtual Machine) from the validator client. This separation will allow:
- Easy forking of SVM for custom chains
- Independent SVM runtimes
- Plug-and-play development of appchains
Joe C, an Anza engineer, outlined plans to modularize SVM by extracting the transaction processing pipeline and embedding it within SVM itself. This means developers could run SVM instances without relying on validators—opening the door to sovereign chains built on Solana’s execution layer.
The goal? A modular, composable stack where:
- Appchains handle specialized workloads
- Rollups batch and settle data on Solana
- Developers pick and choose components (e.g., using Firedancer’s validator logic or Agave’s runtime)
👉 See how developers are building the next generation of scalable dApps on Solana.
Solana Appchains: Specialized Chains for Specific Use Cases
Appchains—also known as SVM forks—are independent chains built using Solana’s codebase but tailored for specific applications. Unlike general-purpose L1s, they optimize for speed, cost, or control.
Types of Solana Appchains
- Permissionless: Open to anyone (like mainnet)
- Permissioned: Designed for institutions (e.g., “Solana Permissioned Environments” or SPEs)
Notable Examples
Pythnet: The first major SVM appchain. Pyth forked Solana to create a dedicated network for high-frequency price feeds. By moving off mainnet, it avoids congestion and internalizes costs—saving millions in fees. Pythnet uses a proof-of-authority model and processes 10–20% of what used to be mainnet traffic.
Cube Exchange: A hybrid CEX deploying a sovereign SVM chain with an off-chain order book but on-chain settlement—ideal for high-frequency trading.
Potential Use Cases
- Perpetual DEXs: Like Hyperliquid, these could run as standalone chains with custom logic (e.g., native stop-loss execution).
- AI & DePIN: Projects like Akash use Cosmos appchains; similar models could emerge on SVM.
- Governance Chains: MakerDAO’s interest in an SVM-based governance chain highlights demand for dedicated coordination layers.
- Enterprise Chains: BlackRock, Visa, or CBDCs could run private SVM instances.
- Gaming Chains: A casino project on Solana is exploring its own appchain for low-latency gameplay.
- Optimized Forks: Just as Monad parallelizes EVM, someone could build a faster SVM variant.
Connecting the Appchain Ecosystem
Appchains only work if they can communicate. Inspired by:
- Avalanche Subnets (via Warp Messaging)
- Cosmos IBC
- Polygon AggLayer (ZK-proof aggregation)
Solana could develop a native messaging layer or middleware—akin to Cosmos SDK—that bundles RPCs (Helius), oracles (Pyth), and bridges (Wormhole) into a unified appchain toolkit.
While appchains don’t directly boost SOL value (they don’t pay gas in SOL unless re-staking), they strengthen the SVM ecosystem effect. More forks mean more demand for SVM tooling, talent, and infrastructure—making SVM itself more valuable.
Solana Layer 2s and Rollups: The Rise of RollApps
Solana L2s—often called RollApps—are application-specific rollups that post data to Solana’s DA layer and inherit its security.
Key Differences from Ethereum L2s
| Aspect | Ethereum L2s | Solana RollApps |
|---|---|---|
| Origin | Top-down (Ethereum Foundation-led) | Bottom-up (driven by app demand) |
| User Experience | Often visible as separate chains | Abstracted; feel like Solana |
| Motivation | Scalability due to high fees | Performance & value capture |
Are Compressed Transactions Equivalent to Rollups?
Not quite. True rollups execute off-chain, batch data, compress it, and post it to L1 with validity or fraud proofs. State compression helps—but isn’t a full rollup. That said, Grass L2 plans to use state compression as part of its ZK rollup design.
Live Examples
GetCode: A payment SDK using a pseudo-rollup model. It creates payment intents, sequences them off-chain, and settles batches on Solana. Benefits include instant payments (even during congestion) and enhanced privacy.
MagicBlocks’ Ephemeral Rollups (ER): Designed for games, ER splits game state into clusters and processes them on temporary SVM runtimes. Benefits:
- Gasless transactions
- Faster block times
- Built-in tick mechanisms
- Full compatibility with Solana tooling
Upcoming RollApps
- Grass: A DePIN project needing 1M+ web requests/sec. It will use ZK proofs and batch data to Solana mainnet.
- Zeta: A legacy perp DEX moving matching off-chain via rollup.
- Sonic’s Hypergrid: A modular SVM chain for games.
- Neon: EVM-compatible L2 on Solana.
- Eclipse & NitroVM: SVM-based Ethereum rollups.
- Molecule: Conceptual SVM Bitcoin L2.
- Sovereign SDK: Build Optimistic/ZK rollups from Rust code—now supports Solana.
👉 Explore how RollApps are redefining scalability on emerging blockchains.
Why Rollups Align with SOL’s Value
Just as Ethereum’s narrative boosted ETH through “ETH alignment” (via L2s and EigenLayer), Solana’s community will rally behind anything that increases SOL’s utility. If rollups or appchains require SOL for security (e.g., re-staking), they directly boost demand for SOL.
Projects like Cambrian, Picaso, and Solayer are early players in this space. LST platforms like Jito (via Stakenet/Sanctum) and validators also stand to gain from increased staking demand.
Will Rollups Feel Like Solana?
Absolutely. Like Base or Arbitrum feel like Ethereum extensions, most Solana RollApps will offer:
- Same wallet addresses
- Native SOL gas
- Instant bridging
- Seamless UX
Users won’t know they’re on an L2—and that’s the point.
Appchain vs. Rollup vs. Mainnet: What’s Best?
It depends:
- Mainnet: Best for apps needing composability (e.g., DEXs, yield protocols)
- Appchain/Rollup: Ideal for apps needing control, privacy, or custom logic (e.g., DRiP, Grass)
- Hybrid Models: Use mainnet for settlement, L2 for execution
DRiP, having achieved escape velocity as Solana’s top consumer app, could easily migrate to its own chain—capturing more value and improving UX.
Infrastructure Supporting the Modular Future
As appchains and rollups grow, infrastructure providers will thrive:
- Caldera: Could enter SVM market
- Sovereign SDK: Already building Solana adapter
- Helius: Well-positioned for L2 RPCs
- Rome Protocol: Shared sequencer for atomicity
- Tinydancer: Lightweight clients
- Wallets: Phantom, Backpack, Solflare
- Smart Wallets: Squads (for multi-sig & contract accounts)
Final Thoughts: Can Solana Handle Global Scale?
No single chain can. Even with hardware advances, not every transaction belongs on mainnet. Low-value actions—like DRiP’s NFT drops—should move off-chain. High-value, composable transactions—like spot trades—should stay.
Solana isn’t losing the monolithic vs. modular debate. Instead, it’s evolving into a hybrid: a high-performance core layer anchoring a constellation of specialized chains.
The question isn’t if Solana needs L2s and appchains—it’s how fast they’ll arrive.
Frequently Asked Questions
Q: Do appchains pay gas in SOL?
A: Not necessarily. Unless they re-stake SOL for security, they may use their own token. However, integration with SOL-based staking can align incentives.
Q: Are Solana rollups like Ethereum’s?
A: No. Ethereum’s are top-down and standardized; Solana’s are bottom-up and application-driven, often abstracted from users.
Q: Can I build a rollup on Solana today?
A: Yes—with tools like Sovereign SDK or Caldera (adapting to SVM). Production deployments are emerging in 2025.
Q: Will appchains fragment liquidity?
A: Potentially. But shared sequencers (e.g., Rome Protocol) and bridges can mitigate this by enabling cross-chain atomicity.
Q: Is Firedancer enough to solve scalability?
A: It helps—but likely not enough. Horizontal scaling via rollups is still needed for specialized workloads.
Q: Does modularity weaken Solana’s composability?
A: Only if not designed well. With strong messaging layers (like IBC or Warp), composability can extend across chains.