Solana Plugins: Modular Extensions for Your Solana App

Blockchains are user-driven systems. Nothing happens unless someone signs and submits a transaction. If a price needs updating, someone has to submit a transaction. If a loan goes underwater, someone has to trigger the liquidation. If a game needs to tick forward, someone has to push the button. Every action requires an external actor. Additionally, every program shares the same execution environment.

There's no way to customize the execution environment or relax the runtime limitations to accommodate the needs of an app. 

What are Solana Plugins?

Solana Plugins are modular, app-specific extensions that add powerful new capabilities to Solana applications. Think of them as a custom toolkit: plug in what you need, when you need it. Solana Plugins eliminate that tradeoff between a general-purpose runtime and an app-specific environment. 

Examples of plugins available today are:

• Native cranks
• Real-time price streams
• AI oracles
• Verifiable Randomness 

with more coming next.

Native cranks for scheduled execution

On Solana, there's no native way to schedule a transaction. Something as simple as incrementing a counter every five minutes is impossible without offchain infrastructure. Game loops? Auction countdowns? Auto-compounding vaults? Subscription renewals? Same problem.

MagicBlock's Validator crank plugin solves this. Cranks are automated, scheduled tasks that execute onchain instructions at predetermined intervals without anyone manually triggering them. Developers schedule a task through a Cross-Program Invocation (CPI) to MagicBlock's scheduling program, specifying what to run and how often. The Ephemeral Rollup handles all scheduling and execution from there.

What this unlocks is significant. Game loops where NPCs move, resources regenerate, and time-based events fire. Periodic settlements for clearing houses, batch processing, and escrow releases. Auto-compounding DeFi strategies that reinvest without anyone clicking a button. Timed auctions that actually count down onchain. Subscription systems with recurring payments and no offchain infrastructure.

Basically anything that needs "do X every Y seconds" without trusting some offchain service to stay online. They execute inside the Ephemeral Rollup with the same verifiability as any manually submitted transaction. The automation and the guarantees are onchain. 

Real-time price streams & AI Oracles

Getting external data onchain has always meant relying on oracle networks that push updates at whatever cadence they've chosen. The problem is that 1) on Solana, the best accuracy can be once per slot, roughly every 400ms, and 2) every account update needs to pay a transaction fee, like any other user-submitted transaction.   

MagicBlock's Pricing Oracle plugin takes a different approach. By ingesting data feeds directly into the Ephemeral Rollup's execution environment, price updates land at <10ms intervals, or about 40x faster than typical slot times. MagicBlock partnered with Pyth Pro to enable out-of-the-box price streams for 2800+ assets across crypto, stocks, commodities, prediction markets, and more. The architecture supports arbitrary data sources, so you are not vendor locked with one single provider.

For liquidation engines, copy-trading systems, or any latency-sensitive financial application, sub-50ms oracle updates aren't just marginal improvements.

Pricing oracles are not the only option. AI Oracles let developers call AI models from their programs, opening up a design space that's barely been explored. This is already possible today, with our reference example that brings AI capabilities directly into smart contract logic. Imagine NPC behavior in autonomous games, dynamic content generation, onchain risk assessment, all executing within the same trust model as the rest of your application.

Verifiable Randomness: provably fair, fully onchain

Generating true randomness on a blockchain is hard. Blockchains are public, deterministic, and adversarial. You can't just sample from a blockhash or timestamp; if there's enough money on the line, validators can simulate outcomes during their leader slot and only publish the block when the result goes their way. Without proper randomness, any onchain game, lottery, or selection mechanism is compromised at the foundation.

MagicBlock's VRF (Verifiable Random Function) plugin solves this end-to-end, onchain. Your program submits a request via CPI to MagicBlock's VRF program. An independent oracle generates the randomness and returns the result along with a cryptographic proof. The VRF program verifies the proof onchain. If it doesn't check out, the result is discarded before it ever reaches your application. 

Players can't manipulate the result because the randomness is generated outside their program and delivered via callback. The oracle can't cheat because the cryptographic proof must verify against a commitment hash that the player locked in before the randomness was generated. Even collusion between a player and the oracle fails: the commitment is sealed before the dice are rolled.

VRF is available on Solana mainnet, but combined with Ephemeral Rollups, the performance changes too. Co-locating VRF oracles with your ER dramatically reduces latency, and the entire flow executes in a single transaction.

Verifiable randomness is a useful primitive that unlocks plenty of use cases with guarantees that no centralized server could offer.

What's coming next

These plugins are just the beginning. Because developers control the execution environment, any capability they need can be embedded directly into the runtime. The upcoming roadmap includes:

Custom Sequencing: fine-tuned transaction ordering for applications that need priority and predictability in how their transactions are processed.

Highly Precise Clock: hyper-accurate, time-based logic for applications that need more granularity than standard slot timing.

The plugin architecture is designed to be extensible. As developers discover new needs, new plugins can be built to meet them.

Why this matters

The common thread across all of these plugins is simple: they eliminate the difference between building onchain and offchain.

We want to enable any application to be built onchain, with the same affordances of servers but additional verifiability, composability, and persistence. That’s the bet behind Solana Plugins: keep developers on Solana, keep liquidity and composability intact, and still give builders the knobs they normally only get by launching an appchain. The design space is wide open.

You don't have to choose between performance and composability. With Solana Plugins, you get both.

Ready to build? Check out the docs and start building with Cranks, Oracles, or VRFs.