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.
Want AI too? Blend classical ML with GenAI when it helps — it’s one more set of typed nodes, not a separate stack.
Please wait while we prepare everything
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.
Preflight checks catch schema and wiring issues before run. The same typed graph ships across dev → staging → prod — no “hardening” rewrite.
Typed dataflow with versioned port schemas makes refactors safe and reviewable. Changes are validated, so prototypes stay deployable as they evolve.
Rust runtime compiles micro-plans, applies back-pressure, and keeps latency stable under load. Add approvals and policies without changing the graph.
Drag nodes, wire typed pins, and validate as you go. Inline errors keep graphs shippable. Snapshot inputs to reproduce issues and compare runs.
ports know their schema so refactors are safe.
miswired edges are surfaced immediately.
inspect payloads and timings at every edge.
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.
Create an offline project on your machine. Your data stays local until you decide otherwise.
Flip the project online and invite colleagues. Roles and approvals come along for the ride.
Choose your target — Edge, Cloud, or on-prem. Click deploy. Same validated graph, different runtime target.
Private, local-first dev
Online, shared, governed
Edge • Cloud • Anywhere
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.
Trace spans, per-edge timings, and payload previews — directly in the UI.
Wrap internal APIs, queues, PLCs, computer vision, or spreadsheets. Versioned ports and validation make shared nodes safe to reuse across teams.
in/out ports are versioned and validated.
snapshot fixtures and property-tests for ports.
publish nodes privately or on a marketplace.
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.
Use Layers so roles see what they need without leaving the canvas. Switch context — keep the graph.
Three interconnected views of the same workflow
Example: Warranty Claim Intake. Customer submits a claim → triage severity → approve or decline → notify customer → trigger payout or repair.
Source systems in one
project: PostgreSQL claims, object storage for
photos, and a document
store for reports.
Schemas appear at ports
and are validated
pre-deploy.
Typed nodes wired to the
business flow: HTTP.Intake → Classify.Image → Human.Approval → ERP.CreateCase → Notify.Email/SMS. Tests and policies
live on edges.
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.
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.
Treat files as first-class data. Use Read to String,
Write Bytes, and stream processors inside your graph —
no temp glue.
Typed query/insert nodes with preflight schema checks. Join, filter, and paginate without leaving the canvas.
Index documents, logs, or tickets and query with ranking — results are typed for safe downstream fan-out.
Nearest-neighbor lookups with filters. Combine vectors with SQL and full-text in the same flow.
Deep dives and examples — including Teachable Machine as a simple on-ramp.
Learn how to integrate Google’s Teachable Machine with Flow-Like for seamless AI-powered workflows.
Read post
Flow-Like Alpha v0.0.2 introduces Rapid Prototyping mode, new models, secure offline sharing, and execution fixes.
Read post
Enterprise-grade workflow automation built for scale. How Flow-Like's typed workflows solve the problems of traditional workflow engines.
Read postLocally on macOS/Windows/Linux, on the edge, or in any cloud. Start local, move to cloud later without changing the graph.
Wrap systems as nodes with typed ports. Embed/white-label the editor or run the engine headless inside your apps.
Nodes are authored in Rust today. A WASM node SDK is planned to broaden language support.
Yes — approvals, policy guardrails, and versioned flows are first-class concepts to help you meet operational and audit needs.