A powerful, actor-based workflow execution engine built in Rust
📖 Documentation | 🚀 Quick Start | 💡 Examples | 🔧 API Reference
Reflow is a modular, high-performance workflow execution engine that uses the actor model for concurrent, message-passing computation. It enables you to build complex data processing pipelines, real-time systems, and distributed workflows with multi-language scripting support and cross-platform deployment.
🎭 Actor-Based Architecture - Isolated, concurrent actors communicate via message passing
🌍 Multi-Language Support - JavaScript (Deno), Python, and WebAssembly runtimes
📊 Visual Workflows - Graph-based workflow representation with history and undo
⚡ High Performance - Rust-powered execution with zero-copy optimizations
🌐 Cross-Platform - Native execution + WebAssembly for browsers
🔄 Real-Time Processing - Built-in networking, WebSockets, and live data streams
📦 Extensible - Rich component library + custom component creation
🛠️ Developer Friendly - Hot reloading, debugging tools, and comprehensive APIs
# Install Rust (if not already installed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Clone and build Reflow
git clone https://github.com/reflow-project/reflow.git
cd reflow
cargo build --releaseuse reflow_network::{Graph, Network};
use reflow_components::prelude::*;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Create a new graph
let mut graph = Graph::new("MyWorkflow", true, HashMap::new());
// Add actors to the graph
graph.add_node("source", "DataSource", json!({
"data": [1, 2, 3, 4, 5]
}));
graph.add_node("processor", "MapActor", json!({
"function": "x => x * 2"
}));
graph.add_node("sink", "Logger", json!({}));
// Connect the actors
graph.add_connection("source", "output", "processor", "input", json!({}));
graph.add_connection("processor", "output", "sink", "input", json!({}));
// Execute the workflow
let network = Network::from_graph(graph).await?;
network.execute().await?;
Ok(())
}Output:
[INFO] sink: 2
[INFO] sink: 4
[INFO] sink: 6
[INFO] sink: 8
[INFO] sink: 10
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_network- Core actor runtime and message routingreflow_components- Standard library of reusable actorsactor_macro- Procedural macros for actor creation
reflow_js- JavaScript/Deno runtime integrationreflow_py- Python runtime integrationreflow_wasm- WebAssembly runtime and browser support
reflow_script- Multi-language script executionreflow_server- HTTP server and API endpoints
examples/- Working examples and tutorialsdocs/- 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 → publishExplore working examples in the examples/ directory:
Demonstrates how to create and deploy actors as WebAssembly modules.
# Clone the repository
git clone https://github.com/reflow-project/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-exampleReflow 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
- Fork the repository
- Create a feature branch (
git checkout -b feature/amazing-feature) - Make your changes and add tests
- Ensure all tests pass (
cargo test) - Commit your changes (
git commit -m 'Add amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - 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
- Deno - JavaScript/TypeScript runtime
- WebAssembly - Portable binary format
⭐ Star us on GitHub if you find Reflow useful! ⭐