Articles & deep dives
Technical writing on Solana — programs, tooling, infrastructure, and the DevRel community.
Write for devrels.xyzOpenWallet (OWS): a local, policy-gated wallet for the agent era
Give an AI agent a wallet and you've given it your private key. OWS — MoonPay's open standard — keeps keys local in ~/.ows, gates every signature through a policy engine, and exposes a CLI, SDKs, and an MCP server. One seed, nine chains including Solana. The model.
The Arcium Explorer: a block explorer for a network you can't see into
How do you build a block explorer for a privacy network? The Arcium Explorer surfaces the topology of Arcium's confidential computing on Solana — computations, clusters, Arx nodes, MXEs — while the actual inputs and outputs stay encrypted. The line it draws between observable and secret.
Quantum-proofing Solana: what you can do today, and the migration path
Quantum computers don't break hashes — they break elliptic curves. That single fact shapes Solana's entire post-quantum roadmap: PDAs are already safe, Winternitz one-time signatures ship today via Winterwallet, and Falcon-512 plus bigger transactions finish the job. A walk through the threat model and the practical moves, building on Blueshift's research.
How an AI agent actually pays: x402, MCP, and agent wallets on Solana
An agent that can call any paid API on the open internet sounds great until you ask: whose money, and what stops it from draining the wallet? This is the practical wiring — x402 inside the MCP tool loop, the @x402/svm client, and the Solana agent wallets (Coinbase, Crossmint, Privy, SendAI) that enforce spend caps and allowlists.
Build an x402 seller on Solana (and when to run your own facilitator)
Delegating to a facilitator is one line. But to ship a real x402 seller you need to understand the v2 middleware, the Solana 'exact' scheme down to the instruction order, how replay protection actually works (blockhash + memo nonce), and when it's worth running your own facilitator instead of Coinbase's or PayAI's.
The agentic payments landscape: x402 vs AP2, MPP, L402, and Solana Pay
Everyone's racing to be the payment layer for AI agents, and the names blur together: x402, AP2, MPP, L402. They're not all competitors — some are settlement rails, one is an authorization layer, one is for humans at a checkout. Here's the map, what each is actually for, and why Solana ends up at the center of the settlement story.
What x402 is actually for: six agentic-payment patterns on Solana
x402 is easy to explain and easy to over-apply. The useful question isn't 'how does it work' but 'what is it actually good for' — and the answer is six recognizable patterns, each with real Solana deployments (Pay.sh, Exa, Venice, Helius). Plus the cases where you should reach for an API key instead.
Qlaster: shared-memory streaming when your Solana services share a host
Most Solana streaming assumes the consumer is somewhere else on the network, so it serializes and ships bytes over gRPC. But a lot of infra — RPC sidecars, indexers, MEV bots — runs on the same host as the validator. Qlaster is a Rust system that fans account/tx updates over shared-memory rings instead of sockets: zero-copy, eventfd-driven, SCM_RIGHTS fd passing. A look at the design.
solana.new: an AI-native CLI from idea to raise
Most Solana scaffolds stop at 'here's a dApp template.' solana.new goes further — a Claude-powered CLI that takes you from 500+ vetted ideas through code generation, GTM copy, and a pitch deck, backed by curated catalogs of repos, skills, and MCPs. One curl command. What it actually installs.
web3.js 3.0: the classic API, rebuilt on Kit — Solana's TypeScript reunion
Solana's TypeScript ecosystem fractured: web3.js v1, then the Kit rewrite, then Gill and Kite wrappers — and choice paralysis. web3.js 3.0 is the convergence move: the API everyone already knows, rebuilt on Kit's modern internals. What it actually is, with the package facts the announcement leaves out.
Stables: a stablecoin payments API that treats Solana as a settlement rail
Moving USDC between a bank account and a Solana wallet means KYC, FX quotes, sanctions screening, and settlement plumbing nobody wants to build. Stables wraps all of it behind a REST API — customers, quotes, transfers, virtual accounts, webhooks — with Solana as one of ten settlement rails. A protocol-level look.
Alpenglow: Solana's new consensus, and the end of Proof of History
Alpenglow is the biggest change to Solana's core in its history: it retires Proof of History and TowerBFT for a new consensus — Votor for finality, Rotor for propagation — targeting ~150ms finality. SIMD-0326 passed governance with 98% yes. What it actually does, and what breaks.
ZK Compression: cheaper accounts on Solana (and why it's not cNFTs)
State compression gave Solana cheap NFTs. ZK Compression generalises the idea to arbitrary accounts and tokens — ~100× cheaper, secured by a constant-size validity proof verified on-chain. The catch is compute. A developer's-eye view, and the cNFT distinction everyone gets wrong.
Solana Actions & Blinks: transactions from a URL
A Blink is a URL that unfurls into a signable transaction; an Action is the HTTP API behind it. Two endpoints — GET for metadata, POST for a serialized tx — turn any link into a one-tap payment or mint. Clean spec, real security questions. The wire-level view.
DoubleZero: a dedicated fiber network under Solana's validators
Consensus isn't Solana's bottleneck — the public internet is. DoubleZero is a contributor-supplied fiber network with FPGA edge filtering and native multicast, purpose-built for validator block propagation. Mainnet-beta launched Oct 2025 with ~20%+ of staked SOL. What it is and who's behind it.
Token-2022 Confidential Transfers: encrypted balances, and the ZK proof saga
Token-2022 can hide how much you hold and move — encrypting balances with twisted ElGamal and proving correctness with zero-knowledge range proofs. It hides amounts, not parties. And in mid-2025 two proof-soundness bugs took the ZK ElGamal program offline. The mechanism, honestly.
Yellowstone gRPC: how real-time Solana data actually streams
If you've ever missed a websocket update or polled getProgramAccounts in a loop, this is the fix. Yellowstone gRPC taps Solana's Geyser interface and streams filtered account/tx/slot/block updates over HTTP/2 — lower latency, server-side filtering, real backpressure. The data layer indexers actually use.
The DAS API: one interface to read every Solana asset
Compressed NFTs don't have accounts, so getAccountInfo can't see them. The DAS API is how you read them — plus regular NFTs, Token-2022, and fungibles — from one standardized interface. The methods, why getAssetProof is essential for cNFT transfers, and the indexer dependency.
Metaplex Core: an NFT in one account
Token Metadata spreads an NFT across three-plus accounts. Metaplex Core puts the whole thing in one — ~0.0037 SOL to mint vs ~0.022, ~17k CU vs ~205k — with a modular plugin system for royalties, freezing, and on-chain data. The catch: a Core asset isn't an SPL token.
Restaking on Solana: Jito, Solayer, and Fragmetric compared
Restaking lets your staked SOL pull double duty: secure Solana, then secure other services for extra yield. Jito coined NCNs, Solayer split endogenous vs exogenous AVS, Fragmetric built it on Token-2022. The model, the three players, and the honest question — where's the real slashing risk and demand?
MEV on Solana: Jito bundles, swQoS, and the anti-sandwich fight
No public mempool, leader-based blocks, off-chain orderflow — MEV on Solana looks nothing like Ethereum. It runs through Jito's bundle auctions; sandwiching migrated to private validator deals after Jito killed its mempool in 2024. swQoS, and Paladin's economic counter-attack. The mechanics.
Drift Protocol: how Solana's biggest perp DEX is built
Drift runs perps, spot, lending, and prediction markets off one cross-margin account. Its liquidity is a three-layer hybrid: JIT auctions, a keeper-run decentralized order book, and a vAMM backstop. Powerful and capital-efficient — and the target of a >$270M exploit in April 2026. The architecture, honestly.
Solana Attestation Service: portable on-chain credentials
How does a DeFi app know a wallet passed KYC without seeing the passport? The Solana Attestation Service standardises that: issuers sign on-chain attestations that a wallet meets a credential; verifiers check them; raw data stays off-chain. Optionally tokenized via Token-2022. The model and its limits.
PayAI: the x402 facilitator on Solana
x402 needs someone to verify and settle payments — that's the facilitator. PayAI runs the biggest one after Coinbase, covers gas for both buyer and merchant, and lets a resource server stay completely chain-agnostic. Protocol view.
OTL: the Open Transaction Layer for compliant onchain transactions
Blockchains settle transactions; they don't coordinate who you're transacting with, whether they're compliant, or how to reconcile the off-chain context. OTL — backed by Fireblocks, Robinhood, MetaMask, Stripe's Privy and the Solana Foundation's consortium — is an open stack for exactly that. Protocol view.
ProofNetwork's MCP: docs-as-a-tool for building proof-backed Solana apps
ProofNetwork is a serverless JavaScript runtime where every execution is proof-backed. Its MCP server doesn't run contracts — it serves the documentation an agent needs to write them: four tools over Streamable HTTP, two skills, real VRF and key-storage APIs. A look at the docs-as-MCP pattern.
The Solana Vote Program: schema, instructions, and how to read it
Vote Program byte layout, the VoteInstruction enum, TowerSync serialization, lockout math, and JS code to read every field of a live vote account. Pure technical reference.
MetaDAO: how futarchy on Solana actually works (three programs, two markets, one TWAP)
Decisions by markets, not votes. MetaDAO's futarchy mints conditional-on-pass and conditional-on-fail tokens per proposal, runs a market for each, and finalises whichever TWAP is higher. Here's the on-chain architecture.
Generating Solana vanity addresses at 17 billion per second with caveman's `vanity`
Don't grind keypairs. Grind seeds. caveman's `vanity` tool generates Solana vanity addresses via CreateAccountWithSeed at GPU speed — here's why it's so much faster and what you give up.
ProgramWatch: the Solana program explorer that surfaces what Solscan won't
Every general explorer shows you transactions. ProgramWatch shows you the things you actually want to know about a program before you CPI into it — upgrade authority, freeze status, verified build, IDL availability.
The official Solana Explorer: open source, forkable, the reference decoder
Everyone uses explorer.solana.com. Fewer people know the whole thing is Apache-2.0 on GitHub, runs locally pointed at any cluster, and is what most branded chain explorers are forked from.
Stablecoins on Solana: mint registry, decimals, and Token-2022 extensions
USDC, USDT, PYUSD, USDG, USDY and friends — their actual mint addresses, decimals, token program, and the on-chain extensions each issuer wired up. The technical sheet you need before integrating any of them.
Crossmint on Solana: wallets, fiat checkout, and minting from one SDK
Embedded smart wallets, fiat checkout, REST minting, and agent wallets — one TypeScript SDK across 40+ chains, Solana first-class. Where it wins and where it doesn't.
Solana CPI: how one program calls another, the actual mechanics
CPI is how Solana programs compose. Account meta forwarding, invoke vs invoke_signed, signer seeds, the 4-deep call limit, and reading return data from the called program.
Solana PDAs: program-derived addresses, the actual math
PDA derivation, the bump search, off-curve check, invoke_signed semantics, and the canonical patterns for using PDAs as program-owned state.
Flash Trade: pool-to-peer perpetuals on Solana, the mechanism
No order book, no matching engine. Flash Trade prices perps off Pyth, executes against a shared liquidity pool (FLP), and LPs earn fees + the trader's net losses. The pool-to-peer model explained.
Phoenix: the crankless on-chain order book, and the perps extension
Phoenix proved a fully on-chain CLOB could work on Solana without a crank — fills settle atomically in the taker's transaction. The market/seat account model, the crankless design, and why it matters.
Solana's developer platform: the official on-ramp for new builders
solana.com/developers is the Solana Foundation's curated hub — docs, bootcamps, the Cookbook, payments primitives, and links into every meaningful learning path in the ecosystem. Here's how to actually use it.
Solana compute units: the actual cost table and how to budget
What a compute unit actually costs (per syscall, per opcode), the 200k default, the 1.4M per-tx cap, and how to set the limit + price right per instruction.
Solana transactions and limits: 1232 bytes, 64 signatures, 1.4M CUs
The four hard limits — size, signatures, compute, accounts — that bound every Solana transaction. Where each comes from, when you'll hit it, and how to work around it.
Solana RPC providers compared: methods, streaming, archival, and price
Five serious Solana RPC providers, compared on the technical axes that actually differ: enhanced methods, Geyser gRPC streaming, DAS API, archival depth, staked connections for landing, and pricing model.
From Wormhole to Frontier: the history of Solana hackathons and the rise of Colosseum
Solana's hackathons have produced more of the ecosystem's top protocols than any other on-ramp. Here's the full timeline — from the 2020 Wormhole hackathon to today's Colosseum-run Frontier — and why the hackathon → accelerator → venture model became Solana's strategic moat.
Blueshift: where Solana developers go to actually learn
Free, structured Solana learning with on-chain verified challenges, courses from beginner to sBPF assembly, and a research arm that goes deeper than anyone else outside the validator teams.
Privy vs Dynamic vs Magic vs Crossmint vs Reown vs Lazorkit: the embedded wallet showdown
Six serious players, six different bets. The full embedded-wallet comparison for Solana — multi-chain incumbents, stablecoin platforms, the Walletconnect rebrand, and the passkey-native challenger.
Testing Solana programs with LiteSVM: the workflow, Rust and TS
Beyond 'what is LiteSVM' — the actual testing workflow. Rust integration tests, the TypeScript bindings, setting arbitrary account state, warping the clock, and wiring it into CI for sub-second test runs.
Turbin3: the talent engine behind half of Solana's engineering
How Turbin3 has trained 2,000+ Solana engineers since 2022 — and why its alumni keep showing up at Jupiter, Helius, Metaplex, and most of the protocols you've heard of.
Superteam Talent: the recruiting layer the Solana ecosystem actually uses
A community-powered recruiting agency that connects engineers, designers, and operators with the Solana teams hiring them — without the noise of a traditional job board.
Solana derivation paths: BIP44, m/44'/501', and the Ledger gotcha
BIP39 → BIP44 with coin type 501 → ed25519. The canonical Solana path, the Ledger variant, hardened vs non-hardened, and why different wallets sometimes derive different addresses from the same seed phrase.
What is LiteSVM on Solana
A fast, lightweight library for testing Solana programs in Rust. Wraps the Sealevel VM directly — no validator, no async runtime, no RPC layer.
SPL Token vs Token-2022: program IDs, account layout, and what changed
Two program IDs, the same core schema, plus Token-2022's extension framework appended after the base mint. How to detect which you're dealing with and how the wire formats actually differ.
Mobile Wallet Adapter: how Solana dapps talk to wallets on a phone
MWA is the spec every Solana mobile wallet implements. Intent URI handshake, session-token capability model, sign-and-send flow, and how it differs from the desktop wallet-adapter pattern.
Token-2022 extensions: a field guide for builders
Token-2022 ships ~15 extensions that used to require custom programs. Here's what each one is for, what it costs, and how to combine them without painting yourself into a corner.
p-token: how Solana rewrote its most-called program (4,645 CU → 76)
SPL Token ate ~10% of every block. The Pinocchio rewrite cut a transfer from 4,645 CU to 76 — a ~98% reduction — shipped under the same program ID via SIMD-0266. The numbers, the rollout, and the one thing that breaks for indexers.
Solana staking: the Stake program, account states, and warmup math
Stake accounts, the warmup/cooldown math, the four states, and the actual instruction shapes for delegate, deactivate, split, merge, and withdraw. The technical reference.
Address Lookup Tables on Solana: when they earn back their cost
ALTs trade a one-time setup cost for ~31 bytes saved per address on every future transaction. Worth doing for hot programs; pointless for one-shots. Here's the actual math.
Solana validators: identity, vote, stake, and what running one actually requires
Identity key, vote account, delegated stake — three on-chain primitives plus the hardware to run them. The technical view of what a Solana validator actually is.
Solana priority fees in 2026: CU price, Jito tips, or both?
Three ways to pay for inclusion: CU price, Jito tips, both. Each works in different scenarios — here's the decision tree and the numbers behind it.
Squads: how Solana's standard multisig actually works on-chain
Squads V4 program architecture — Multisig accounts, vault PDAs, transaction proposals, approval and rejection thresholds, ephemeral signers. The technical view.
codama: how the modern Solana stack generates TypeScript clients
Anchor's TypeScript client is a runtime IDL interpreter. codama is a build-time code generator that emits tree-shakeable, type-safe instruction builders. The difference matters.
SNS: Solana Name Service, the registry program, and how .sol resolves
Bonfida's Name Service program, the PDA derivation from SHA-256 hash + class + parent, the NameRecordHeader structure, and the canonical resolution flow for a .sol address.
Anchor vs Pinocchio vs Steel: three Solana program frameworks, compared
Anchor optimises for developer experience. Pinocchio optimises for compute units. Steel sits in the middle. Bundle size, CU cost, and ergonomics — compared.
Pyth: the on-chain price layer, Push vs Pull, and the price account schema
Pyth's publisher network, the aggregated price account, the Push (Solana-native) vs Pull (cross-chain) models, EMA price, confidence intervals, and how to consume a feed safely.
@solana/kit vs @solana/web3.js vs gill: the JS client situation in 2026
Legacy web3.js is on borrowed time. @solana/kit is the official successor. gill is the ergonomic wrapper. Here's the actual difference and what to use when.
Switchboard: the customisable oracle, queues, jobs, and aggregators
Switchboard's per-feed customisability — write your own job definition, get any data source on-chain. Queues, oracles, aggregator schema, and the randomness primitive.
Firedancer and the Solana validator client landscape in 2026
Five Solana validator clients exist in 2026, three are in production. Here's what each one does, what's on mainnet, and why client diversity finally matters.
MagicBlock: ephemeral rollups for real-time Solana, 10ms blocks and all
Ephemeral rollups let a Solana app temporarily delegate accounts to a faster L2-like runtime — 10ms blocks, free transactions, committed back to mainnet on demand. The mechanism explained.
Jito Block Engine, demystified: bundles, MEV, and what tips actually pay for
Jito tips show up in every Solana arb, snipe, and high-priority transaction. The Block Engine is the auction underneath. Here's the mechanism in concrete terms.
Surfpool: mainnet-fork test validator with RPC cheatcodes
Drop-in alternative to solana-test-validator. Fork Mainnet state on demand, set any account or token balance via RPC cheatcodes, deploy via Infrastructure-as-Code, watch it in a real-time dashboard.
State compression and cNFTs on Solana: when 99% cost reduction actually happens
cNFTs let you mint a million NFTs for the price of one. The trade-off is your reads now go through an RPC indexer — here's when that breaks even.
Arcium: MPC for Solana — compute over encrypted data, on-chain
MPC done right — a network of compute nodes that jointly evaluate functions over inputs none of them can see. Used for dark pools, sealed-bid auctions, and any flow that needs on-chain privacy without ZK proofs.
Solana Pay: the underrated spec every wallet already implements
A URL scheme. That's it. Solana Pay lets you accept stablecoins or SOL via QR code or deeplink, with every wallet on the network already supporting it.
Umbra: a privacy layer for Solana — shielded balances and private transfers
ZK-shielded balances on Solana. Deposit transparent funds into a shielded pool, transfer between shielded addresses without revealing amounts or counterparties, withdraw back to transparent. The on-chain mechanism.
DePIN on Solana: what Helium, Hivemapper, Render, and Honey Frame actually do
Helium for wireless, Hivemapper for maps, Render for GPUs, Honey Frame for IoT — DePIN on Solana spans four real markets. What's actually running, beyond the marketing.
@solana/kit: the modern JS client, functional + tree-shakeable
Branded types, pipe-based composition, codecs for serialization, no classes, no defaults. Kit's a fundamental redesign — not a coat of paint on web3.js. The concrete shape.
Solana AI agents in 2026: agent wallets, MCP servers, and what's actually shipping
Most of the AI x Solana narrative is marketing. The actual primitives — agent wallets, Solana MCP, agent kits — are small, useful, and easy to ship today.
Privy: white-label wallet infrastructure, the technical view
Privy's TEE-and-sharding key model, the User / Treasury / Agent wallet products, the React provider pattern, server-side wallet operations, and how recovery actually works.
Sanctum: how Solana's liquid staking platform actually works
Sanctum unbundled LST issuance from LST liquidity. Anyone can launch one, the Infinity pool aggregates them all, and JitoSOL/mSOL/bSOL became interchangeable at fair value.
Kit-squared: @solana/kit in SvelteKit, no React needed
Kit ships no React adapters because it doesn't need them — every primitive is a plain function. The SvelteKit integration pattern: RPC and wallet as stores, lifecycle-managed subscriptions, end-to-end SSR-safe.
Polymarket on Solana: why a prediction market migrates, and what changes
Polymarket's expansion to Solana isn't strategy theatre — it's UX. Sub-second order matching needs sub-second confirmation, and Ethereum L2s still can't deliver it cheaply.
Solana Unity SDK: the C# client for game devs, with real wallet integration
C# bindings for Solana — RpcClient, Wallet, Transaction, SPL Token. WebGL + Android + iOS targets, in-game wallet adapter, and how to ship a Solana action without the player ever leaving the game.
Rust + Anchor + Quasar: the standard Solana program stack in 2026
Cargo init through deploy, with Anchor for program ergonomics and Quasar (or solana-test-validator) for fast integration tests. The opinionated stack new Solana program authors converge on.
x402: HTTP 402 reborn — internet-native payments, on Solana
The HTTP 402 Payment Required status code finally gets a real spec. Coinbase's x402 turns it into a one-round-trip API payment flow, settled in USDC on Solana (and other chains). Pure-protocol view.