Solana:
Speed at the Speed of Light
Throughput
65k+
Transactions Per Second
Latency
400ms
Block Time
Cost
$0.00025
Avg. Fee per Tx
Validators
1,700+
Global Network
The 8 Core Innovations
Solana isn't just a faster Ethereum. It's a fundamental rethink of blockchain architecture, borrowing concepts from cellular networks and CPU design.
A Clock Before Consensus
In distributed systems, agreeing on time is hard. Solana solves this by creating a cryptographic timestamp using a Verifiable Delay Function (VDF). This allows validators to trust the order of events without waiting to hear from every other node.
Optimized PBFT for PoH
Tower BFT leverages the PoH clock to reduce messaging overhead. Validators 'vote' on the ledger state, and because the clock is trusted, they don't need real-time communication for every single vote, enabling massive speed.
Block Propagation Protocol
Inspired by BitTorrent, Turbine breaks blocks into tiny packets. A validator sends packets to a 'neighborhood' of peers, who then relay them to others. This allows data to propagate through the network exponentially fast.
Mempool-less Transaction Forwarding
Solana has no mempool. Since the leader schedule is known in advance, wallets send transactions directly to the current and future leaders. This eliminates the waiting room and reduces confirmation times.
Parallel Smart Contracts
Most blockchains are single-threaded (one tx at a time). Sealevel allows Solana to process thousands of smart contracts in parallel, using all available cores of the validator's CPU.
Transaction Processing Unit
Borrowed from CPU design, pipelining separates the process of fetching data, verifying signatures, and writing to the ledger into distinct hardware stages, maximizing efficiency.
Horizontally Scaled Accounts
A custom data structure optimized for concurrent reads and writes across RAID 0 SSDs. It allows the database to keep up with the massive throughput of the network.
Distributed Ledger Storage
Storing petabytes of blockchain history is hard. Archivers are lightweight nodes that store pieces of the ledger, ensuring data availability without forcing every validator to be a supercomputer.
The Next Generation
Solana is constantly evolving. New upgrades like Firedancer and State Compression are pushing the boundaries of what's possible.
Firedancer
A new, independent validator client built by Jump Crypto in C++. It's designed to increase throughput to over 1 million TPS.
- Modular Architecture: Uses "tiles" (individual Linux processes) for specific tasks like signature verification and network processing, allowing for extreme optimization.
- Hardware Acceleration: Bypasses the OS kernel for networking (using XDP) to reduce latency to the absolute minimum.
- Client Diversity: Eliminates the single point of failure of having only one validator client implementation.
State Compression
A method to store data on-chain for a fraction of the cost using Concurrent Merkle Trees.
- Compressed NFTs (cNFTs): Mint millions of NFTs for pennies. Instead of storing full data in accounts, only the "fingerprint" (hash) is stored on-chain.
- Merkle Roots: The root of the tree is on-chain (secure), while the leaves (data) are stored in cheaper ledger space, verified by RPC providers.
- Massive Scale: Enables use cases like gaming items, tickets, and social graph data that were previously too expensive.
Built with Rust
Solana smart contracts (programs) are written in Rust, C, or C++. This ensures memory safety, high performance, and low-level control over system resources.
The Sealevel runtime executes these programs using the Berkeley Packet Filter (BPF) bytecode, a technology originally designed for high-performance packet filtering in the Linux kernel.
use solana_program::{
account_info::AccountInfo,
entrypoint,
entrypoint::ProgramResult,
pubkey::Pubkey,
msg,
};
entrypoint!(process_instruction);
pub fn process_instruction(
program_id: &Pubkey,
accounts: &[AccountInfo],
instruction_data: &[u8],
) -> ProgramResult {
msg!("Hello, Solana!");
Ok(())
}