Where Flow is at: 0.11.0, self-hosting, and what's next

I want to talka about the current state of the Flow language.

Flow is a statically typed, compiled language where the primary abstraction is how a system evolves through time. For instance, you can describe state and dynamics, and the compiler converts the description to machine code.

flow Pendulum {
    state angle: f64 = 0.5
    state velocity: f64 = 0.0
    param damping: f64 = 0.3

    angle evolves as velocity
    velocity evolves as -9.81 * sin(angle) - damping * velocity
}

That's a complete program. The compiler hands the right-hand sides to an RK4 solver and runs them at native speed. There isn't a glue layer between the model and your application.

Language. Generics via monomorphization, enums and ADTs as tagged unions, pattern matching with guards, alternation and nested struct patterns, traits, closures with automatic by-value capture, Option and Result.

Algebraic effects. Effects, capabilities and handlers. Statically bound handlers get devirtualized in the C backend, so in the common case the abstraction costs nothing at runtime. This is the feature I'd point at first if someone asked what Flow has that its neighbours don't.

Evolution constructs. flow blocks with x evolves as expr lower to an Euler or RK4 stepper. when x reaches 0 { x becomes expr } gives you hybrid guard and reset semantics. every 1 ms { } gives discrete time blocks with time-typed literals. Units of measure carry through the type system, so dimensional mistakes are type errors.

Backends. C by default, no LLVM required. MLIR as a co-equal CPU path, WebAssembly, Metal and WGSL for GPU, and MLIR to SPIR-V.

Self-hosting. flowc is the compiler written in Flow. All 17 modules of compiler/src emit C that cc accepts with zero diagnostics, the resulting binary passes flowc's own tests, and it reproduces itself three generations deep under CI. flowc is already the default host for flow run and flow compile. There's a checked-in bootstrap C file, so you can build a working compiler with no Python involved.

Standard library. Around 110 modules: autodiff, BLAS, DSP, RF and IQ signal types, memory and arenas, collections, POSIX, networking, concurrency, strings, GPU memory, a software 3D renderer, statistics and experiment support.

Tooling. LSP with diagnostics, hover, go to definition, find references and rename. REPL, formatter, package manager, JIT, debug builds, a VS Code and Cursor extension, and a fuzzing harness wired into CI.

Examples. 403 domain examples outside the proof corpus, with recorded GIF galleries for games, morphogenesis, neurodynamics, evolutionary biology, planet generation, procgen and 3D. Over 100 of them are compiled to WebAssembly and run in a browser. The galleries are the fastest way to get a feel for the language, and honestly they're the part I enjoy building most.

Performance. On fib, n-body, matmul and spectral norm, Flow lands within noise of C at -O3, and in a couple of cases slightly ahead. Same machine, same flags, numbers are in the repo.

Install:

brew tap flooooooooooow/flow && brew install flow

What's new in 0.11.0

The headline is zero-bridge C interop. Four directives:

Directive	Purpose
`@cImport("header.h")`	Parse a C header and expose its declarations
`@cInclude`	Emit an include without a Flow-side binding
`@cEmbed("...")`	Emit raw C verbatim into the generated output
`extern type` / `cfn(A) -> R`	Opaque C types and plain C function pointers

The idea is that using a C library should not require hand-writing a binding layer first. Point at the header, get the declarations.

We originally wrote the C header parser in Python, then ported it to Flow as compiler/src/c_parser.flow, using flowc to do the job. There are BLAS and LAPACK bindings running on Accelerate on macOS and OpenBLAS on Linux.

The rest of 0.11.0 is flowc catching up on language surface: top-level let, effect and capability blocks, generic structs, c64 and c128 complex types, fixed-size array struct fields, extern block signatures, and about thirty other parser and codegen gaps. Unglamorous work, but it's the thing standing between here and dropping Python.

Also in this release: the RF and DSP groundwork (rate-typed Signal<R>, quantity literals, |> pipelines with compile-time stage fusion), WCET and stack depth analysis, and MISRA 17.2/17.4 enforced at type-check time. Full notes are in the changelog.

Roadmap

Near term

Finish flowc coverage so it handles the full language surface, then take Python off the compile critical path for good. That's the last self-hosting phase, plus packaging and release CI.

Two MLIR bugs are blocking the JIT path for a handful of examples. While loops fail the mlir-opt verifier with a cf.cond_br operand mismatch, and arithmetic over indexed ptr<f64> loads emits an f32-typed load. Both have small repros.

Physical systems

The thesis behind Flow is a compiler that understands units, sample rates, timing, memory topology, hardware and precision as part of the type system. The path there runs RF to satellite in phases:

Phase	Focus	Status
W0	RF units, quantity literals, complex and IQ, rate-typed `Signal<R>`	near complete
W1	Fuseable DSP pipelines, rate analysis	partial
W2	MMIO and SVD, bitfields, fixed point, saturating arithmetic	open
W3	Bare metal and RTOS, interrupts, state machines	open
W4	Identical code in simulation and deployment, digital twin	open
W5	`@hardware` to RTL, clock domain crossing, deploy partitions	open
W6	Fault and radiation handling, `--profile flight`	partial

Extending the core abstraction

Four things I want on top of flow blocks:

Composition: nested flow instances and connect { a.out -> b.in } wiring
analyze Foo { poles stability controllability } over any flow
represent linear: autodiff-based linearization of flow dynamics
always { } and never { } invariant blocks, runtime-checked first, static later

Longer term

GPU autodiff, real MLIR optimization passes (vectorization, inlining, DCE, constant propagation), a SIMD intrinsics module, Windows graphics verified on real hardware, statement-level debug info, and a package registry once there's actual third-party demand for one.

Rough edges

Being straight about where it's weak:

207 of 1193 checked example files fail to parse. Most sit under examples/verify/, a proof corpus deliberately written ahead of the verification keyword parser. It explores notation that is still design spec. The number looks worse than it is, but it isn't zero either.
Graphics is solid on macOS, SDL2 on Linux. Windows shares the SDL2 path but has never been smoke tested on real hardware.
Escaping closures returned from a function still don't have a uniform ABI.
Strict mode doesn't yet type lambda-typed variables or closure calls.
We've deliberately chosen not to include type inference just yet.