Reflow is a modular workflow execution engine that uses the actor model for concurrent, message-passing computation. It enables graph-authored DAGs for data processing, real-time media, visual tooling, distributed workflows, and optional ML/CV taskpacks.

🎭 Actor-Based Architecture - Isolated, concurrent actors communicate via typed messages
📊 Graph-Authored Workflows - DAG representation with subgraphs, IIPs, history, and undo
📦 The Reflow Runtime API - reflow_rt is the public Rust crate for building and running Reflow applications
🎛️ Optional Component Families - GPU, AV, window events, camera, API services, media, and ML are feature gated
🌍 Multi-Language SDKs - first-party bindings for Node.js, Python, Go, JVM (Java + Kotlin), and C++
🌐 Cross-Platform - Native Rust execution plus WebAssembly-oriented runtime surfaces
🔄 Real-Time Processing - Networking, WebSockets, streams, and live graph events
🧠 Media / ML Ready - Typed media packets, mockable inference, LiteRT backend boundary, and taskpack subgraphs

For application code, start with the unified runtime crate:

[dependencies]
reflow_rt = "0.1"

The default reflow_rt feature set is intentionally lightweight: runtime plus core utility components. Optional stacks are selected explicitly:

# Runtime + core component catalog only.
reflow_rt = "0.1"

# Add GPU rendering/compute components.
reflow_rt = { version = "0.1", features = ["gpu"] }

# Add typed media packets and graph-driven ML/CV taskpacks.
reflow_rt = { version = "0.1", features = ["media", "ml"] }

use reflow_rt::prelude::*;

fn main() {
    let mut graph = Graph::new("example", false, None);
    graph.add_node("tap", "tpl_passthrough", None);

    let network = Network::with_graph(NetworkConfig::default(), &graph);
    let _ = network;
}

See the reflow_rt README for the runtime API surface and feature map.

The runtime is the same Rust core; each SDK is a thin native binding plus an idiomatic surface in that language. Pick the published artifact for your runtime, then jump to that SDK's README for quick-start code.

# Node.js — npm install pulls the right per-platform .node addon automatically
npm install @offbit-ai/reflow

# Python — pre-built wheels for darwin / linux / windows on PyPI
pip install offbit-reflow

# Go — install the module, then drop the platform-specific
# libreflow_rt_capi tarball into the module via the bundled script.
# See sdk/go/README.md for full instructions.
go get github.com/offbit-ai/reflow/sdk/go@v0.2.3

// Gradle (Kotlin DSL) — JVM SDK is the fat jar; native libs are
// bundled as classpath resources.
dependencies { implementation("ai.offbit:reflow:0.2.4") }

# C++ — header-only over libreflow_rt_capi; install the matching
# native lib from a sdk/go/v* GitHub Release and point CMake at it.
add_subdirectory(third_party/reflow/sdk/cpp)
target_link_libraries(myapp PRIVATE reflow::cpp)

The same @offbit-ai/reflow package falls back to a wasm bundle in the browser via the "browser" conditional export — Vite, webpack, and esbuild pick it up automatically. Node continues to load the napi .node addon. See sdk/node#browser-target for the runtime surface available there.

Optional .rflpack bundles plug additional actor palettes (GPU renderers, ML, browser automation, ~6,700 SaaS API actors) into any SDK at runtime — load via loadPack() / load_pack() / LoadPack() / Packs.loadPack().

Reflow's architecture is built around three core concepts:

┌─────────────────┐    Messages    ┌─────────────────┐    Messages    ┌─────────────────┐
│     Actor A     │────────────────▶│     Actor B     │────────────────▶│     Actor C     │
│  (JavaScript)   │                 │    (Python)     │                 │     (Rust)      │
│                 │                 │                 │                 │                 │
│ ┌─────────────┐ │                 │ ┌─────────────┐ │                 │ ┌─────────────┐ │
│ │Input Ports  │ │                 │ │Input Ports  │ │                 │ │Input Ports  │ │
│ │Output Ports │ │                 │ │Output Ports │ │                 │ │Output Ports │ │
│ └─────────────┘ │                 │ └─────────────┘ │                 │ └─────────────┘ │
└─────────────────┘                 └─────────────────┘                 └─────────────────┘

