Skip to main content

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

Topic 63 of 179

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 July 2026Block Clarity Hub Editorial Team

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 (theoretical 65,000 TPS, sustained 3,000-5,000 TPS in practice) 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 Framework Everyone Uses

Anchor is the dominant Solana development framework, 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. Most production Solana programs are written in Anchor. The framework's adoption is so widespread that 'Solana program' and 'Anchor program' are essentially synonymous for new development.

  • Transactions declare account list up front → enables Sealevel parallel execution
  • Programs are stateless; data lives in separate accounts
  • Written in Rust, with C/C++ support; Anchor framework dominates
  • 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 dominant framework — most production Solana code uses it
  • Trade-off: throughput up, developer experience more constrained than Ethereum

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 the dominant modular L2 framework.

Base Architecture

How Coinbase's Base L2 implements OP 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 production zkEVMs — Linea (Consensys) and Polygon zkEVM — 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