Skip to main content

This site is for educational purposes only. Nothing here constitutes financial advice.

Topic 63 of 189

Solana Programs and Anchor

How Solana's account model differs from Ethereum's, why Sealevel enables parallel execution, what makes Solana programs feel different to write, and where Anchor fits.

Beginner
8 min readUpdated November 2026Block Clarity Hub Editorial Team

The basics

Solana's Core Architectural Choice

Solana made a different bet from Ethereum: optimise for throughput by requiring transactions to declare which accounts they touch up front. This declaration enables Sealevel — Solana's runtime — to schedule non-conflicting transactions in parallel. Result: high throughput (actual transactions per second vary with network demand) at the cost of higher developer complexity. You can't just 'call whatever contract you want' the way you can on Ethereum; you have to know your account list in advance.

Programs Aren't Contracts

On Solana, smart contract logic lives in 'programs.' Programs are stateless — they don't hold their own data. Data lives in separate 'accounts' that programs can read from and write to. This separation is a big mental shift from Ethereum, where contracts and their state are tightly coupled. The benefit: programs can be upgraded independently of their data, and the same program logic can operate on many independent account instances.

Anchor — The Most Popular Framework

Anchor is the most popular Solana development framework (per its own README), similar in role to Hardhat or Foundry on Ethereum. It provides Rust macros that abstract away most of the account-handling boilerplate, IDL (Interface Description Language) generation for client SDKs, and testing utilities. Solana's own documentation lists three common ways to write a program: Anchor, Pinocchio, or native Rust.

  • Transactions declare account list up front → enables Sealevel parallel execution
  • Programs are stateless; data lives in separate accounts
  • Written in Rust; Anchor is the most popular framework (Pinocchio and native Rust are alternatives)
  • High throughput at the cost of higher developer complexity

Key Takeaways

  • Solana's account-declaration model is the source of its throughput advantage
  • Programs are stateless; state lives in accounts that programs operate on
  • Anchor is the most popular framework; Pinocchio and native Rust are alternatives
  • Trade-off: throughput up, developer experience more constrained than Ethereum

Going deeper

Sealevel — Parallel Execution Engine

Sealevel is the runtime that schedules transactions. When transactions declare their account dependencies, Sealevel sorts them into conflict-free groups and executes each group in parallel. Running non-conflicting groups on separate CPU cores can raise throughput well above single-threaded execution, though contention on popular accounts limits the gain. The hardware requirements are non-trivial (Solana validators need fast NVMe, high core counts, fast networking), which is part of why Solana validators are more expensive to run than Ethereum validators.

Rent and Account Lifecycle

Solana accounts must hold a minimum balance ('rent exemption') to store data onchain. The minimum scales with the account's data size — it is the data length plus a fixed 128-byte overhead, multiplied by a per-byte rate that the network has been lowering in stages — so an empty account needs only a small fraction of a SOL and larger accounts need more. Ongoing rent collection is disabled, so the balance works as a refundable storage deposit that is returned when the account is closed. This is a deliberate design choice to put a price on state size. The trade-off: users have to think about storage deposits in a way Ethereum users don't.

Compute Units and Priority Fees

Solana doesn't have gas in the Ethereum sense. Instead: each transaction has a 'compute unit' budget (default 200K per instruction, max 1.4M per transaction). Programs consume compute units as they execute; exceeding the budget reverts the transaction. Users can pay priority fees to get included faster during congestion. The fee model is similar in spirit to EIP-1559 but with the compute-unit-budget complication.

Local Fee Markets

Solana has 'local fee markets' — fees on contended accounts can spike independently of overall network demand. If one account is in heavy contention (e.g., a popular AMM pool), transactions touching it pay more, while transactions touching uncontended accounts stay cheap. It produces uneven user experience but, in principle, better overall resource allocation.

Key Takeaways

  • Sealevel schedules non-conflicting transactions in parallel — the throughput trick
  • Rent-exempt minimum balances act as a refundable storage deposit that scales with account size
  • Compute unit budgets replace gas; priority fees handle congestion
  • Local fee markets isolate contention to specific accounts

Under the hood

Native Token Standards: SPL Token and Token-2022

