One graph.
Every projection.
A program is a graph — it always was. Text is a one-dimensional, lossy serialization the compiler has to rebuild. flowG keeps the graph as the source of truth, and treats every language as a projection of it.
Text is one projection of something deeper.
Variables, functions, types — nodes. Calls, owns, borrows, returns, contains — edges. The source file was always a flattened view of this graph. In 1945 the only I/O device was a teletype, so text was all we had; for eighty years that accident of history became an axiom. flowG drops the axiom and makes the graph canonical.
Interactive — drag to rotate. The same structure a text file serializes and the compiler rebuilds.
22 universal primitives.
A closed, fixed vocabulary for every programming pattern. Not an extensible library — a complete kernel. Every programming pattern in every language composes from this fixed set.
11 wire kinds.
Resource semantics carried by the edge itself — ownership, borrowing, channels, streams, errors, laziness, feedback. The things text throws away. Bugs that take hours to find in text — use-after-free, data races, dangling references — become structurally impossible in a well-wired graph.
When the graph runs, it rewrites itself.
This is the oldest rigorous form of "the graph is the program" — interaction nets (Lafont, 1990), where computation is local graph rewriting that is inherently parallel. No central instruction pointer marching down a line: nodes react where they meet. See the fifty-year lineage →
Interactive — nodes annihilate and commute. The same reduction model maps cleanly onto parallel silicon.
One graph → any language.
flowG isn't a fixed number of languages — it's the omni-language. Its own surfaces (Lux, JMax, Joule) and any language with a tree-sitter grammar are the same graph wearing different syntax. Materializing source is a deterministic, pure function from graph to text — roundtrip-tested, no model in the loop — so the projections never drift.
Not generate, not transpile — materialize. There is no inference step and no token sampling. The emitter is a pure function from graph to text, so every projection is exact and they never drift from one another.
flowG’s own surfaces are languages too — uncounted, because the point isn’t a number. We are all languages.
To many silicons.
The same graph lowers to compute backends — native, GPU, and browser — through OpDispatch, routed to the lowest-joule target.
Every op, metered in picojoules.
Every operation carries a measured picojoule cost; placement prefers measured calibration over the analytical prior, and you get a joule receipt.
total: 8.42 μJ · placement: min-joule · determinism: strict
Horowitz 2014 energy table, operationalized as a per-op placement pass.