Section 01 · Introduction
The one paragraph answer
Solana is a public, permissionless layer 1 blockchain built for high throughput and low cost. Here is what you need to know before writing your first program.
Quick answer
What is Solana? Solana is a layer 1 blockchain that processes thousands of transactions per second at roughly $0.00025 each. It uses Proof of History — a cryptographic clock — plus Proof of Stake consensus to confirm transactions in about 400 milliseconds without sacrificing decentralization.
Anatoly Yakovenko spent years at Qualcomm building systems where GPS synchronized clocks let millions of devices coordinate without talking to each other. He brought that idea to blockchains. The insight: if validators share a verifiable record of time, they do not need extra communication rounds just to agree on when transactions happened. That insight became Proof of History.
Yakovenko published the Solana whitepaper in 2017. The mainnet launched in March 2020. Solana is not a layer 2 built on top of Ethereum. It is a completely independent layer 1 with its own consensus, its own execution environment, and its own developer toolchain. Programs are written in Rust, not Solidity.
The numbers tell the story. Solana produces a block every 400 milliseconds. Ethereum produces one every 12 seconds. Bitcoin takes roughly 10 minutes. Transaction fees on Solana run about $0.00025 — roughly 5,000 lamports. On Ethereum, a simple token transfer can cost $0.50 to $20 during periods of high demand. For applications that send hundreds of transactions per user session, that cost difference is the entire business model.
Solana is a layer 1, not a layer 2
A common misconception is that Solana is built on top of Ethereum. It is not. Solana is a fully independent layer 1 with its own validator set, its own consensus protocol, and its own VM. It shares no code or security model with Ethereum. This matters for developers: you cannot deploy a Solidity contract to Solana without rewriting it in Rust.
Section 02 · Architecture
Why Solana is fast
Three design choices combine to deliver block times that no other layer 1 matches today.
The first is Proof of History Explained. The current leader node runs a sequential SHA-256 hash chain at around 400,000 hashes per second. Each output feeds into the next as input. Events inserted into the chain carry a provable timestamp. Validators read the chain to determine transaction order without sending messages to each other. Fewer messages means faster blocks.
The second is Sealevel, Solana’s parallel execution engine. Most blockchains process transactions one after another. Sealevel inspects the accounts each transaction needs to read or write, then runs non overlapping transactions simultaneously across all available CPU cores. If transaction A touches accounts 1 and 2, and transaction B touches accounts 3 and 4, they run in parallel. Only transactions that share accounts run sequentially. The practical result: the more CPU cores a validator has, the more throughput the network can sustain.
The third is Tower BFT. Tower BFT is Solana’s consensus algorithm, and it uses the PoH clock as its time reference. Validators vote on blocks and lock their votes for an exponentially increasing timeout period. A validator who votes for block N cannot vote against it for 2 slots, then 4, then 8, and so on. This lockout mechanism prevents validators from switching votes quickly, which is what lets the network reach finality fast. A transaction that lands in a block is confirmed in about 400 ms and reaches full finality in around 12 seconds.
Section 03 · Core Concepts
Four concepts every Solana developer needs to know
Solana's programming model differs from Ethereum in ways that trip up developers who come from an EVM background. These four concepts explain the differences.
Accounts
Everything on Solana is an account. A wallet is an account. A deployed program is an account. The data that a program reads and writes lives in separate data accounts. Each account has a public key (its address), a lamport balance, an owner field (the program that controls it), and a data field. Accounts that hold no data still need a minimum lamport balance called rent exemption — about 0.002 SOL for a small account — to remain alive on chain.
Programs
Programs are Solana's name for smart contracts. They are stateless: they do not store data inside themselves. Instead, they read and write data accounts passed in at call time. Programs are written in Rust, compiled to SBF (Solana Bytecode Format), and deployed to the network. The Anchor framework sits on top of raw Rust and eliminates most of the boilerplate. Read our guide on What Is Anchor for the full setup walkthrough.
Transactions
A transaction is a signed message that includes one or more instructions. Each instruction names the program to call, the accounts to read or write, and the instruction data. Every account that will be modified must be declared upfront in the transaction's account list. This upfront declaration is what lets Sealevel detect non overlapping transactions and run them in parallel.
Lamports
A lamport is the smallest unit of SOL, equivalent to one billionth of a SOL — the same relationship that satoshis have to Bitcoin. Programs handle all balances in lamports using u64 integer arithmetic. This avoids the rounding errors that floating point math would introduce when tracking fractions of a token. Transaction fees are roughly 5,000 lamports, and rent is also denominated in lamports.
Section 04 · Setup
Setting up your Solana development environment
You need four things: Rust, the Solana CLI, a keypair, and some devnet SOL. The whole setup takes about 15 minutes.
Install Rust
Rust is the primary language for writing Solana programs. Install it with the official installer. The Solana toolchain also needs Rust internally, so this step is required even if you plan to use higher level frameworks like Anchor.
Install the Solana CLI
The Solana CLI (command line interface) is your main tool for deploying programs, checking balances, and interacting with the network. It is maintained by Anza, the team that built the Agave validator client. Install from the official release endpoint.
Configure for devnet
Devnet is a public test network that mirrors mainnet behavior. Transactions cost devnet SOL, which is free and has no real value. Configure the CLI to point at devnet so all commands hit the right network.
Create a keypair and airdrop test SOL
Your keypair is your developer wallet. The private key lives in a JSON file on your machine. Never commit it to version control. Once you have a keypair, airdrop 2 SOL from the devnet faucet to cover transaction fees during development.
# 1. Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env
# 2. Install Solana CLI (uses Anza toolchain)
sh -c "$(curl -sSfL https://release.anza.xyz/stable/install)"
# Add to ~/.zshrc or ~/.bashrc:
export PATH="$HOME/.local/share/solana/install/active_release/bin:$PATH"
# 3. Verify
solana --version
# solana-cli 1.18.x (src:xxxxxxxx; feat:xxxxxxxxx, client:Agave)
# 4. Configure for devnet
solana config set --url https://api.devnet.solana.com
# 5. Create a keypair (your developer wallet)
solana-keygen new --outfile ~/.config/solana/id.json
# 6. Check balance (starts at 0)
solana balance
# 7. Airdrop test SOL (devnet only, not real money)
solana airdrop 2
# 8. Confirm
solana balance
# 2 SOL
With 2 SOL on devnet you can deploy dozens of test programs before the balance runs out. If it does, run solana airdrop 2 again. Devnet allows up to 5 SOL per request. Testnet works the same way for load testing closer to mainnet conditions, but devnet is the right environment for development.
Once your environment is running, the natural next step is the Anchor framework. Anchor wraps the Solana program model in a type safe layer that auto generates the IDL (interface definition language) and client code from your Rust annotations. Most production programs on Solana are built with Anchor. Read What Is Anchor? for the full setup and your first program.
If you want to understand how Solana compares to Ethereum at the protocol level before writing code, the Solana vs. Ethereum: Blockchain Fundamentals Compared post covers consensus, account models, fee structures, and ecosystem differences in depth.
If you are evaluating Solana for a production application and need help with architecture, smart contract audits, or full stack development, the blockchain development service covers the full stack from program design to mainnet deployment.
Section 05 · FAQ
Common questions about Solana
Direct answers to the questions developers ask most when they encounter Solana for the first time.
What is Solana?
Solana is a layer 1 blockchain designed for high performance decentralized applications. It processes thousands of transactions per second at a fraction of a cent each, powered by a unique mechanism called Proof of History that gives validators a shared cryptographic clock so they do not have to wait for network wide agreement before committing transactions.
Is Solana better than Ethereum?
Solana and Ethereum serve different trade offs, not a clear winner loser comparison. Solana is significantly faster and cheaper for high volume applications. Ethereum has a larger developer ecosystem, more battle tested DeFi protocols, and stronger decentralization with more validators and more client diversity. For a new project, Solana's lower fees and faster confirmations are often a practical advantage. For protocols that need maximum composability with existing DeFi, Ethereum or an EVM chain is typically the better fit.
What language do you use to write Solana programs?
Rust is the primary language for writing Solana programs. The Solana runtime compiles Rust code to SBF (Solana Bytecode Format), which runs inside the Solana Virtual Machine. Developers typically use the Anchor framework on top of raw Rust to reduce boilerplate. C and C++ can also compile to SBF, but Rust is the recommended choice for new projects because of its safety guarantees and active ecosystem support.
What is a lamport in Solana?
A lamport is the smallest unit of SOL, Solana's native currency. One SOL equals one billion lamports, which makes lamports equivalent to satoshis in Bitcoin. Programs track balances in lamports using integer arithmetic to avoid rounding issues that floating point would introduce. Transaction fees are denominated in lamports, and so is the rent a data account needs to stay alive on chain.
Is Solana proof of work or proof of stake?
Solana uses Proof of Stake for consensus, implemented through an algorithm called Tower BFT. What makes Solana unusual is that it combines Proof of Stake with Proof of History, a mechanism that acts as a cryptographic clock. Proof of History does not produce blocks on its own. It provides validators with a verifiable record of time that lets them agree on transaction order without sending extra network messages, which is the primary source of Solana's speed advantage.