On Solana, the SPL Token program is the canonical fungible token implementation — analog to Ethereum's ERC-20 but implemented as one shared program that every token's accounts are owned by, rather than a separate contract per token. Token-2022 (released 2023) extends this with optional features: transfer fees, confidential transfers (switched off on 11 June 2025 after a ZK ElGamal proof program vulnerability report, and re-enabled in the Token-2022 v11.0.0 release of May 2026), metadata pointers, interest-bearing tokens. Many newer Solana projects use Token-2022 specifically for these extensions. The shared-program approach (vs Ethereum's separate contract per token) means every token runs the same program logic, so per-token customisation comes through Token-2022's extensions rather than custom token code.

Program Upgrades and BPF Loader

Solana programs are deployed via BPF Loader Upgradeable, which lets program authority addresses upgrade the program. By default this is the deployer's address; production programs often transfer authority to a multisig or burn it for immutability. Unlike Ethereum's proxy patterns (transparent, UUPS), Solana upgrades are built into the runtime. Reading a Solana program's upgrade authority is part of routine due diligence.

Solana's Outages and Mainnet Reality

Solana has had multiple multi-hour mainnet outages: September 2021 (17 hours; bots flooded the network during the Grape Protocol IDO), April 2022 (about seven hours; bots chasing an NFT mint stalled consensus), June 2022 (a durable-nonce bug), February 2023 (block-forwarding services re-broadcast an unusually large block, degrading finalisation until a restart), February 2024 (a bug in how the validator cached compiled programs deployed with legacy loaders). Each outage triggered substantial fixes, and the only post-mortems in Solana's news archive since February 2024 (May and June 2025) concern a patched ZK ElGamal proof vulnerability rather than a halt. But the outage history is real and shapes risk assessment.

Firedancer — The Second Validator Client

Solana has historically run a single validator client (Agave, maintained by Anza). Firedancer, built by Jump Crypto, is the second independent client — a complete from-scratch rewrite in C, with substantially higher theoretical throughput. It has been rolled out in stages: the hybrid Frankendancer (part Agave, part Firedancer code) has had mainnet releases since September 2024, and the full Firedancer validator has had releases marked 'mainnet ready' since August 2026 (v1.1.3). Two-client diversity is a major resilience improvement; comparable to Ethereum's multi-client situation (Geth, Reth, Nethermind, Besu, Erigon). Firedancer adoption is the leading indicator of Solana's medium-term resilience trajectory.

Solana's Centralisation Tension

Solana validators require server-class hardware (Anza's recommendations include 12 or more cores, 256GB or more of RAM and several NVMe SSDs) and SOL to cover vote transactions (up to 1.1 SOL per day, per Anza) — far more than Ethereum's solo-staker hardware. This concentrates validation in well-resourced operators. The decentralisation argument is that physics requires the hardware (you can't have high throughput on cheap commodity hardware), and that competition among well-resourced validators is sufficient. Critics argue it represents structural centralisation that compromises Solana's censorship-resistance claims. The truth is somewhere in the middle and the debate is ongoing.

Key Takeaways

  • SPL Token + Token-2022 are the standard token programs; every token is an account owned by one of them
  • Program upgrades use BPF Loader Upgradeable; check upgrade authority during due diligence
  • Multiple multi-hour mainnet outages between 2021 and 2024; as of November 2026 Solana's status page lists no critical incident since February 2024
  • Firedancer is the second independent client — significant resilience improvement
  • Hardware requirements concentrate validation in well-resourced operators; centralisation debate is real

Related Content

Arbitrum Nitro and Stylus

How Arbitrum Nitro evolved from Arbitrum One's custom architecture to running Geth-on-WASM, what BoLD fraud proofs change, and what Stylus's WASM extension brings (Rust/C/C++ smart contracts).

Optimism Bedrock and the Superchain

How OP Mainnet's Bedrock architecture, fault-proof rollout, and Superchain interop strategy reshape Optimism from a single rollup into a widely deployed modular L2 framework (Optimism says 54 mainnet chains ran on the OP Stack as of October 2026).

Base Architecture

How Coinbase's Base L2 launched on the OP Stack and has been moving to its own Base-operated stack, how Coinbase's exchange-side integration drives uniquely smooth UX, what the sequencer's centralised reality means today, and the path to a 'stage-2' rollup.

Linea and Polygon zkEVM Compared

How two zkEVMs — Linea (Consensys) and Polygon zkEVM, whose Mainnet Beta sequencer was sunset on 3 July 2026 — compare on EVM-equivalence levels, prover technology, ecosystem strategy, and what each chain's positioning means for users and developers.

Move Language (Aptos and Sui)

Why Move's resource model fundamentally differs from Solidity, how Aptos and Sui evolved from the same Facebook-origin language, and what 'resources' mean for safety guarantees.

Cairo and StarkNet Contract Development

How Cairo as a language differs from Solidity and Rust, why account abstraction is native to StarkNet, and what writing production StarkNet contracts actually involves.

CosmWasm and Cosmos Smart Contracts

How CosmWasm enables smart contracts on Cosmos chains via WebAssembly, what makes the developer experience distinct from EVM, and why Cosmos's sovereign-chain architecture is a different bet from rollup-style scaling.

Cardano Plutus and EUTxO Contracts

How Cardano's Extended UTXO (EUTxO) model differs fundamentally from Ethereum's account model, what writing Plutus contracts actually involves, and why concurrency on Cardano works differently.

References & further reading