“Flow: Separating Consensus and Compute” is the 2019–2020 technical paper by Dapper Labs describing the Flow blockchain — designed specifically for consumer-scale applications like NFT marketplaces and games. Dapper Labs, creator of CryptoKitties (which congested Ethereum in 2017) and later NBA Top Shot, designed Flow to handle the specific throughput and usability demands of consumer NFT products without sharding state — instead pipelining the tasks of a blockchain node across four specialized node types.

Flow’s smart contract language, Cadence, is a resource-oriented language with protocol-level support for representing digital assets as first-class resources with access control.

> Technical paper: Available at onflow.org/technical-paper.

---

Publication and Context

CryptoKitties launched in November 2017 and immediately congested Ethereum, causing gas prices to spike to ~$20/transaction during a period when average Ethereum fees were ~$0.10. Dapper Labs concluded that Ethereum, as designed, could not support mass-market consumer NFT applications, and began designing a purpose-built chain.

The fundamental requirement: support millions of users performing simple asset transactions (minting, buying, selling NFTs) without requiring users to pay variable gas fees or manage blockchain complexity. Flow mainnet launched in September 2020.

---

Four-Role Node Pipelining

The Flow whitepaper’s core architectural contribution is pipelining the blockchain pipeline across four specialized node types rather than having every node perform every task:

1. Collection Nodes:

• Aggregate user transactions into collections (batches)
• Responsible for transaction ordering and network dissemination
• Form collection clusters that independently order transactions
• Provide transaction data availability: all execution nodes can retrieve the transactions

2. Consensus Nodes:

• Reach agreement on the order of collections (not transaction content or execution)
• Use a BFT consensus protocol (HotStuff-based)
• Do NOT execute transactions — producing blocks is purely an ordering exercise
• All consensus nodes are relatively lightweight; they only order collection hashes

3. Execution Nodes:

• Actually execute the ordered transactions
• Maintain the full global state
• Produce execution receipts (commitments to the post-execution state) for each block

4. Verification Nodes:

• Independently re-check execution receipts against their own execution results
• Detect incorrect execution claims and challenge them
• Provide a fraud-proof mechanism without every user re-executing

Pipelining analogy: Like an assembly line, each stage starts on the next block while previous stages are still processing earlier blocks. Consensus starts ordering block N+2 while Execution is processing block N+1 and Verification is checking block N.

---

Cadence Programming Language

Flow uses Cadence, a resource-oriented smart contract language with several novel features:

Resources as first-class types: Digital assets (NFTs, fungible tokens) are represented as Move-style resource types — they cannot be duplicated or lost, only moved between storage locations. A CadenceNFT is stored directly in a user’s account storage, not in a mapping inside a contract.

Capability-based access: Smart contract functions are exposed via capabilities — unforgeable tokens that grant the holder permission to call a specific function on a specific object. This is more granular than Solidity’s function visibility modifiers.

Account storage model: Each account has typed storage where resources are stored. Contracts define types; accounts own instances of those types.

Cadence was designed to prevent common NFT and token bugs (lost assets, access control failures) at the language level, though it required a new mental model that slowed developer onboarding.

---

Reality Check

Flow achieved its primary goal: NBA Top Shot launched in 2020 and processed hundreds of thousands of transactions during peak demand without the congestion issues CryptoKitties caused on Ethereum. Consumer UX was significantly better than Ethereum (no gas fees visible to end users; credit card payments integrated).

However:

• Centralization concerns: During peak periods, only a small number of Execution Nodes run (Dapper Labs runs the majority), making the chain functionally centralized at the execution layer.
• Developer ecosystem: Cadence required developers to learn a new language from scratch; EVM-compatible tooling (Hardhat, Foundry, MetaMask) doesn’t work natively. Ecosystem growth has been slower than EVM chains.
• NFT market consolidation: As NFT market activity moved to Ethereum L2s and Solana, Flow’s relative importance in the NFT space declined after 2022.
• EVM layer added (2024): Flow added an EVM-compatible execution environment alongside Cadence to attract Solidity developers, acknowledging the ecosystem limitation.

---

Legacy

Flow demonstrated that a purpose-built consumer blockchain could support millions of mainstream users in a way that Ethereum could not in 2020. The four-role pipelining architecture is a distinct alternative to sharding for scaling without global state fragmentation. Cadence’s resource orientation influenced later resource-based smart contract designs.

---

Related Terms

• NFT
• Smart Contract
• Cadence Language
• Proof of Stake

---

Research

• Hentschel, A., Lafrance, B., Sanchez, P., et al. (2020). Flow: Separating Consensus and Compute. Dapper Labs.

— Primary technical paper. Section 3 details the four-node architecture; Section 4 describes the execution and verification protocols.

• Blackshear, S., Cheng, E., Dill, D., et al. (2019). Move: A Language With Programmable Resources. Diem Language Research Group.

— Move language paper; Cadence independently arrived at similar resource-oriented design with different syntax and account model.

• Yin, M., Malkhi, D., Reiter, M., Gueta, G.G., & Abraham, I. (2019). HotStuff: BFT Consensus with Linearity and Responsiveness. ACM PODC 2019.

— HotStuff consensus paper; Flow’s consensus layer is based on HotStuff for O(n) communication complexity.