logo
Typed • Blazing fast • Robust

Typed workflows that scale

Design reliable systems with type‑safe graphs, Rust‑level performance, and built‑in governance. Run locally for a head start, then move to edge or any cloud without rewiring.

🧩 Type-safe graph contracts 🔒 Governance & observability ⚡ Rust runtime • predictable latency ☁️ Run local → edge → cloud

Want AI too? Blend classical ML with GenAI when it helps — it’s one more set of typed nodes, not a separate stack.

Preparing something amazing...

Please wait while we prepare everything

;
Prototype → Production

Zero-to-prod, by design

The graph you sketch is the graph you deploy. Typed ports, preflight validation, and a deterministic Rust runtime mean no throwaway prototypes, no glue-code rewrite, and no surprises when you flip from dev to prod.

Production-ready by default

Preflight checks catch schema and wiring issues before run. The same typed graph ships across dev → staging → prod — no “hardening” rewrite.

Contracts that don’t drift

Typed dataflow with versioned port schemas makes refactors safe and reviewable. Changes are validated, so prototypes stay deployable as they evolve.

Predictable in production

Rust runtime compiles micro-plans, applies back-pressure, and keeps latency stable under load. Add approvals and policies without changing the graph.

Visual Design

Design workflows visually

Drag nodes, wire typed pins, and validate as you go. Inline errors keep graphs shippable. Snapshot inputs to reproduce issues and compare runs.

Typed pins

ports know their schema so refactors are safe.

Inline validation

miswired edges are surfaced immediately.

Observability

inspect payloads and timings at every edge.

Inline validation
Node inspector
Lifecycle Management

Start offline. Go online later. Deploy with one click.

Manage the full lifecycle from the interface — no CLI required. Keep projects private and local, publish to your team when ready, and ship to production targets with a single action.

1

Start Offline (Private & Secret)

Create an offline project on your machine. Your data stays local until you decide otherwise.

2

Make it Online & Invite

Flip the project online and invite colleagues. Roles and approvals come along for the ride.

3

Deploy to Production

Choose your target — Edge, Cloud, or on-prem. Click deploy. Same validated graph, different runtime target.

Offline

Private, local-first dev

Team

Online, shared, governed

Production

Edge • Cloud • Anywhere

Create offline project Invite teammates Deploy with one click
Rust Performance

Rust runtime for predictable speed

Flow-Like's runtime is written in Rust — tight memory control, back-pressure aware IO, and zero-copy on hot paths. Nodes are authored in Rust too, so you can lean on the ecosystem.

Rust
foundation for runtime & nodes
0-copy
hot paths
Stable
latency under load
Back-pressure
aware IO
Instrumentation

Trace spans, per-edge timings, and payload previews — directly in the UI.

Traces and timings
Extensibility

Integrate your world with typed nodes

Wrap internal APIs, queues, PLCs, computer vision, or spreadsheets. Versioned ports and validation make shared nodes safe to reuse across teams.

Stable interfaces

in/out ports are versioned and validated.

Testability

snapshot fixtures and property-tests for ports.

Distribution

publish nodes privately or on a marketplace.

Custom node library
White-label Ready

Embed, theme, and ship under your brand

Integrate the editor into your product or run the engine headless. Apply your design tokens and logo for a seamless white-label experience — governance and observability stay intact.

Theme via design tokens or CSS variables
Single-sign-on and secrets
Usage metering & multi-tenant ready
SDKs & webhooks
Dark theme variant Light theme variant
Brand-colored variant Compact layout variant
Brand-colored variant Compact layout variant
Brand-colored variant Compact layout variant
Multi-Layer Views

Business process, data, and implementation in one view

Use Layers so roles see what they need without leaving the canvas. Switch context — keep the graph.

Layer Stack Visualization

Three interconnected views of the same workflow

Implementation
Data
Business

Business Layer

Example: Warranty Claim Intake. Customer submits a claim → triage severity → approve or decline → notify customer → trigger payout or repair.

Process Flow
Visual workflow representation
Decision Points
Approval gates and routing

Storage that ships with every app

Each project includes unlimited file storage and unlimited databases. Use files directly in your flows — read streams, transform, and write back. Keep data in classical SQL, add full-text and vector search, and combine them for hybrid queries — all as typed nodes.

∞ Files ∞ Databases SQL + Full-text + Vector Inline in workflows
AI Ready

AI — local & classical

Drop LLM/VLM nodes that run locally or remotely, plus vision (D-Fine, TFLite/ONNX) and regression/classification. Same typed pins, same deployment; agents optional.

Local LLM/VLM Regression / Classification Vision: D-Fine, TFLite, ONNX Agents optional Runs offline

Files (unlimited)

Treat files as first-class data. Use Read to String, Write Bytes, and stream processors inside your graph — no temp glue.

Classical SQL (unlimited DBs)

Typed query/insert nodes with preflight schema checks. Join, filter, and paginate without leaving the canvas.

Full-text search

Index documents, logs, or tickets and query with ranking — results are typed for safe downstream fan-out.

Vector & hybrid search

Nearest-neighbor lookups with filters. Combine vectors with SQL and full-text in the same flow.

Learning Resources

Recommended reading

Deep dives and examples — including Teachable Machine as a simple on-ramp.

Questions & Answers

Frequently Asked Questions

Where can I run Flow-Like?

Locally on macOS/Windows/Linux, on the edge, or in any cloud. Start local, move to cloud later without changing the graph.

How do I integrate with my stack?

Wrap systems as nodes with typed ports. Embed/white-label the editor or run the engine headless inside your apps.

What languages can I use for nodes?

Nodes are authored in Rust today. A WASM node SDK is planned to broaden language support.

Is there governance?

Yes — approvals, policy guardrails, and versioned flows are first-class concepts to help you meet operational and audit needs.