logo
Typed • Blazing fast • Robust

Typed workflows that scale

Design reliable systems with type-safe graphs, Rust-level performance, and built-in governance. Start local for a head start, then move to edge or any cloud — no 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.

  1. Dev
  2. Staging
  3. Prod

Same typed graph across environments — no “hardening” rewrite.

Production-ready by default

Preflight checks catch schema & 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 & reviewable. Changes are validated, so prototypes stay deployable as they evolve.

Predictable in production

The Rust runtime compiles micro-plans, applies back-pressure, and keeps latency stable under load. Add approvals & 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 surface immediately.

Observability

Inspect payloads and timings at every edge.

Inline validation
Inline validation
Node inspector & overview
Overview & inspector
Rapid prototyping (live)
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. Offline
  2. Team
  3. Prod

Same validated graph — different targets.

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.

Create offline project Invite teammates Deploy with one click
Offline Local-first → Share → Deploy
Portability — full size
Traces and timings — Flow-Like instrumentation
Rust Performance

Rust runtime for predictable speed

Tight memory control, back-pressure aware IO, and zero-copy on hot paths. Nodes are authored in Rust too — lean on the ecosystem without sacrificing performance.

Rust runtime 0-copy hot paths Stable latency Back-pressure IO
Benchmarks (coming soon…)
Traces and timings — full size
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.

HTTP/REST gRPC Kafka MQTT S3 Postgres LanceDB OpenCV PLC/Modbus Webhooks

Stable interfaces

I/O ports are schema-checked and versioned.

Testability

Snapshot fixtures & property tests per port keep changes safe.

Distribution

Publish privately or to a marketplace with semantic versioning.

See how to wrap an internal API
Typed connection between nodes
exec frame: Image → Result: Table typed
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.

Drop-in widget

Mount the visual editor in any route; theme via CSS variables or tokens.

Design tokens & CSS vars

Map your brand palette; instant dark/light support.

SSO & secrets

OIDC, JWT, and scoped secrets per tenant/app.

Usage metering

Per-tenant quotas, events, and audit trail.

SDKs & webhooks

Control flows via SDKs and REST API.

Dark theme
Light theme
Drag
Theme presets
Scroll →
LOGO
Your logo, your tokens
Craft your brand in tweakcn — copy the tokens and paste to apply instantly.
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.

Your Business - Because it has Depth

Three interconnected views of the same process

Business Layer

Warranty Claim Intake: submit → triage → approve/decline → notify → payout/repair.

Process Flow
Visual workflow representation
Decision Points
Approval gates & routing
Storage & Search — Built-in

Files, tables, and hybrid search — all in your graph

Every project ships with files, tables, and search that plug straight into nodes. Stream bytes, validate schemas, and combine SQL + full-text + vectors in one flow.

apps/acme/vaults/runtime-files/ presigned etag
  • img_3421.webp 1280×720 • 84 KB • etag:3c9af…
  • invoice-4201.pdf 3 pages • 186 KB • signed url
  • claim_10023.jpg 3024×2016 • 1.4 MB • streaming
  • notes.txt 2.1 KB • utf-8 • cache hit
Read Stream Transform Write Bytes Presign

Storage that ships with every app

Unlimited files and unlimited databases, wired into nodes. Read streams, transform, and write back with typed pins. Keep data in SQL, add full-text and vectors, and combine them for hybrid queries.

Stream & transform in-graph
🧾 Typed schemas & preflight checks
🔐 Presigned URLs + scoped access
♻️ ETag caching & diff-based sync
🧠 Full-text + vector side-by-side
📦 Object-store first (local/S3/Azure)
∞ Files ∞ Databases SQL · FTS · Vector Hybrid queries Inline in workflows
Questions & Answers

Frequently Asked Questions

Search, filter, and deep‑link to answers. Built for individuals and enterprises alike.

Filter:
Where can I run Flow‑Like?

Locally on macOS, Windows, and Linux; in containers; on the edge; or in any cloud. Start offline on your laptop, move to production later without changing the graph.

Can I run fully offline / air‑gapped?

Yes. Flow‑Like is local‑first. You can run completely offline or in air‑gapped environments. Sync to cloud later if you choose.

How do I integrate with my stack?

Wrap systems as typed nodes with explicit input/output types. Embed or white‑label the editor, or run the engine headless inside your app.

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, roles, and versioned flows with audit trails are first‑class to meet operational and compliance needs.

How is data stored and searched?

Object‑store–centric by design (e.g., S3/local). For vector search we use LanceDB behind the scenes; graphs interact via nodes — no raw SQL required.

Does it support versioning & reviews?

Flows are versioned. You can stage changes, request approvals, and roll back safely. Git‑based workflows integrate smoothly.

How do I go from dev to prod?

The same typed graph runs locally and in production. Package as a container, deploy to edge/cloud, and promote versions via approvals.

How fast is it?

The runtime is written in Rust for high throughput and low latency. Many workloads run dramatically faster than typical scripting‑based stacks.

Is my data private?

You control where data lives. Local‑first by default, no forced telemetry, and encryption in transit. Keep everything on‑prem if needed.

Do you support SSO / identity providers?

OIDC/SAML‑based SSO and role‑based access controls are on the enterprise track. Ask us about timelines if you have specific providers.

What license does Flow-Like use?

Business Source License (BSL) 1.1 with an Additional Use Grant, and a Change Date after which each version becomes MPL 2.0.

What does the Additional Use Grant allow?

You may use the software (including production use) as long as you do not use it to develop, offer, or provide a product or service that competes with Flow-Like or with products/services from TM9657 GmbH that are substantially similar to Flow-Like’s functionality.

Are there organization-size restrictions?

Yes. A Large Entity—defined as an organization with >2,000 employees or >€300M annual revenue—is not eligible to use Flow-Like under the BSL terms in any capacity and must obtain a commercial license from TM9657 GmbH.

Can agencies/consultants use Flow-Like for clients?

Yes, if neither the agency nor the client is a Large Entity and the delivered solution is not a Competitive Product or Service. Large Entity clients require a commercial license.

Do I need to code to use it?

No. Build visually with typed nodes. Coding is optional for custom nodes or advanced logic.

How do I back up or migrate?

Projects are file‑based with object‑store artifacts. Use your existing backup tooling and promote versions between environments.

How is Flow‑Like different from typical workflow tools?

Types on nodes & edges, local‑first design, Rust performance, and governance built‑in. Safer changes, faster execution, portable deployments.