Chapter 00 — the manual opens here

The working terminal.

t0 is a fictional open-source deploy CLI, and this page is its manual. The terminal below is real in every way except one — it runs entirely in this page. Type help and press Enter.

t0 — simulated sessionSIMULATED — no real infrastructure

t0 — the two-command deploy CLI. simulated session.

everything below runs in your browser. no network, no infrastructure.

type 'help' and press Enter. ↑/↓ walks history, Tab completes.

every line of output is produced by this page — zero network requests·output is illustrative for a CLI that does not exist·Chapter 04 lists every command

what “simulated” means: commands are parsed and answered by JavaScript in your browser. Nothing is uploaded, deployed or executed anywhere. The point is to teach the workflow, not to pretend.

Chapter 01 · one binary, no dependencies

Install.

t0 ships as a single static binary. The install is the whole install — no runtime, no daemon, no account.

Install methods

Pick one line. The shell script verifies the checksum, puts the binary on your PATH, and prints the version when it finishes. Homebrew and npm wrap the same binary.

install — pick one

# one static binary, three ways to fetch it — pick one
curl -fsSL https://get.t0.dev/install.sh | sh
brew install t0
npm install -g @t0/cli

illustrative — t0 is fictional, so the URL, formula and package are placeholders that would exist if the CLI were real

Verify the install

Any t0 subcommand that works offline is a good smoke test; the version line is the cheapest. If this prints, the binary runs and the manual below applies to it.

verify

$ t0 --version
t0 version 0.4.2-simulated
build 2026-10-22 · platform web-demo

expected output, shown exactly as the simulated terminal prints it

Chapter 00’s terminal implements this command — run it there before reading on.

Chapter 02 · the pipeline, stage by stage

Deploy.

One command, three stages. Each stage below shows the command that drives it, the output it prints, and the reason the stage exists.

Anatomy of a deploy

figure 02·a — click a stage, or focus it with Tab and step with ←/→.

t0 init demo

→ resolving template "static-site" for demo/
✓ wrote t0.toml          (routes + edge regions)
✓ wrote src/index.html   (hello, edge)
✓ wrote README.md        (what t0 just did, in order)

next: t0 deploy demo --edge
example output — simulated

A t0 project is a plain directory. t0 init writes a t0.toml that names the project, maps routes to files, and lists the edge regions to announce to. Nothing else — no manifest, no lockfile ritual. The repo stage is the only one that touches your disk.

stage 1 of 3 — repo

How a request moves

After a deploy, the happy path never touches an origin server. The visitor’s request lands in the edge region nearest them; the region holds the immutable artifact; the artifact is the site. Regions fetch from the artifact store exactly once per hash — after that, every response is served locally.

figure scrolls →

figure 02·b — immutability is what makes the miss path boring: a hash never changes, so “stale” is impossible.

Chapter 03 · one file, four decisions

Configure.

Everything t0 knows about your project lives in t0.toml at the project root. Four decisions, all visible, none hidden behind defaults you didn’t choose.

demo/t0.toml

name = "demo"

routes = [
  { path = "/",       file = "src/index.html" },
  { path = "/about/", file = "src/about.html" },
]

[edge]
regions = ["fra1", "sin1", "iad1"]
immutable = true

example configuration — illustrative, like everything else on this page

name: The project identifier. It names deploys in t0 status and prefixes log lines. It is not a domain — t0 never invents URLs for you.
routes: Path-to-file pairs, matched in order, most specific first. A route points at a file that exists in the project; the build fails with exit code 2 if it doesn’t.
edge.regions: The regions a deploy is announced to. t0 deploy --edge announces to all of them; without the flag, only the first is used (the preview target).
edge.immutable: Content-addressed artifacts. On (the default), artifact names are content hashes and rollbacks are re-deploys of an older hash. Turn it off only if you enjoy invalidating caches by hand.

Environment variables

t0 keeps environment variables out of artifacts on purpose. At build time, the shell provides them. At request time, the edge serves static files only — there is no runtime to hold a secret, so there is no secret to leak. If a page needs live data, it calls an API from the client; the manual for that API is not t0’s to write.

Chapter 04 · the complete surface

Reference.

Every command, flag and exit code the simulated CLI implements. Each row is exercised by the Chapter 00 terminal — the manual and the demo cannot drift apart, they are generated from the same list.

Commands

Command	What it does	Example
help	List every command the demo implements, with usage.	help
t0 --version	Print the CLI version and build line.	t0 --version
t0 init <name>	Scaffold a static-site project: t0.toml, an index page, a README.	t0 init demo
t0 deploy <name> [--edge]	Build the project, upload an immutable artifact, map routes, announce to edge regions.	t0 deploy demo --edge
t0 status	List recent deploys for the current project, newest first.	t0 status
t0 logs --tail N	Print the last N lines of the most recent deploy log.	t0 logs --tail 20
clear	Clear the terminal. Ctrl+L does the same.	clear

Flags

Flag	Attaches to	What it does
--edge	t0 deploy	Announce the artifact to all configured edge regions, not just the first.
--tail N	t0 logs	How many log lines to print. Whole number, 1–10000.
--version	t0	Print the version. -v is the short form.
--help	t0 / help	Print the command list. -h is the short form.

Exit codes

Code	Meaning
0	The command did what it said.
1	Usage error — missing or malformed arguments. The error line tells you the exact usage.
2	Build failed. The log (t0 logs --tail 20) holds the reason above the failure line.

this page documents a fictional CLI — the terminal implements a compatible, simulated subset, and nothing here executes real infrastructure