Noureddine RAMDI / Flow-Like: a Rust-native workflow engine with 1000x performance over interpreted runtimes

Created Mon, 04 May 2026 10:23:01 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
980 Words
github-stars rust workflow automation tauri nextjs performance

TM9657/flow-like

Flow-Like delivers a striking 1000x performance advantage over typical interpreted workflow engines, running around 244,000 workflows per second with latency near 0.6 milliseconds. This gap is not just a marketing claim — it reflects a fundamental difference in architecture and language choice that impacts how workflows can be executed locally, at the edge, or even embedded in air-gapped environments.

What flow-like is and its architecture

Flow-Like is a Rust-native workflow automation engine built for local-first execution with a strong emphasis on type safety and auditability. The core runtime is written in Rust, providing compiled performance and memory safety.

The platform includes over 900 built-in nodes covering APIs, databases, AI models, and messaging systems. These nodes form the building blocks for workflows, enabling complex automation pipelines that maintain full data lineage tracking across process, data, and execution perspectives.

Architecturally, Flow-Like uses Tauri to deliver a native desktop app experience, while its web interface is built with Next.js. This combination allows it to serve both desktop and web users effectively, while maintaining a compact footprint suitable for edge deployment or embedded scenarios.

Under the hood, the engine’s Rust-native execution model compiles workflows to binaries rather than interpreting them, which accounts for the low latency and high throughput. This design contrasts with most workflow engines that rely on interpreted languages like Node.js or Python, which typically achieve 200 workflows/sec with 50-500ms latency.

Flow-Like is source-available under the Business Source License (BSL), which permits free use for smaller organizations (under 2,000 employees and $300M ARR). It also supports white-labeling with SSO/OIDC, making it suitable for enterprise embedding.

Why flow-like’s approach matters

The most obvious technical strength is the performance: 244,000 workflows/sec at around 0.6ms latency is roughly 1000x faster than typical interpreted workflow engines. This kind of throughput opens up use cases where workflows need to run locally on devices with limited resources or in air-gapped environments where cloud connectivity is absent or insecure.

The choice of Rust is central here. Rust’s zero-cost abstractions, memory safety without garbage collection, and strong typing enable Flow-Like to deliver native-speed execution while maintaining rigorous data contract checks. The codebase leverages Rust’s ecosystem to deliver type-safe data contracts, ensuring that workflows are verified and auditable before and after execution.

Another notable design decision is the local-first architecture. Instead of relying on centralized cloud services, Flow-Like emphasizes running workflows close to the user or device. This reduces latency, improves privacy and security, and allows operation in disconnected or restricted network conditions.

The auditability and comprehensive data lineage tracking across process, data, and execution perspectives provide transparency that is often missing in automation platforms. This is particularly important for regulated industries or scenarios where traceability is critical.

On the tradeoff side, Rust’s steep learning curve and the complexity of compiling workflows to native binaries mean that extending or debugging workflows might require more expertise compared to interpreted languages. The ecosystem is also younger compared to mature platforms like n8n or Node-RED, which enjoy broader community nodes and integrations.

The inclusion of 900+ built-in nodes is impressive and suggests a broad coverage of common integrations. However, managing and updating such a large node set can be challenging, and users might find some nodes less polished or documented compared to other platforms.

Explore the project

Since the repository does not provide explicit installation or quickstart commands, the best approach to get started is to explore the documentation and repo structure.

The README and docs detail the prerequisites, including mise, Rust, Bun, Tauri prerequisites, and Protobuf compiler. These hint at the complexity of the build environment and the native tooling required.

The repo also includes Node.js and Python SDKs, which allow external programs to interact with the workflow engine, extending its utility beyond Rust or Tauri-based apps.

Developers interested in contributing or embedding Flow-Like should start by examining the core runtime in Rust, then explore the Tauri desktop client and Next.js web interface. The node definitions and data lineage logic are key areas to understand for customization.

Verdict

Flow-Like targets a niche but growing need for high-performance, local-first workflow automation that is type-safe and auditable. Its Rust-native design and optimized execution deliver a throughput and latency profile unmatched by typical interpreted workflow engines.

It is most relevant for teams building edge applications, embedded systems, or air-gapped environments where cloud dependencies are undesirable or impossible. The platform’s breadth of built-in nodes and white-label readiness also make it a candidate for enterprise embedding, provided the team is comfortable navigating Rust’s ecosystem.

Tradeoffs include the complexity of Rust-based development, the potential learning curve for workflow authors used to interpreted environments, and the relative youth of the ecosystem compared to more mature low-code/no-code platforms.

Overall, Flow-Like is a solid choice when performance and auditability are paramount and the operational context demands local execution. It’s worth understanding even if you don’t adopt it directly, as it sets a high bar for what native workflow automation can achieve.

→ GitHub Repo: TM9657/flow-like ⭐ 843 · Rust