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.
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
Related Coins
Related Topics
More Topics
Browse all 179 topicsArbitrum 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
- primary
- secondary