The idea is older than
the tooling that buried it.
“Code is structure, not text” is one of computing’s oldest recurring dreams. It has been invented, half-built, and shelved for fifty years — each time defeated by the same thing: human friction with anything but a line of characters. flowG doesn’t claim to have invented it. It builds the thing all of this work has been circling — now that the obstacle is lifting.
Why the line won.
When von Neumann described the stored-program computer, the only I/O device was a teletype. Text was all we had. Fetch one instruction, execute it, fetch the next. For eighty years that accident of history hardened into an axiom — text editors, parsers, formatters, diffs, version control, an entire civilization of tools built on one assumption: code is a stream of characters.
Everything else became a graph.
The silicon is parallel. The computation is a parallel graph. The intelligence we built on top — attention — is graph-structured. At every layer the world is relational and multidimensional. Only the source code still pretends it’s a line. flowG removes the pretense and works at the structure directly.
Six threads, fifty years.
flowG is a synthesis, not a bolt from the blue. Each of these communities found a piece of it. The contribution is connecting them — and adding energy as the spine.
The first machines and languages where computation is a graph of operations that fire when their inputs are ready. Forty years of evidence: programs-as-graphs ship and win in domains that are intrinsically dataflow — signal processing, instrumentation, control, ETL.
lessonGraphs win where the work is dataflow. They stalled on branchy, stateful control — a UX problem, not a theory problem.
The most rigorous form of “the graph is the program”: computation is local graph rewriting that is inherently parallel. No instruction pointer marching down a line — nodes react where they meet, and independence is parallelism for free.
lessonA reduction model maps onto parallel silicon more naturally than a sequential one ever could.
The cleanest break from text-as-truth: every definition is identified by the hash of its syntax tree. Names are just labels, there are no source files in the usual sense — so no merge conflicts, perfect caching, trivial code mobility, and an effects system in the same spirit as resource-typed wires.
lessonThe closest existing answer to “let a machine mutate code without breaking the build.”
Edit the tree, not the characters — so a program is never syntactically broken. Simonyi’s “intentional tree with text as one projection” is almost exactly flowG’s thesis, thirty years early.
lessonIt never beat text for humans — and the reasons were all human (typing speed, text-shaped tools). Move the human out of the editing loop and the objection dissolves. That is why the idea is alive again.
Machine learning rebuilt all of this for tensors: trace a program into a graph, then lower one graph to many backends. JAX is explicit about it — Python is a frontend to a graph.
lessonOne-graph-many-silicons is table stakes for tensors. flowG’s contribution is generalizing it beyond tensors — to all code — with resource-typed wires and energy as a first-class unit.
The much-cited table that put hard picojoule numbers on primitive operations: an 8-bit add costs a sliver of a pJ; a DRAM access, hundreds to thousands of times more. Data movement, not arithmetic, is where the joules go.
lessonflowG operationalizes that table as a placement pass — route each op to the lowest-joule silicon, and hand back a receipt.
The rigorous root of “the graph is the program” — local rewriting, inherently parallel.
The field keeps rediscovering the substrate.
Recent research keeps finding, empirically, that under the syntax of every language there is a shared, language-agnostic structure — and that operating on it works better. These aren’t flowG’s results; they’re the ground it’s built on.
Code embeddings contain separable syntax and language-agnostic semantics; remove the syntax part and downstream tasks improve.
arXiv:2310.16803LLMs develop a shared representation across languages and modalities — the same semantic region for Chinese, arithmetic, and code.
arXiv:2411.04986Forcing code models through a shared intermediate representation gives consistent multilingual gains.
arXiv:2403.03894Language-agnostic graphs reach 94% F1 on compiler analysis across six source languages — graphs beat sequences for program understanding.
arXiv:2003.10536Control-/data-flow graphs from one language improve code generation in another — graphical structure transfers.
arXiv:2405.02355Routing through a universal pseudocode before emitting target languages improves generation. Even a naïve substrate helps.
arXiv:2406.16441Each validated a piece in isolation — embeddings, intermediate representations, read-only graphs, pseudocode. The remaining work was to make the graph the source of truth, give it resource-typed wires, and meter it in joules.
The obstacle was always the human. The human is leaving the loop.
Projectional editing lost to text because people type faster in characters and every tool — diff, review, blame, the terminal — is text-shaped. None of those frictions bind a machine. At the same time the hardware is finally parallel everywhere, WebGPU put compute in the browser, and the energy cost of getting it wrong has become impossible to ignore.
So this is not a claim of novelty. It’s a claim of timing — and of cause. We’re building the thing fifty years of brilliant work has been circling, in the open, because energy-efficient compute is worth building. Stand on the shoulders; carry it the last step.