Flow

Flow is a Layer 1 proof-of-stake blockchain designed for consumer-scale applications, including digital collectibles, games, social products, decentralized finance, and AI-oriented workloads. It was created by the team associated with CryptoKitties after encountering throughput and user-experience limits on existing networks. Flow's architecture separates transaction collection, consensus, execution, and verification into distinct node roles, allowing the protocol to scale without relying on conventional sharding while preserving a globally distributed Byzantine-fault-tolerant network.

Flow supports two execution environments on the same underlying chain. Cadence is its native resource-oriented smart-contract language, designed so tokens and NFTs are first-class resources that cannot be accidentally duplicated or lost. Flow EVM is EVM-equivalent, enabling Solidity contracts and familiar Ethereum tooling such as Hardhat, Foundry, MetaMask, Ethers.js, RainbowKit, and wagmi. Developers can build in either environment or combine them in hybrid applications.

The FLOW token is the native asset used for transaction and storage-related fees, staking, and network participation. Flow's consumer orientation is reflected in its focus on low-cost transactions, fast finality, native account features, and applications such as NBA Top Shot and Disney Pinnacle. The protocol also provides native verifiable randomness, account linking, and atomic batching across Cadence and EVM contexts.

Flow's design is a pipeline: collector nodes batch transactions, consensus nodes order collection guarantees, execution nodes compute deterministic state transitions, and verification nodes check execution results. This places heavier computation on dedicated execution infrastructure while keeping ordering and correctness independently verifiable. The approach targets high composability and horizontal scaling, though the professionally operated execution-node model is a trade-off against maximal hobbyist-node accessibility.

Earlier general-purpose blockchains struggled to support consumer-scale applications because every validator often had to process the same work, creating throughput, latency, fee, and energy bottlenecks. Those limits are especially painful for games, collectibles, ticketing, and social applications that may produce many small transactions and need predictable, responsive interactions. Flow was designed after the CryptoKitties team experienced these constraints directly.

Flow addresses the problem by separating roles in the transaction-processing pipeline instead of making every node perform every task redundantly. Collector clusters ingest and batch transaction data; consensus orders compact collection guarantees; execution nodes process the full workload; and verification nodes check the results. This lets the network use high redundancy where transaction ordering needs it while avoiding the cost of running expensive execution on a very large validator set.

Developer and user experience is another target. Cadence's resource-oriented model and capability-based permissions make ownership semantics explicit, while multi-key accounts, account linking, low fees, fast finality, native randomness, and EVM compatibility reduce onboarding and development friction. These features aim to absorb common blockchain complexity into the platform rather than forcing each application team to rebuild solutions independently.

Flow's multi-role architecture begins with collection. Collector nodes are organized into clusters that receive subsets of transactions and assemble them into collections. Signed collection guarantees commit the collectors to retaining the underlying data, while the smaller guarantee is what consensus needs to order. Consensus nodes then use Byzantine-fault-tolerant proof-of-stake consensus to establish the canonical order of collection guarantees.

Execution nodes receive the collections and execute the ordered transactions against Flow's state. Flow's design can use a small number of powerful, dedicated execution nodes; each maintains the full state and computes all transactions, potentially parallelizing internally as long as the result matches deterministic sequential execution. Verification nodes independently check execution results before they become finalized protocol output. This separation makes consensus redundancy and execution redundancy tunable independently.

At the application layer, developers may use Cadence or Flow EVM. Cadence uses resources, capabilities, and an account model with multiple keys and permissions. Flow EVM exposes Ethereum-compatible JSON-RPC and uses FLOW for gas, so Solidity applications can use established EVM tooling. Both environments share the same Flow blockchain infrastructure and can interact through cross-VM features such as atomic batch transactions.

FLOW underpins the network economy: it pays transaction/gas costs, supports storage-related fees, and is used in staking and delegation. Mainnet Flow EVM is chain ID 747 and testnet is 545. Native Flow access uses Flow Access APIs, while EVM applications use standard Ethereum JSON-RPC endpoints. Users and developers can inspect activity with Flow-compatible explorers such as Flowscan.