> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tape.network/llms.txt
> Use this file to discover all available pages before exploring further.

# Network Architecture

Tapedrive has a control plane and a data plane. Solana is the control plane: it keeps
track of the nodes, the state of the network, and which erasure-coded pieces each node
stores. Tapedrive nodes are the data plane: they store and serve the data itself.

[Tapenet](/tapenet) is the open data plane made up of independent Tapedrive nodes. Local
Tapedrive uses the same design with tapesvm, a drop-in replacement for Solana. Both use
the same object model and the same tools.

Here's the whole system in one pass. Users hold wallets and sign transactions. Data lives as [tracks](/protocol/architecture/tracks) on prepaid [tapes](/protocol/architecture/tapes). Erasure-coded tracks are cut into [slices](/protocol/architecture/slicing) spread across [spool groups](/protocol/architecture/spool-groups) of storage nodes. [Gateways](/protocol/architecture/gateways) serve reads to the public. The [challenge mechanism](/protocol/architecture/challenges) continuously verifies that nodes hold what they claim. And the entire network state is event-sourced: every participant rebuilds it by replaying the chain.

Each section below compresses one detail page. Follow the links when you want the full story.

## Key components

Four actors make up the network:

1. **Solana programs** hold system state and perform the operations that matter for correctness: tape reservations, track registration, certification, votes, and rewards ([Solana programs](/protocol/architecture/solana-programs)).
2. **Storage nodes** are staked committee members that host spools of slices, follow the chain, and vote in their groups. They are not public read infrastructure: they serve staked peers, and users never talk to them directly ([storage nodes](/protocol/architecture/storage-nodes)).
3. **Gateways** are the network's public face. They follow the chain like nodes do, hold the object indexes, read slices from storage nodes as staked peers, and serve decoded data over HTTP to anyone ([gateways](/protocol/architecture/gateways)).
4. **Clients** are the [SDKs](/sdks) and [CLI](/tools/cli). The wallet is the identity: writes are signed Solana transactions, and there are no accounts or API keys anywhere in the protocol.

<Frame caption="Clients reach gateways over the public internet. Gateways reach storage nodes as staked peers. Everyone coordinates through the Solana programs.">
  <img src="https://mintcdn.com/tapedrive/IVlwjOpRsvR7xk5g/images/network-components.svg?fit=max&auto=format&n=IVlwjOpRsvR7xk5g&q=85&s=89933a3ae7187e2c36bbea227259699f" alt="Flowchart: clients connect through the public internet to gateways, gateways reach storage nodes as staked peers, and clients, gateways, and storage nodes all coordinate through the Solana programs." width="1110" height="197" data-path="images/network-components.svg" />
</Frame>

## The data model

One sentence per level. A **tape** is the prepaid container you reserve: capacity for a length of time. A **track** is one piece of raw data written to a tape. A coded track is cut into **slices** held by a spool group. A named track becomes an S3-style **object**, with listings and metadata.

Details: [tapes](/protocol/architecture/tapes), [tracks](/protocol/architecture/tracks), [slicing](/protocol/architecture/slicing), [objects](/protocol/architecture/objects), [spool groups](/protocol/architecture/spool-groups).

<Frame caption="A tape holds tracks. A coded track fans out into slices across a spool group. A named track becomes an object.">
  <img src="https://mintcdn.com/tapedrive/IVlwjOpRsvR7xk5g/images/data-model.svg?fit=max&auto=format&n=IVlwjOpRsvR7xk5g&q=85&s=c2c1e1859d762608f377f431e41ba581" alt="Diagram: a tape containing tracks, one track fanning out into slices across a spool group's nodes, and one named track projecting into an object listing." width="465" height="287" data-path="images/data-model.svg" />
</Frame>

## Writing

You reserve capacity once, then write. Small writes travel inside the transaction itself and are certified the moment it lands ([tape replay](/protocol/architecture/tape-replay)).

Larger writes take the erasure-coded path. The client slices the data and computes commitments locally, then registers the track on-chain, which deducts tape capacity and assigns the least-loaded spool group. The client distributes slices to the group's nodes, and each node checks its slice against the on-chain commitment before accepting it. When 14 of the group's 20 nodes have signed receipt, one aggregate signature lands on-chain and the track is certified. Certification is the network's proof of availability.

Every transfer in this path is verified against chain commitments before it's accepted. See [tracks](/protocol/architecture/tracks) for the write paths and [spool groups](/protocol/architecture/spool-groups) for placement.

<Frame caption="A coded write: local encoding, on-chain registration, slice distribution with per-node verification, aggregate certification.">
  <img src="https://mintcdn.com/tapedrive/IVlwjOpRsvR7xk5g/images/write-path.svg?fit=max&auto=format&n=IVlwjOpRsvR7xk5g&q=85&s=a920a38c90bab8649912f410697d6a2f" alt="Sequence diagram of a coded write across the client, the Solana programs, and the spool group's storage nodes: local encoding, registration, slice distribution with per-node verification, and aggregate certification." width="649" height="420" data-path="images/write-path.svg" />
</Frame>

## Reading

Finding data is a lookup: on-chain track state names the group, and the group names the nodes. A gateway fetches slices in parallel and reconstructs from the first seven valid responses it gets back, verifying each slice against the on-chain commitments and then verifying the decoded result before serving it. Nodes that are slow, missing, or dishonest get routed around.

You read through gateways. Tapenet's hosted public gateway serves light traffic free and
anonymously under [rate limits](/apis/rate-limits); sustained workloads use a paid
gateway tier or [run their own](/protocol/architecture/gateways). Clients that want proof
instead of trust can do verified reads through the [SDK](/sdks/reading). Inline tracks
can additionally be recovered from the Solana ledger itself
([tape replay](/protocol/architecture/tape-replay)).

<Frame caption="A read completes from the first valid slices to arrive, even with a node down.">
  <img src="https://mintcdn.com/tapedrive/IVlwjOpRsvR7xk5g/images/read-path.svg?fit=max&auto=format&n=IVlwjOpRsvR7xk5g&q=85&s=44b63e3e5c1c153f854e0c478b5b7b73" alt="Sequence diagram of a read across the user, a gateway, chain state, and storage nodes, with one node failing and the read completing from the remaining slices." width="590" height="390" data-path="images/read-path.svg" />
</Frame>

## Epochs

The network runs on a clock. Time is divided into [epochs](/protocol/architecture/epochs), and everything network-wide changes at epoch boundaries, by vote: committee membership, spool assignment, capacity, and pricing. Each epoch moves through four phases (sync, snapshot, active, closing), and the network never advances past an epoch whose record isn't sealed.