Flow-Like

Build Apps around typed Flows in FlowScript or on a live canvas.
Keep executable logic with its interfaces, data, packages, access, releases, and run evidence.

Try online · Download Studio · Documentation · FlowBook · Discord

Most software work starts in the middle. The database already exists. The API has quirks that never made it into the docs. A useful change still has to fit that system and remain understandable after it ships.

Flow-Like is a source-available developer platform for building and running application logic. A Flow is one executable process, and its persisted graph is the Board that the Rust runtime executes locally or on configured infrastructure.

An App is the unit a team owns and ships. It keeps Flows beside the Events and Pages that expose them, the data they use, reusable packages, members, roles, and release settings. An App Event selects a Flow entry, version, and execution location for an API, schedule, chat, form, Page, REST endpoint, MCP server, or another supported caller.

Studio is the complete desktop application. Developers use it to manage Apps, edit Flows, inspect data and packages, run logic locally, and trace results back to the Board. The browser app and configured backend provide shared access and remote execution.

Text and canvas edit the same Flow

FlowScript is the typed text form of a Flow. The canvas shows the same Flow as nodes, pins, and connections. Edits from either view update its Board.

This entry receives an incident report and chooses the log path:

use log::*

eventsGeneric triageIncident(payload: Struct, report: string) {
    const normalized = report.trim()
    if (normalized.contains({ substring: "production is on hold", ignoreCase: true })) {
        error({ message: normalized, toast: false })
    } else {
        info({ message: normalized, toast: false })
    }
}

_{Generated from the checked-in FlowScript with the real reconciler and Studio auto-layout.}

The canvas exposes the same rule as six nodes. The trim and contains calls resolve to catalog nodes, and their values travel over typed wires into a Branch node. FlowScript earns its keep during broad edits and code review. Open the canvas to trace a branch or inspect a failed run.

Studio renders the current Board as canonical FlowScript. When you apply a source edit, Studio parses it, checks it against the node catalog, and writes the change back as Board commands. The Rust runtime executes that Board.

Read FlowBook for the language concepts, worked examples, and current round-trip boundaries.

Run Flow-Like

Build from source

Install Git, mise, Tauri 2 system dependencies, protoc, and a C/C++ toolchain. Run these commands from the repository root:

git clone --branch dev https://github.com/Rheosoph/flow-like.git
cd flow-like
mise trust
mise install
bun install
cp apps/desktop/.env.example apps/desktop/.env
mise run dev:desktop

mise install supplies the toolchain declared in mise.toml. mise run dev:desktop detects the current platform and starts Studio.

Useful tasks:

mise tasks
mise run dev:web
mise run dev:docs
mise run dev:book
mise run check
mise run fix

The detailed setup guide lives at docs.flow-like.com/dev/build.

Self-host with Docker Compose

The checked-in Compose directory builds the browser app, API gateway and API replicas, Rust runtime workers, WASM compiler, realtime signaling, server-side Event services, PostgreSQL, Redis, and database initialization on one host. Studio remains the desktop application and can connect to that backend.

Start with these files:

The documented installation path is:

git clone --branch dev https://github.com/Rheosoph/flow-like.git
cd flow-like/apps/backend/docker-compose
cp .env.example .env
cp flow-like.config.example.json flow-like.config.json

../../../tools/gen-execution-keys.sh --export
# Add the generated keys, OIDC settings, public URLs, and storage configuration to .env.
# Point FLOW_LIKE_CONFIG and FLOW_LIKE_RUNTIME_CONFIG_FILE at flow-like.config.json.

docker compose config --quiet
docker compose up -d --build
docker compose ps --all

The stack expects external object storage and does not create its buckets or containers. The copied environment template currently selects AWS, while the stock API image omits the AWS runtime-credential feature. Select a provider supported by that image or rebuild the API target with the required feature. Read the complete Docker Compose installation guide before exposing the stack publicly. The optional monitoring profile adds Prometheus, Grafana, Tempo, and PostgreSQL and Redis exporters.

Runtime requirements stay with the Flow

Before a run starts, Flow-Like's pre-run analysis walks the complete Flow and reports the runtime variables, OAuth requirements, local-only nodes, and WebAssembly permissions it finds.

The App Event and Board modes currently select local or remote execution. Pre-run reports when any node, including one inside a nested layer, requires local access. The current dispatcher does not yet reject every incompatible remote selection from that aggregate flag. A single run remains in one environment, and device-local secret values stay outside the Board and remote payloads.

A Board can run in Studio or on configured remote runtimes. The maintained self-hosting guides cover Docker Compose and Kubernetes. Backend directories also contain deployment work for AWS, Azure, and GCP; check each target's documentation and status before relying on equivalent behavior.

Start with the system you have

Typed catalog nodes connect Flows to the services and data already in use, including local files and devices. Reusable packages put a domain operation behind declared inputs and outputs. The current system can keep owning its data while a Flow validates input or coordinates calls.

Start with the integration that costs the team the most time. If it fails, run evidence points back to a node on the Board. Capability declarations show what that operation needs from the host.

App Events expose a pinned Flow entry to callers without duplicating its logic. Pages and APIs can reuse the same Flow, while model calls remain explicit typed nodes with node-attributed run evidence. Supported models can run locally when their runtime and files are installed, or through a configured provider.

Find your way around the repository

Flow-Like is a Rust and TypeScript monorepo. Bun manages the JavaScript workspace, Tauri hosts the desktop client, and the runtime and core application model live in Rust.

Extend the platform

The catalog turns each supported operation into a node with typed pins. For domain-specific work, add a native node or package the operation as a WebAssembly component with declared host capabilities. The templates cover fifteen source languages; host API support varies by language and template maturity.

Applications can also control the platform through the TypeScript SDK and Python SDK.

License

Flow-Like is source-available under the Business Source License 1.1. The Additional Use Grant permits use that does not compete with Flow-Like or substantially similar Rheosoph products. Entities with more than 2,000 employees or more than €300 million in annual revenue need a commercial license. For each version, MPL 2.0 takes effect on the earlier of the stated eight-year Change Date or the fourth anniversary of that version's first public distribution.

Contributing

Code and documentation contributions are welcome.

• Browse good first issues.
• Open pull requests against dev and run the checks relevant to your change.
• Use GitHub Discussions or Discord when you want to talk through an approach.

Website · Documentation · FlowBook · License · Code of Conduct · Security

_{Built in Munich, Germany.}