The map
Flux is a total, causal, deterministic application language for the web platform, documented across a Guide you read in order and a Reference you land in from search. This page is the index to both: every page on the site, grouped the way the left navigation groups it, each with a one-line statement of what it covers. Where the Overview states the model in prose, this page hands you the whole table of contents and the shortest path to the page you actually need.
Two doors, one book. The Guide teaches the language as a narrative, one runnable idea at a time; the Reference — split into The Language, the Language Spec, the FVM and the FDK — specifies it exhaustively for random access. Support pages sit beside both.
New here? Start with Guide §1 — What is Flux? →
Reading paths
Pick the path that matches why you are here; each names the pages to read in sequence.
- New to Flux — read the Guide in order. It opens with What is Flux?, Why Flux is built this way and Your first session, then builds through streams, kinds, clocks, signals, the four planes, scenes, applications and trust to Where to go next.
- Writing programs — start from the Cookbook, reach for the FDK overview when you need an API, and keep the language spec — Kinds, Operators, Grammar — at your elbow.
- Evaluating the guarantees — read Guarantees, then Compiler & runtime for how each one is enforced and machine-verified, with Kinds for the type system the rest leans on.
- Extending the host — representations, tools and panes are covered in Host integration.
Figure — the two doors and the reference pillars, and how a reader crosses between them.
Landing
| Page | Covers |
|---|---|
| Flux | The one-page introduction: the mental model, one line of code, and the doors into the Guide and Reference. |
The Guide
The Learn door — fifteen linear chapters, each teaching one idea and closing with a down-link to the formal rules.
| Page | Covers |
|---|---|
| §1 — What is Flux? | The mental model, what programs look like, where they run, trust tiers, honest non-goals. |
| §2 — Why Flux is built this way | The design pillars, from intuition: total, causal, byte-deterministic, dimensional, fire-walled, capability-secure, optimizable. |
| §3 — Your first session | From one line to parameters, composition, state, multi-timeframe, canvas and a first app. |
| §4 — Streams, delay and running state | Values as streams, delay, windows and scan — how state is expressed without mutation. |
| §5 — Kinds — types that carry meaning | Kinds as dimensions, and how a kind alone infers the presentation. |
| §6 — More than one clock | Clocks, @, causality and multi-timeframe composition. |
| §7 — Signals, marks and alerts | Turning computed streams into signals, on-chart marks and alerts. |
| §8 — The four planes | ANALYSIS / CANVAS / TRANSITION / APP and the one-way firewall between them. |
| §9 — A scene that moves | Building a canvas scene and animating between computed states with transitions. |
| §10 — Building an application | The Elm-architecture core: messages, subscriptions, commands, slots. |
| §11 — Determinism, replay and trust | Why replay re-derives the same numbers and the same scene, and what that buys you. |
| §12 — Working in the editor | Kind-aware completion, hover docs, live preview, dataflow debugging. |
| §13 — Cookbook — recipes that run | Working recipes for every aspect of the language. |
| §14 — What Flux deliberately doesn’t do | The deliberate non-goals and the trades behind them. |
| §15 — Where to go next | The onward paths into the Reference, by what you want to do next. |
Reference · The Language
The model, the pillars, the planes, and the ground rules that run through every other page.
| Page | Covers |
|---|---|
| Overview — a dataflow language | What a Flux program is, the four planes, the FDK, and the range one runtime stands behind. |
| The map | This page — every page on the site and the paths through them. |
| The seven design pillars | Total, causal, byte-deterministic, dimensional, fire-walled, capability-secure, optimizable — one by one. |
| The four planes & the firewall | ANALYSIS / CANVAS / TRANSITION / APP, the one-way firewall, and live(), in depth. |
| Non-goals (v1) | What Flux does not attempt, and why each boundary is deliberate. |
| Conventions & notation | How kinds, error codes, invariants and sample annotations are written throughout the docs. |
| Implementation status | What is implemented versus sealed-design-staged, and the meaning of the inline status labels. |
Reference · Language Spec
The normative specification of the ANALYSIS plane and the plane surfaces — grammar, kinds, operators, inference, time, canvas, transitions and the app harness.
| Page | Covers |
|---|---|
| Lexical structure | Tokens, literals, interpolation, keyword tiers, newline rules. |
| Grammar | The normative grammar, the single arrow’s five readings, precedence, formal properties. |
| Kinds — the dimensional type system | Sorts, the lattice, coercion, tags, named types — the canonical home of the kind algebra. |
| Operators | The dimensional algebra of every operator; UFCS; with; the ? family. |
| Inference & the error policy | Kind inference, presentation inference (kind → pane/scale/guides), and the error policy. |
| Time & state (Analysis) | Streams, delay, windows, scan, clocks and @, causality, live(). |
| The Canvas plane | Signals as properties, spaces, events → actions, primitives, the performance model. |
| The Transition plane | Morph, replay, focus, view — cosmetic interpolation between computed states. |
| The App plane | The Elm-architecture core, messages, subscriptions, commands, slots, capabilities. |
Reference · The FVM
How Flux runs: the two engines behind the one contract, memory, optimization, concurrency, host integration, packaging and the verification that ties them together.
| Page | Covers |
|---|---|
| Overview — two engines, one contract | The interpreter and the WASM backend, and the contract that makes them interchangeable. |
| Compiler & runtime | The pipeline, interpreter ≡ WASM (I7), pinned routines, budgets, the verification harness. |
| The optimizer | The correctness law, translation validation, tiers T0–T3, the cost model. |
| Memory model | Value representation, SoA columns, the liveness plan, slotmaps, arenas, linear memory. |
| Concurrency & the 1≡N proof | Scheduling the pure DAG, barriers vs work-stealing, 1 ≡ N byte-equality. |
| Host integration | The five descriptors, open registries, representations, extension seams. |
| Packages & distribution | fluxpack, content addressing, minimal version selection, capability aggregation. |
| Verification & reproducible builds | The harness, the golden corpus and differential tests, and reproducible-build proofs. |
Reference · The FDK
The Flux Development Kit — the standard prelude and the pillar APIs, all bounded, capability-gated, and specified to the same determinism bar as the core.
| Page | Covers |
|---|---|
| Overview & the prelude | Prelude, namespaces, doc-as-data, the capability model, status matrix. |
| compute | math/stat/vec/decimal/time/ta, Table/Col/Mat dataframes, domain libraries. |
| collections | Vec/Deque/Map/Set/Tree — bounded, ordered, value-semantic. |
| units | meas[u] quantities: conversions, affine point/delta, walls. |
| asset & currency | Asset tags (B,Q[,@v]), fx and money, venues, toSource. |
| text | string, str/fmt, the Md codec, editing, highlighting, diff, search, validators. |
| i18n | Locales, message catalogues, MessageFormat 2, collation, RTL. |
| color | The color kind, construction, OKLab interpolation, output channels. |
| display | Scenes as values, the two strata, 2D/3D models, viz.*, panes, tool bindings. |
| net | Verbs, transports, codecs, streams, backpressure, presets, cache/offline. |
| host-services | Files, clipboard, notifications, auth, payments, media, print, fonts, embedding. |
| server | Headless apps, shared storage with tiered ACLs, prerender, the third determinism leg. |
Support
Beside both doors: what is promised, the common questions, and every term defined.
| Page | Covers |
|---|---|
| Guarantees | What is guaranteed, and how each guarantee is enforced and machine-verified. |
| FAQ | Common questions answered by the model, and the deliberate non-goals. |
| Glossary | Every term, precisely defined. |
See also
- Overview — a dataflow language — the model stated in prose, if you want the idea before the index.
- Conventions & notation — how kinds, error codes and invariants are written across every page.
- Implementation status — what is implemented versus sealed-design-staged.
- Guide §1 — What is Flux? — the start of the linear path through the same material.
- Kinds — the dimensional type system — the type system everything else leans on.
- FDK overview — the libraries and the capability model.