• Actors: Isolated units of computation that process messages
• Messages: Strongly-typed data passed between actors
• Graphs: Visual representation of actor connections and data flow

This workspace contains multiple crates that work together:

• reflow_rt - The public Rust runtime crate for Reflow applications
• reflow_network - Core actor runtime and message routing
• reflow_components - Standard library of reusable actors
• reflow_graph - Graph data model, exports, nodes, connections, and IIPs
• reflow_actor - Actor traits, contexts, messages, streams, and state
• actor_macro - Procedural macros for actor creation

• reflow_assets - Content-addressed asset database conventions
• reflow_pixel - Pixel/image helpers for media components
• reflow_sdf - SDF primitives and procedural geometry/codegen support
• reflow_shader - Shader graph IR and WGSL generation
• reflow_vector - 2D vector paths, booleans, and rasterization
• reflow_media_types / reflow_media_codec - Optional typed media and tensor packet contracts
• reflow_litert / reflow_ml_ops / reflow_cv_ops / reflow_taskpacks - Optional ML/CV stack and taskpack graph builders

• reflow_js - JavaScript/Deno runtime integration
• reflow_py - Python runtime integration
• reflow_wasm_actor - WebAssembly runtime and browser support

• reflow_script - Multi-language script execution
• reflow_server - HTTP server and API endpoints

• examples/ - Working examples and tutorials
• docs/ - Comprehensive documentation

// ETL pipeline with error handling
source → validate → transform → load → audit

// Live data processing
websocket → parse → aggregate → alert → dashboard

// Sensor data workflow  
mqtt → decode → filter → analyze → store → notify

// Audio/video pipeline
upload → decode → process → encode → publish

📖 Complete Documentation

• Installation Guide
• Basic Concepts
• First Workflow Tutorial

• System Architecture
• Actor Model
• Message Passing

• Creating Actors
• Graph Management
• Component Library

• Building a Visual Editor
• Performance Optimization
• Deployment Guide

• API Reference
• Troubleshooting Guide

Explore working examples in the examples/ directory:

Demonstrates how to create and deploy actors as WebAssembly modules.

# Clone the repository
git clone https://github.com/offbit-ai/reflow.git
cd reflow

# Build all crates
cargo build

# Run tests
cargo test

# Build with optimizations
cargo build --release

# Install wasm-pack
curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

# Build WebAssembly package
cd crates/reflow_network
wasm-pack build --target web

# Install development dependencies
cargo install cargo-watch
cargo install flamegraph

# Run with hot reloading
cargo watch -x run

# Performance profiling
cargo flamegraph --bin reflow-example

Reflow is designed for high-performance execution:

• Zero-copy message passing where possible
• Parallel actor execution with work-stealing schedulers
• Memory pooling for frequently allocated objects
• SIMD optimizations for numeric processing
• Async I/O throughout the system

Benchmark results on modern hardware:

• 1M+ messages/second processing throughput
• Sub-millisecond actor-to-actor latency
• Linear scaling with CPU core count

We welcome contributions! Please see our Contributing Guide for details.

• 🐛 Bug Reports - Found an issue? Let us know!
• 📝 Documentation - Help improve our guides and examples
• 🔌 Components - Build reusable actors for the community
• 🌐 Language Bindings - Add support for more runtimes
• ⚡ Performance - Optimization opportunities
• 🧪 Testing - Expand our test coverage

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes and add tests
4. Ensure all tests pass (cargo test)
5. Commit your changes (git commit -m 'Add amazing feature')
6. Push to the branch (git push origin feature/amazing-feature)
7. Open a Pull Request

• GitHub Discussions - Ask questions and share ideas

This project is licensed under the MIT License - see the LICENSE file for details.

Built with ❤️ using:

• Rust - Systems programming language
• Tokio - Asynchronous runtime