flow-like

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.

See how a source edit becomes Board commands

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 runs the browser app, API gateway and API replicas, the execution manager with disposable gVisor sandboxes, queue bridges, WASM compiler, realtime signaling, server-side Event services, PostgreSQL, Redis, and bundled RustFS object storage on one Linux host. Studio remains the desktop application and can connect to that backend.

Start with these files:

The stack runs the published images ghcr.io/rheosoph/flow-like-docker-compose- at the tag in FLOW_LIKE_IMAGE_TAG (default dev). The self-hosted packages are public, so no registry login or Rust toolchain is needed. The documented installation path is:

git clone --branch dev https://github.com/Rheosoph/flow-like.git
cd flow-like/apps/backend/docker-compose
python3 scripts/setup-env.py
cp flow-like.config.example.json flow-like.config.json
# Replace the OIDC and domain placeholders in flow-like.config.json and point
# FLOW_LIKE_RUNTIME_CONFIG_FILE in .env at it. setup-env.py already generated
# the signing keys and service credentials.

python3 scripts/pull-images.py        # optional: pin every image to a digest, e.g. --tag 1.4.0
python3 scripts/preflight.py
python3 scripts/up.py
docker compose ps --all

pull-images.py pins the nine first-party images and the sandbox references to repository@sha256:… digests; the default per-run isolation mode requires those immutable references. To run unpublished code instead, build locally with python3 scripts/prepare-images.py for the runner and manager images and python3 scripts/up.py --build for the rest.

The template selects the bundled RustFS S3 store with STORAGE_PROVIDER=aws, and the published API image includes the AWS runtime-credential feature. Configure an external provider only when needed. 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.

Self-host on Kubernetes

The Helm chart deploys the same components across a cluster, defaulting to ghcr.io/rheosoph/flow-like-kubernetes- and the shared Compose images at tag dev. Isolated execution requires digest pins for the manager and executor:

cd flow-like/apps/backend/kubernetes
./scripts/setup-config.sh
./scripts/resolve-images.py --tag 1.4.0   # resolves digests through the registry API, no Docker needed
./scripts/deploy.sh -f helm/values-production.yaml -f values-operator.yaml

resolve-images.py accepts --pull-secret for forks and private mirrors and --arch for single-architecture node pools. For local evaluation, ./scripts/dev.sh setup creates a k3d cluster and scripts/build-images.sh builds the images into it. Read the Kubernetes installation guide for prerequisites such as gVisor and Cilium.

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 pul