#Overview — a dataflow language

Flux is a total, causal, deterministic application language for the web platform. This page is the lookup face of that identity: what a Flux program is, the four planes it is built from, the kit that ships with it, and the range of applications one runtime stands behind. It states the model and points onward — the pillars behind each property are catalogued in The seven design pillars, the planes are specified in The four planes & the firewall, and the full reading map lives in The map.

New here? Start with Guide §1 — What is Flux? →

#A program is a dataflow graph

A Flux program is not a sequence of instructions. It is a typed dataflow graph: every value is a stream, every stream carries a kind — its dimension, not only its shape — and the engine, not the author, owns evaluation, incrementality, memory and scheduling. You describe what each value is and how it relates to the others; the runtime decides when to compute it, how to update it incrementally, and where it lives in memory.

Because kinds track meaning rather than storage, one line is enough to see the character of the language:

plot rsi(close, input(14))   // osc(0,100) → its own pane, 0–100 scale, 30/70 guides, params UI — all inferred

rsi(close, input(14)) is a bounded oscillator, osc(0,100). From that kind alone the compiler infers the presentation — a dedicated pane, a 0–100 scale, the 30/70 guides, a parameter control for the 14 — with nothing configured by hand. The dimensional type system that makes this possible is specified in Kinds.

#The four planes and the firewall

Four cooperating planes separate what a program computes from what it shows, how it animates between states, and how it interacts and persists:

• ANALYSIS — the pure computation: streams, kinds, the dataflow graph.
• CANVAS — what the program shows.
• TRANSITION — how it animates between computed states.
• APP — how it interacts and persists.

A one-way firewall runs between them: downstream planes read upstream results but can never write back into what a program computes. This makes the core guarantees — totality, causality, determinism — structural rather than disciplinary: they hold by construction, not by convention. The planes, the firewall and live() are specified in The four planes & the firewall.

Figure — the four planes and the one-way firewall between them.

#The FDK

The language ships with the FDK (Flux Development Kit): the standard prelude and the pillar APIs — compute (dataframes, statistics, domain math), collections, color, text, i18n, units, networking, display, host services, the server plane, and asset/currency identity. All of it is bounded, capability-gated, and specified to the same determinism bar as the core, so a library call carries the same guarantees as a language primitive. The API surface and the capability model are catalogued in the FDK overview.

#One VM, many applications

One dataflow VM stands behind many kinds of application — a live chart, an interactive interface, an animated scene, a server-checked game — because the four planes span compute → show → animate → interact. The breadth is real, and so is the boundary: Flux is specialized — reactive, visual, deterministic, client-side — over that broad domain. It is not a general-purpose systems language and not a backend, and the non-goals drawing that line are as deliberate as the features. The flagship domain is financial charting and market analytics — which is why many examples plot prices — but nothing in the model is specific to markets: the streams, planes, kinds and determinism read the same to an author who has never traded.

#See also

• The seven design pillars — the properties behind the model, one by one.
• The four planes & the firewall — the planes and the one-way firewall in depth.
• The map — every page, and the path through them.
• Kinds — the dimensional type system everything else leans on.
• FDK overview — the libraries and the capability model.
• Guarantees — what is promised, and how each promise is machine-checked.