Flow editions

Flow is one platform delivered through several editions (form factors). Every edition shares the same Rust orchestration core and catalog-driven node registry. What differs is the shell, the execution locus, and the client surface.

Edition	Surface	Execution locus	Status
Flow Studio	Desktop app (Tauri shell)	Local machine	Current
Flow Code	VS Code sidebar	Local machine (in VS Code)	Shipped
Flow Code (JetBrains)	IntelliJ Platform plugin	Local machine (in the IDE)	Planned
Flow Server	Browser (remote)	Private cloud instance	Available
Flow CLI	Terminal / CI	Local machine, headless	Preview
Flow Mobile	Mobile app	-	Exploratory
Flow Edge	Edge deployment	-	Exploratory

Flow Studio

Flow Studio is the desktop edition. It is the shipped foundation the other editions build on. Local inference stays zero-egress by default. Cloud AI and service-node APIs are opt-in carve-outs that are off by default. They are gated by settings, and credentials are kept in the OS keyring. Studio documentation.

Flow Code

Flow Code is the VS Code edition. It is a native sidebar that generates a Flow DSL from a prompt, runs it on the shared orchestration core in the open editor, and lets the model monitor and repair the run. The workspace is pinned to the open VS Code folder, and the engine owns every file and shell action. The core runs out-of-process as a JSON-RPC sidecar. Flow Code documentation.

Flow Code (JetBrains)

This is the same Flow Code edition re-hosted as an IntelliJ Platform plugin, so it runs natively in IntelliJ IDEA, PyCharm, WebStorm, GoLand, and the other JetBrains IDEs. It is a parallel host rather than a fork: it reuses the same out-of-process core sidecar and the same webview bundles unchanged, re-hosts them in JCEF, and rebuilds only the editor-host glue in Kotlin. It is planned and not yet shipped. The VS Code edition remains the shipped reference.

Flow Server

Flow Server is the same platform as Flow Studio. It is hosted on your own private cloud instance and reached remotely in a browser instead of running on your machine. The engine, node registry, and local-inference model are identical. Inference still runs inside the private instance and is never sent to a third-party model service, so the zero-egress posture holds. Only the compute location and the access path change. Server documentation.

Flow CLI

Flow CLI is a headless runner that executes Flow DSL directly on the shared Rust core, without the desktop shell, for terminals and CI. It also includes a full-screen TUI. It is distinct from the planned Flow export / Code Generator, which transpiles a flow away from the runtime into a standalone script. Flow CLI keeps the runtime and runs the .flow document natively. CLI documentation.

Flow Mobile and Flow Edge

These are exploratory editions in early planning. They slot into the same structure rather than forking it. Flow Mobile is the mono UI in a Tauri mobile shell, with IPC to an in-process core, like Studio. Flow Edge is the server binary deployed at the edge, serving the mono UI over HTTP/SSE. It works like Flow Server but in a different locus.

Shared settings

Every edition reads and writes the same ~/.flow-studio/settings.json and surfaces those settings through its own interface, so a change made in one edition is read by the others. See the settings reference.

One UI, one backend

Every edition is built from two shared pillars instead of per-edition forks:

• The mono UI is the single React app every edition renders. Desktop and mobile render it in Tauri, and Server and Edge render it in the browser.
• The mono backend is the canonical HTTP/SSE server over the shared application core for the server-class editions.

A host facade in the UI is the seam that lets the one UI target either transport, selected at runtime. The transport is either Tauri IPC, for desktop and mobile with an in-process core, or HTTP/SSE, for browser and edge. The managed local-model engine is fetched once per host and reused by every edition on it.

Edition	UI surface	Transport	Backend
Studio (desktop)	mono UI in Tauri	Tauri IPC	core in-process
Code (VS Code)	native sidebar	JSON-RPC sidecar	core out-of-process
Server (browser)	mono UI in browser	HTTP/SSE	server binary
Edge	mono UI SPA at edge	HTTP/SSE	server binary (deployed)
CLI	-	direct	core in-process
Mobile	mono UI in Tauri mobile	Tauri IPC	core in-process