The Solana Developer Stack
A Comprehensive Guide to Developer Tooling on Solana
7,625 new developers. 46% growth in GitHub commits. 162 million daily transactions.
Solana’s developer ecosystem in 2025 is not just growing, it’s accelerating. It now leads all Layer 1s in attracting new developers, surpassing Ethereum in early-stage adoption and builder activity.
Daily transaction volume now exceeds 162 million, with average fees staying well below one cent. The network has maintained over 15 months of uninterrupted uptime. Global institutions like Stripe, Visa, and Google Cloud have gone live on Solana, while ecosystem-native tools like Helius, Jupiter, and Drift now handle billions in value daily.
New developer tooling isn’t lagging behind this growth, it’s driving it. The rise in GitHub commit activity reflects deeper team engagement, more production deployments, and faster iteration cycles.
But developer activity doesn’t happen because of blockspace or hype alone. It happens when the tools work. A modern framework lowers the barrier to writing programs safely. A modular SDK makes frontend integration clean. Frameworks lower the barrier to writing programs safely. SDKs make frontend integration clean. Simulation tools let teams test mainnet conditions before deploying. These systems compound: better abstractions reduce cognitive load, better testing infra reduces risk, and better RPCs reduce support tickets.
This deep dive explores the developer stack powering that shift, from smart contract frameworks like Anchor and Seahorse, to client SDKs like Umi and Kinobi, to infra tools like Surfpool and Helius. It’s not just a list of tools, but a look at how they shape the way people build, where things work, where they break, and where there’s still room to improve.
Core Layers of the Solana Developer Stack
Programming Frameworks
Solana offers multiple entry points for developers building smart contracts, each tailored to a different language ecosystem. Whether you're coming from Rust, Python, Solidity, or JavaScript, there’s a framework or compiler designed to meet you where you are. These tools don’t just help you to structure logic, test safely, and integrate with the rest of the Solana stack.
Anchor
Anchor is still the backbone of serious smart contract development on Solana. It wraps the raw Solana programming model in developer-friendly abstractions, with Rust macros that handle account validation, serialization, and security patterns out of the box. The CLI scaffolds projects and automates deployment to Devnet or localnet. Built-in testing is a core strength, that allow developers to spin up a local validator and write unit tests in Rust that mirror production behavior.
What makes Anchor powerful is safety and it’s velocity. By reducing boilerplate, enforcing structure, and integrating with tools like Umi and Kinobi, Anchor compresses the time from prototype to mainnet. It’s the de facto framework for production dApps like Jupiter, Mango, and MarginFi, and will likely remain the default path for Rust-native builders.
Seahorse
Seahorse brings Solana programming to Python developers. Built on top of Anchor, it compiles Python syntax into intermediate Rust programs, letting Pythonistas write smart contracts without jumping into Rust directly. It’s still in beta and not yet production-ready, but it shows real promise for education, prototyping, and expanding Solana’s accessibility.
Seahorse supports custom account annotations, compile-time type safety, and local testing via pytest. Its tight integration with Anchor means developers can transition to production-grade workflows once they’re ready to scale. If the framework matures and improves error handling, it could become a real on-ramp for Python-heavy teams or universities exploring Solana.
Solang
Solang is a Solidity-to-Solana compiler designed to lower the barrier for EVM-native developers. It supports Solidity 0.8 syntax and compiles to Solana BPF bytecode, enabling teams to reuse their existing contracts and mental models while targeting Solana’s architecture. PDAs, bumps, and Solana-specific memory constraints are abstracted via annotations and codegen.
If Solana wants to attract Ethereum teams without forcing them to retool everything, Solang can be the translator. It’s still evolving, but for Solidity-native teams testing the waters, Solang is increasingly viable.
Pinocchio
Pinocchio is a zero-dependency Rust library optimized for compute unit efficiency. It skips the solana-program crate entirely and provides macros like entrypoint! and no_allocator! for tight, low-level control. The trade-off is complexity. There are no built-in validations, no testing framework, and you’re manually parsing accounts. It's ideal for seasoned teams optimizing CU costs or fitting into tight runtime budgets, not for first-time builders or rapid prototyping.
How to Build Solana Programs with Pinocchio - Helius
Solana’s smart contract layer has remained remarkably unified compared to Ethereum, which has splintered into a complex ecosystem of L2s, alt-EVMs, and tooling silos. That’s largely because Solana offers a single high-performance runtime (Sealevel), one monolithic execution environment, and a dominant framework in Anchor. Instead of choosing between competing dev stacks, Solana teams mostly follow a common structure, with Anchor, or tools that compile to Anchor-compatible IDLs like Seahorse and Solang. This reduces divergence in testing, client SDKs, and deployment flows.
The network’s design also plays a role: Solana scales at Layer 1, so there’s no need to build across multiple chains or manage fragmented state. That said, fragmentation risk is not zero, especially as alternative frameworks mature. But for now, a shared runtime, shared conventions, and a “build-on-one-chain” mindset have kept the dev stack tight and cohesive.
Local Development & Testing
Local development on Solana is getting better, but it’s far from seamless. Tools have improved dramatically since the early days of solana-test-validator, but the experience still depends heavily on which stack a developer chooses and how deep they’re willing to go. There's now a clear spectrum: from low-level command-line control to full mainnet mirroring, to in-browser prototyping. But UX is not uniform, and the gaps between tools can be jarring.
Solana CLI and Test Validator
This is the foundational setup, the Solana CLI combined with a local validator. It gives developers full control to simulate the blockchain locally, manage accounts, deploy programs, and run basic tests. But it’s a raw experience. Beginners often hit roadblocks setting it up, debugging errors, or managing conflicting versions. It remains a critical tool, especially for projects with custom setups, but it’s low-level by nature and lacks guardrails.
Surfpool
Surfpool is emerging as a real alternative to the traditional test validator. It mirrors mainnet accounts in local environments, supports cheatcodes, and even comes with a faucet for test funds. You can simulate realistic conditions on a Raspberry Pi, get UI-based visibility into your runtime state, and iterate faster. It’s a game-changer for teams doing integration testing or debugging live interactions, but it’s still maturing and doesn’t fully handle contention or adversarial cases like MEV.
Surfpool is the best first touch point for developers building on Web3 using Solana.
Solana Surfpool Developer Guide - Helius
Solana Playground (by LamportDAO)
Solana Playground strips it all down: no installs, no setup.
Solana Playground is the browser-based IDE maintained by LamportDAO, a community initiative dedicated to onboarding new developers into the Solana ecosystem through education, tooling, and open-source contributions.
Playground abstracts away the friction of setting up a local Solana environment. There’s no need to install Rust, Anchor, or the CLI. You just open your browser, write your program (Rust + Anchor or Seahorse), and deploy to Devnet. Phantom wallet support is built in, and real-time logs with stack traces help you quickly debug.
The tool is ideal for learning, prototyping, and teaching. Newcomers can get a taste of Solana programming in minutes, and instructors use it for workshops and hackathons. Anchor templates and Seahorse scaffolds are preloaded, and you can fork, edit, and deploy everything entirely from the browser.
That said, it’s intentionally lightweight. Solana Playground is not designed for complex dApps or end-to-end testing. It lacks support for custom tooling, external dependencies, or persistent local state, so serious developers will quickly graduate to using local validators and full IDEs.
Still, as a teaching tool and low-friction prototyping environment, it plays a vital role. LamportDAO’s stewardship ensures it stays up to date with new framework versions and remains one of the most accessible entry points into Solana development.
Client SDKs & Codegen
Solana’s performance isn’t just a function of throughput or fees, it’s a function of how cleanly developers can bridge their programs to real users. That’s where client SDKs and codegen tools come in.
These tools abstract the complexity of working with accounts, instructions, and serialization formats. Whether you're building a token minter, trading UI, or backend bot, these SDKs offer safer, faster, and more composable ways to interact with Solana programs. The shift toward type-safe codegen, modular JavaScript clients, and domain-specific SDKs reflects a growing maturity in the ecosystem, one where developer experience matters as much as raw execution speed.
Umi
Umi is a modern JavaScript framework for building Solana clients, created by Metaplex. It introduces a modular, tree-shakable architecture that allows developers to compose functionality using plugins, while only shipping the code they need. Umi is zero-dependency by default and exposes clean interfaces for connecting wallets, signing transactions, managing uploads, and interacting with programs.
It’s built around the idea of composability. Developers instantiate a Umi object and “use” plugins for identity management, file storage, transaction building, etc. This design is intuitive and scales from hobby projects to full-blown production dApps. Its plugin model also enables community extensions without bloating core logic.
Umi shines in NFT workflows. The mpl-token-metadata and mpl-core plugins, for instance, offer clean interfaces for creating and managing NFT metadata. Its TypeScript-first approach, support for keypair-based signing, and testing-friendly architecture make it ideal for projects that value reliability and speed in client-side execution. Projects like LaunchMyNFT and community tools around Candy Machine v3 already leverage Umi as their default frontend layer.
If you're building JavaScript-heavy apps with on-chain interactions, especially involving tokens or NFTs, Umi provides a smoother experience than raw web3.js. Its only drawback: the learning curve around its plugin system and some advanced usage patterns can be steep for newcomers.
Kinobi
Kinobi is the codegen engine behind Umi’s ecosystem. Also built by Metaplex, it consumes program IDLs (typically from Anchor or Shank) and outputs Umi-compatible TypeScript client libraries. But it goes beyond basic client scaffolding, Kinobi introduces a visitor pattern that lets teams traverse and modify the internal abstract syntax tree before generating code, enabling high degrees of customization.
The generated clients include transaction builders, account serializers, deserializers, error handling, and program-specific helpers. Because Kinobi is designed to emit Umi-style interfaces, its output integrates natively with wallets and connection logic, creating a seamless developer workflow.
The tool is especially valuable for teams maintaining multiple on-chain programs, it allows them to regenerate clients automatically from IDL changes, enforce internal coding standards, or inject custom wrappers. Teams like Coral (backers of Backpack) have used Kinobi to manage their complex client codebases.
Kinobi is less visible than Umi, but arguably more critical. It enforces consistency across large TypeScript codebases, reduces the surface area for bugs in custom clients, and anchors the broader push toward type-safe, auto-generated interfaces for Solana programs. If Umi is the runtime, Kinobi is the compiler.
Solana.js and Solana-py
Solana Web3.js is the standard JavaScript/TypeScript library for interacting with Solana from the frontend. It's not a smart contract framework, but no dApp ships without it. Web3.js manages wallet connections, sends transactions, signs messages, and fetches on-chain data, which makes it the glue between smart contracts and real users.
The library continues to evolve: version 2.0 introduces better type safety, modular imports, and performance improvements. Most Anchor programs expose IDLs compatible with Web3.js, enabling apps to generate program clients automatically. Whether you’re building with React, Svelte, or custom UIs, this is the SDK that connects the dots.
On the Python side, solana-py fills a similar role. While not as feature-rich as Web3.js, it supports building bots, backend scripts, and trading infra. Combined with AnchorPy, it can interact with Anchor programs using familiar Pythonic syntax. It’s increasingly used by analysts, quants, and DeFi backend teams looking to automate operations without jumping into JS.
Protocol SDKs
Beyond general-purpose SDKs, Solana also has a growing set of protocol-specific libraries, purpose-built tools that expose domain-specific logic for leading DeFi platforms.
Jupiter SDK
Jupiter is Solana’s liquidity aggregator, the Uniswap Router equivalent, but multi-source and smart about routing. The Jupiter SDK lets teams fetch swap quotes, execute optimal routes, manage limit orders, and run DCA strategies via scheduled jobs. It powers bots, trading UIs, and yield tools. While still evolving, it’s already in use by projects building passive LP strategies and programmatic swap engines.
Drift SDK
Drift is a decentralized perpetuals exchange. Its SDKs expose low-level trading functions, funding rate calculations, margin account management, and liquidation logic. Used by automated traders and liquidation bots alike, Drift’s SDKs have become a blueprint for building vertically-integrated protocol APIs in the Solana ecosystem.
Mango SDK
Mango offers spot, perpetual, and lending markets, and its SDKs (in C++ and .NET) reflect that legacy. While less mainstream than Drift or Jupiter, Mango’s SDKs power institutional tools and algorithmic traders that need deep access to cross-margin accounts and risk modeling features. These SDKs aren’t plug-and-play, they require careful integration, but they’re proof that serious infrastructure is being built on Solana, and not just in JavaScript.
GameShift API
Solana’s high throughput and sub-second finality make it an attractive foundation for real-time games, but historically, the blockchain tooling landscape has been too fragmented or complex for traditional studios to adopt. That’s where GameShift, a developer platform from Solana Labs, steps in.
GameShift offers a turnkey API for integrating Web3 features like NFTs, payments, and in-game economies, no blockchain knowledge required. Designed for studios and developers coming from Unity or Unreal, it abstracts away key management, transaction signing, and smart contract plumbing. Developers get REST APIs to mint NFTs, embed non-custodial wallets, enable fiat/crypto payments, and even spin up branded in-game marketplaces.
Despite early confusion around custodianship, GameShift is non-custodial at its core. Players control their wallets generated silently using HSM-secured keys and approve all transactions themselves. What is managed under the hood is the payment flow: GameShift supports fiat onramps, credit card checkout, and international payouts, helping onboard non-crypto-native players with minimal friction.
Key capabilities
NFT Management: Mint, assign, and trade game assets using a high-level API, with metadata and rarity controls.
Non-Custodial Wallets: Embedded wallets that abstract key handling while preserving user control, provisioned seamlessly at onboarding.
Payment SDK: Built-in support for credit cards, crypto, and bank payouts with 100% chargeback protection and global coverage.
In-Game Marketplaces: Create branded storefronts where players can list assets in USDC, powered by Solana and cross-posted to platforms like Tensor.
Cloud Integration: Available on Google Cloud Marketplace, with support for BigQuery and Vertex AI, ideal for scaling analytics and content delivery.
The developer experience is web2-friendly, with no blockchain environment setup required. Game logic can live entirely off-chain, while asset ownership and transactions remain verifiable and composable on Solana. Studios like Earth from Another Sun are already leveraging GameShift to build dynamic economies that blend Web2 UX with Web3 ownership.
GameShift reflects a broader trend in Solana’s dev tooling: composable APIs for verticals like gaming, not just general-purpose frameworks. By pairing blockchain primitives with familiar developer workflows, it lowers the barrier to mainstream adoption without compromising on user sovereignty.
Why it matters: GameShift could become the Stripe+Firebase of Web3 gaming, giving developers production-grade tools for wallet onboarding, NFT commerce, and real-time economies, all on a performant Layer 1.
Wallet UX & Key Management
Solana’s Wallet Adapter remains the default method for connecting wallets to dApps and for good reason. Maintained by Anza, it’s a modular TypeScript library that provides plug-and-play adapters for wallets like Phantom, Solflare, Backpack, Glow, and more.
The library abstracts away the mess of individual wallet APIs and instead exposes a common interface for connection, signing, and account management. It also ships with React and Vue hooks, UI components, and auto-detection logic, streamlining frontend development across frameworks.
Recent updates have focused on DX polish: improved UI modals, reduced adapter weight, and better error handling. The June 2024 release, highlighted by community devs like SOLBigBrain, was widely praised for removing friction in wallet switching and initial onboarding. Discussions on Solana Stack Exchange consistently cite Wallet Adapter as a “best first step” for integrating with most Solana wallets.
However, it’s not perfect. Deep integrations often require wallet-specific overrides, and mobile support still has rough edges. A Rust version was open-sourced in late 2024, hinting at backend or embedded use cases, but adoption remains early.
Still, for the majority of dApps, especially those on web, Wallet Adapter is the backbone. Its composability, ecosystem adoption, and active maintenance have made it a pillar of the Solana DX.
Dialect SDK
Most Solana dApps today are fast and composable, but still silent. There’s little native infrastructure to message users, trigger alerts, or offer contextual actions like in-app trading, signing, or confirmations. Dialect fixes that.
The Dialect SDK is Solana’s wallet-native messaging and notification layer, a real-time communication protocol built directly into the chain. It enables developers to send personalized alerts about on-chain events, power peer-to-peer wallet messaging, and embed “Blinks” (blockchain links) that let users take action (swap, mint, vote) directly from a social post, email, or dApp UI.
It’s not just about UX. Dialect makes Solana dApps feel alive, reactive to events, contextual in messaging, and embedded in the user's daily workflows. A lending app can send a health check warning to your wallet inbox. A DAO can push a vote alert directly into Backpack. And a game can airdrop rewards with a single-click claim Blink, sharable on X or Discord.
Under the hood, Dialect is developer-friendly. It offers a TypeScript SDK, Solana-native pub-sub messaging, no-code dashboards for teams, and deep integrations with wallets like Phantom, Backpack, and Solflare. Blinks support Solana Actions, allowing complex transactions (like Jupiter swaps or NFT purchases) to be executed in just one click, even outside a wallet or dApp.
Features:
Wallet-native push notifications via dApp UI, mobile push, or email/SMS.
Secure wallet-to-wallet messaging without centralized infrastructure.
Blinks: one-click links for trading, minting, signing, or voting.
Pub-sub messaging using Solana PDAs as communication channels.
Fully open-source and modular SDKs with React components and alert APIs.
Cross-platform compatibility, including Chrome extension support.
Recent upgrades (e.g., Alerts Stack rewrite) have cut integration code by 80%, and major DeFi protocols like Drift, MarginFi, and Meteora are already using Dialect to push user-facing notifications. With over 30 integrated dApps and wallets, it’s becoming the default communication primitive for the Solana ecosystem.
Phantom Connect & Backpack
As wallets mature into full-blown platforms, many are going beyond the Wallet Adapter, offering their own SDKs, APIs, and developer platforms. This verticalization gives developers tighter control, advanced features, and ecosystem-specific capabilities.
Phantom Connect
Phantom’s SDK enables direct integration through its provider (window.phantom), bypassing Wallet Adapter for more granular control. It exposes signing methods, message verification, deeplink support, and session management for web and mobile.
Mobile support has expanded considerably. Phantom now supports universal links and app-to-app deeplinking, allowing seamless sign-in flows across platforms. The SDK is well-documented, with guides for React, React Native, and vanilla JavaScript. As of February 2025, it also offers better error introspection and analytics hooks.
Developers appreciate the low-latency performance and reliability. But the trade-off is lock-in: by skipping the Wallet Adapter, you're tied to Phantom’s API surface and its assumptions. For many production teams, especially those optimizing for Phantom-heavy user bases, this is worth it.
Backpack
Backpack, developed by Coral (the team behind Anchor and Mad Lads), takes a different approach. It reimagines the wallet as an app platform, complete with its own app format (xNFTs), renderer (react-xnft), and permission system.
In this model, the wallet isn't just a signing agent, it’s the runtime. xNFTs are executable NFTs that contain frontend code, deployed directly into the wallet. Think Chrome extensions, but composable and on-chain. Developers build using a specialized React framework, with sandboxed execution and inter-wallet communication.
The SDK allows token transfers, UI rendering, and integration with Solana programs, all within the Backpack runtime. It also offers SDKs for general dApp integration, but the real power lies in native xNFT experiences.
The challenge is the learning curve. xNFTs require new mental models, and documentation is still evolving. Mobile support is limited compared to Phantom. But for teams building wallet-native apps, games, identity tools, social apps, Backpack opens new design spaces that were not possible in traditional dApp/wallet separations.
This shift toward verticalized SDKs reflects a broader trend: wallets are no longer passive bridges. They’re ecosystems and developers are expected to choose which one they want to optimize for.
Access Control & Onchain Governance
As Solana matures into an ecosystem where institutions, DAOs, and developer teams deploy programs that control millions in value, basic wallet access is not enough. Fine-grained permissioning, multisig logic, and programmable policy enforcement are increasingly essential, not just for compliance, but for operational safety.
In this context, Squads v4 has emerged as the leading access control layer on Solana. It’s not a governance framework in the abstract sense, it’s a secure, production-ready system for managing treasuries, program authorities, token mints, validator ops, and more. The impact is real: over $600M in assets are now managed using Squads, across 100+ teams including Pyth, Jupiter, and Orca.
This section explores how Squads enables secure, flexible coordination through multisig infrastructure and how its feature set is driving the practical adoption of on-chain governance on Solana.
Squads v4
Squads v4 builds on the Squads Protocol, a formally verified smart contract wallet standard to provide modular multisig accounts with advanced permissions and policy logic. Each "Squad" is a shared on-chain account that supports role-based access, transaction thresholds, time-locks, and integrations with DeFi and governance platforms.
At its core, it’s a general-purpose multisig system. But unlike the legacy model of simple n-of-m approval, Squads adds rich organizational structure:
Proposers can draft and submit transactions.
Voters approve or reject proposals.
Executors finalize them on-chain.
This setup allows real-world teams to define safe workflows without sacrificing autonomy or speed. Treasury withdrawals, program upgrades, NFT mints, all actions can be gated behind role checks, spending limits, and optional time delays.
The UX is strong. Teams can configure Squads through the web app, no coding required. Power users can opt into the SquadsX browser extension, the first multisig wallet for Solana DeFi, which supports protocols like Maple and Orca. Transactions can even be gasless using a relayer, a crucial detail for non-technical signers or cold wallets.
Security is also taken seriously. Squads is formally verified by OtterSec and Certora, and audited by Neodyme and Trail of Bits. Code is immutable, upgrade keys are removed after deployment, and Address Lookup Tables (ALTs) are used to support complex transactions beyond the 32-account limit.
Real-World Use Cases
1. Treasury Operations
Teams use Squads to manage SOL, SPL tokens, and NFTs with full auditability and configurable permissions. Spending limits allow low-risk operations (e.g., daily ops funds) to proceed without full multisig approval, while large movements require consensus.
Example: A DeFi protocol holds $10M in a Squad. It sets a 3-of-5 threshold for treasury approvals, with one member authorized to withdraw up to $10K/day for grants.
Benefit: Eliminates single points of failure while keeping operations nimble.
2. Upgrade Guards
Program upgrades on Solana, while powerful, carry risk. Squads allows teams to transfer upgrade authority to a multisig, and apply time-locks on changes to allow audits, governance votes, or community feedback.
Example: An NFT marketplace uses Squads to gate upgrades with 4-of-7 approvals and a 24-hour delay.
Benefit: Prevents rogue deployments and adds human review into critical infrastructure updates.
3. DAO Governance
Squads integrates with Realms, Solana’s primary governance layer, to let DAOs execute proposals via multisig. It can also manage sub-DAOs, budget allocations, and token distributions using configurable rules.
Example: A $50M DAO sets up a Squad to hold funds. Community votes on Realms, and passed proposals are routed to Squads for secure execution.
Benefit: Provides decentralized, composable execution that aligns with on-chain governance outcomes.
Most blockchains treat access control as an afterthought, an upgrade_authority set once and forgotten. But in 2025, Solana projects are realizing that program safety, treasury governance, and infrastructure security require something more robust.
Squads is filling that gap. It doesn’t try to reinvent governance primitives, it just makes them programmable, usable, and secure. With gasless flows, role-based workflows, and seamless integration into the Solana developer stack, it offers real traction for teams building operational muscle on-chain.
Still, challenges remain: standardizing signing flows across multisigs, educating new teams on threat models, and reducing the learning curve. But the direction is clear, access control is becoming foundational.
As Solana scales and institutions enter, Squads’ role may grow beyond Solana itself. Its vision to become a “consensus layer for on-chain operations”, including cross-chain governance, hints at a broader future.
As Solana applications evolve past single-user wallets into more complex interactions, subscriptions, token gating, rentals, and multi-tiered access, new primitives are needed. Core asset security may rely on multisigs like Squads, but for dynamic, permissioned interactions with NFTs or compressed assets, composability layers like Cardinal played a foundational role.
Cardinal
Cardinal was one of Solana’s most thoughtful protocol efforts aimed at extending what NFTs could do. It treated NFTs not as static collectibles, but as programmable access passes capable of expiring, being revoked, leased, or locked. These mechanics enabled:
NFT Rentals
Lend NFTs while retaining revocation rights, which was critical for non-defaultable systems like in-game rentals or time-bound subscriptions.Pass-Based Permissions
Use NFTs as access tokens with expiration dates or usage limits, useful for events, memberships, or in-game unlocks.Token Locking
Lock SPL tokens or NFTs to enforce reward eligibility or prevent trading during certain conditions (e.g. staking windows).
Despite shutting down in 2023 due to macro conditions, Cardinal saw meaningful usage. Its SDK powered token gating in apps like Backpack and Jupiter, and many developers continue to fork its open-source primitives to build revocable token systems or usage-based NFTs.
There’s clearly room for a successor. A maintained, modular toolkit inspired by Cardinal’s design could formalize these patterns into a standard for NFT-based access control, especially useful as subscriptions, temporary roles, and in-game asset leasing gain traction across Solana.
Infrastructure & RPC Services
Solana’s developer ecosystem is not just fast at the program layer, it’s evolving fast at the infrastructure edge. Indexing, scalable backends, real-time event streaming, and low-latency RPCs are no longer optional for teams building in production. They’re mandatory.
This section covers the infrastructure tools that power the backbones of Solana applications today from real-time Firehose streams and RPC infra to node templates and developer-facing analytics layers. Together, they form the invisible scaffolding behind every dApp, NFT marketplace, DeFi protocol, and analytics dashboard.
Helius RPC & Firehose
Helius has become the backbone infrastructure provider for many of Solana’s most-used applications, offering a rich RPC layer with high-performance indexing, token/account APIs, DAS-standard metadata parsing, and real-time streaming. It processes over 250 million RPC requests per day with 99.99% uptime, powering tools like Backpack, Solflare, and Squads.
The standout feature is Helius’s event and transaction infrastructure: webhooks for real-time event monitoring, enhanced parsing APIs for complex Solana transactions, and streaming services like LaserStream that deliver low-latency, fault-tolerant gRPC-like access to live data. Firehose, while not always branded formally, refers to Helius’s ability to stream full on-chain state and transaction flows, critical for bots, games, indexers, or reactive apps.
Enterprise-grade support, SOC 2 compliance, and strong uptime guarantees make Helius the go-to RPC choice for teams that need reliability at scale.
QuickNode and Syndica
QuickNode and Syndica both offer RPC infrastructure-as-a-service, but with distinct flavors.
QuickNode provides globally distributed RPC endpoints optimized for low latency, powering more than half of all Solana projects. It’s fast, developer-friendly, and feature-rich, with tools like QuickAlerts (push notifications for on-chain events), Streams (real-time data pipes), and native support for Solana’s gRPC/Yellowstone extensions. USDC payments and strong documentation make it popular with US-based startups. Teams like Jupiter cite QuickNode’s infrastructure as key to their real-time interface.
Syndica takes a slightly more ambitious route, its ChainStream API offers developer-tunable real-time streaming, while its upcoming validator client “Sig” (written in Zig) is optimized for read-heavy workloads. It’s designed to handle high-RPS (reads per second) use cases like analytics dashboards, NFT metadata crawlers, and trading engines. Elastic node auto-scaling, observability tooling, and real production usage by teams like Star Atlas and Sniper reinforce its value.
Both offer analytics, dashboards, logs, and managed endpoints, making them ideal for projects that don’t want to manage validator hardware or scale RPCs themselves.
AWS Solana Blueprints
Not every developer wants to rely on third-party RPCs. That’s where AWS Solana Blueprints come in a collaboration between the Solana Foundation and AWS that offers pre-built infrastructure templates for deploying Solana nodes in Amazon environments.
These blueprints support multiple deployment modes: consensus validators, base RPC nodes (stateless), and extended RPC nodes (with indexing layers). Deployment can be triggered via CloudShell with minimal setup, thanks to infrastructure-as-code provisioning and integration with AWS monitoring, bandwidth tuning, and traffic optimization tools.
The result is a turnkey option for enterprises who want full control, cost optimization, and direct access to Solana’s ledger without the overhead of managing bare-metal infra. Solana is only the second blockchain after Ethereum to get first-party AWS blueprint support, a strong signal for institutional readiness.
SolanaFM
Beyond RPCs, developers need visibility. SolanaFM fill that role, offering modern explorer and analytics interfaces tailored to dApp teams, power users, and data scists.
SolanaFs grown from an indexer into a full-featured explorer with wallet labeling, token insights, and transaction parsing. It offers a clean, intuitive interface with developer APIs and GraphQL support, perfect for integrating block data into apps or dashboards. It recently crossed 1.2 million monthly visits and powers the Quantum Explorer product with multi-wallet tracking and social features.
Emerging Patterns and Tensions
Solana’s developer tooling landscape in 2025 is not just expanding, it’s stratifying. New standards are forming, UX expectations are rising, and some long-standing assumptions are being rethought. In this section, we examine the most notable patterns emerging across the developer stack, alongside the tensions they reveal.
Emerging Patterns
Account Abstraction Is Getting Real
After years of discussion, account abstraction (AA) on Solana is moving from theory to practice. New tools like Pinocchio and proposals like sRFC-30 are formalizing how wallets and programs can support richer transaction flows. Developers can now encode nonces, time windows, and modular execution logic in a standardized UserInstruction struct. It’s a foundational step toward mobile-friendly smart accounts, gasless experiences, and more expressive authorization. Combined with projects like Fuse from Squads, AA is quietly becoming a core primitive for wallet UX, without sacrificing Solana’s native account model.
Type-Safe SDKs Are the New Baseline
Umi and Kinobi (now Codama) are setting expectations around type safety. Instead of manually writing brittle JS wrappers, developers can auto-generate clients from IDL using language-agnostic definitions. These SDKs don’t just improve reliability, they boost onboarding, reduce support burden, and make Solana feel more modern. As more teams adopt Kinobi-generated Umi clients, type-safety is no longer a nice-to-have. It’s table stakes.
Zero-Install Tooling Is Taking Off
Solana Playground, Surfpool, and LamportDAO point toward a future where no setup is required to get started. Open a browser, load a template, and deploy to Devnet, all without touching a terminal. This shift is critical for onboarding students, hackathon teams, and Web2 devs who aren't ready to commit to local Rust environments. The browser becomes a real IDE, not just a sandbox. And for quick experiments, zero friction means higher throughput for prototyping.
AI & Mobile SDKs Are Expanding the Frontier
Early tools like CAVYAR (AI pair programming) and Saganize (mobile signing) are pushing Solana into new development domains. GameShift and Fuse show how devs are thinking beyond wallets, toward full mobile-native onchain experiences. This shift is not a hype. It’s a response to real usage: over $1B in app revenue and 200M+ daily transactions demand tools that support rapid iteration, mobile form factors, and hybrid stacks that blend onchain logic with offchain UX.
Unified CLIs, Tracing, and DevOps Simplicity
At the infrastructure layer, unified CLIs and tracing tools are starting to reduce the cognitive load of building. Solana’s RPC latency remains sub-10ms in most regions, and teams are spinning up private clusters in under an hour using AWS Solana Blueprints and webhook triggers. New pipelines combine real-time indexing (Helius Firehose) with triggers (QuickAlerts), making devops workflows composable and responsive.
Tensions and Frictions
Tool Siloing Is Still a Pain
Anchor, Seahorse, and Solang all have different toolchains, different documentation styles, and no shared IDE support. No unified linter, no standard debugging interface, and inconsistent test harnesses. This fragmentation slows teams down, especially when switching between programs or collaborating across ecosystems. The need for a cross-framework IDE experience with shared tracing, testing, and devtools is real and growing.
Mobile Still Lags in Core Tooling
Despite Solana’s mobile push, the tooling isn’t fully caught up. Most wallets don’t support offline signing. SDKs are early-stage or fragmented. Features like session keys, deep linking, or native push are being reimplemented app-by-app. Tools like Saganize help, but the ecosystem needs a more opinionated mobile stack, especially with the Seeker phone and Solana Mobile’s long-term bets.
Cross-Language Support Is Too Narrow
Rust and JavaScript dominate the dev experience, but that’s not enough to bring in the next wave. Seahorse is reviving interest in Python, and some Solang efforts are enabling Solidity, but tooling for these languages remains partial. There’s real opportunity to expand Kinobi/Codama to support Python or Go. Otherwise, developers from adjacent ecosystems face a steep and unnecessary learning curve.
Debugging and Observability Still Feel Undercooked
For a chain that moves fast, Solana’s debugging tools feel slow. There’s solana-ledger-tool, some lldb integrations, and CLI logs, but no modern observability stack. Tracing, formal verification, transaction replay, memory inspection, it’s all either manual or missing. The sheer transaction volume demands better infra here, especially for high-value programs. It’s no surprise that RFPs for historical state verification have emerged with $275K+ bounties. The need is acute.
Rapid Tooling Evolution Risks Fragmentation
Surfpool and Gill/Kit are replacing older tools. RPC stacks are diverging. Code that worked six months ago might be broken today because of updates to Solana’s core architecture (e.g. Alpenglow). In this environment, integration work becomes brittle. Without stronger conventions, shared interfaces, or backwards-compatible abstractions, teams risk spending more time chasing updates than shipping product.
Opportunities & RFP-Ready Ideas
Solana’s dev tooling scene is growing fast, but it’s also messy in places. Many tools feel half-built or disconnected. The fundamentals are here, but there’s plenty of room for sharper edges, tighter integrations, and a few missing pieces that would make a huge difference.
From debugging to mobile to cross-language support, this is a prime opportunity for builders and funders. Grants are open. The ecosystem is alive. What’s missing is someone willing to ship the glue and polish.
I tried to list some of the most obvious and high-leverage opportunities.
Tenderly for Solana
Solana still lacks a robust, visual debugger for smart contracts. Developers are stuck reading raw logs or digging through CLI output. Something like Tenderly (from Ethereum) could change this: runtime traces, call stack visualization, gas profiling, error mappings, packaged with a clean UI.
Right now, debugging complex Anchor or Solang programs is tedious. A single developer tool with smart simulations and logs would save thousands of hours across the ecosystem. Bonus points if it integrates directly with Helius or Surfpool.
Why it matters: Debugging is still a pain. Good logs shouldn’t require divine patience.
Anchor Debugging Toolkit
Anchor is dominant, but debugging in Anchor is rudimentary. You’re mostly limited to msg! macros and log reading. There’s no proper way to set breakpoints, inspect account diffs, or step through execution. A toolkit that adds local state diffs, transaction snapshots, and VSCode integration would be a game changer. Anchor has the most mindshare, but it lacks dev-friendly ergonomics.
Why it matters: Anchor made Solana development accessible. Now it needs to grow up.
Unified Dev Sandbox
There’s no one-stop shop for devs. Solana Playground is great for quick scripts, but not enough for production workflows. A unified sandbox that bundles Anchor, Surfpool (for mainnet-like testing), a faucet, wallet adapter, and frontend preview tools (React/Vite templates) would dramatically reduce setup friction. Think of it as Glitch or Replit, but for full-stack Solana apps. Web2 devs would feel at home.
Why it matters: Everyone’s building in fragments. Bring it together.
Umi-Style SDK Generators for Seahorse & Solang
Umi is fantastic for Rust-based programs, but if you’re writing contracts in Python (Seahorse) or Solidity (Solang), you’re out of luck. No type-safe client generators. No plug-and-play SDKs. Creating Umi-style generators for those languages would unlock broader access, especially for non-Rust teams. This is how you make Solana truly multilingual.
Why it matters: Don’t force everyone to write Rust if you want global dev adoption.
Mobile Dev Onboarding Kits (Seeker SDK)
Solana Mobile’s SDKs are promising, but the developer experience isn’t there yet. A full mobile onboarding kit: docs, code templates, push notifications, offline signing, wallet interactions would help teams build actual apps, not just demos. With the Seeker phone now in the wild, there’s a clear need for better tooling around Seed Vault, React Native Wallet Adapter, and Saganize.
Why it matters: You shipped a phone. Give devs what they need to use it properly.
Dev-Focused Analytics Dashboard
Solana has tons of raw data, but no good out-of-the-box analytics for developers. Projects either write custom Dune dashboards or fly blind. A developer-focused dashboard that tracks transaction flows, dropped txs, log emissions, and user behavior would help teams ship smarter and debug faster. Plug into Helius or Chaincrunch and visualize app usage meaningfully.
Why it matters: You can’t improve what you can’t see.
Final Thoughts
Solana’s developer tooling has matured. From smart contract frameworks to infra services, the ecosystem now covers most of what teams need to build production-ready applications. Anchor remains dominant, but alternatives like Seahorse and Solang are gaining traction. Tools like Umi, Kinobi, Surfpool, and Squads are no longer side projects, they’re core infrastructure.
That said, gaps remain. Debugging is still primitive. Mobile tooling is fragmented. And the lack of standardized patterns across languages and stacks can slow teams down. But for most builders, the fundamentals are in place: a fast chain, a growing set of modular tools, and a developer culture that values iteration over abstraction.
Solana’s next phase won’t be about inventing entirely new primitives, it’ll be about tightening integration, improving ergonomics, and filling the last few missing pieces that make building feel smooth end to end.
If the early years were about proving it’s possible, 2025 is about proving it’s sustainable.
References
2024 Crypto Developer Report - Crypto Developer Report
Solana gained highest share of new devs in 2024 - Blockworks
Things Solana Developer Must Know for Development - Rapid Innovation
Solana Ecosystem Report (H1 2025) - Helius
State of the Solana Ecosystem – Solana
Introducing Surfpool: A Solana Devnet Alternative – Helius Blog
GameShift Web3 Game Dev Podcast – Solana
What Solana Devs Can Look Forward to in 2024 - Solana
Cooking with Solana - Solana Cookbook
What's Coming For Solana In 2025? - Solana Compass
Best Tools for Solana Developers - GetBlock
Getting started with development on Solana - Rise in
(All other sources are cited in-line with hyperlinks.)