Rust Runtime
Built on Tokio async I/O with zero-cost abstractions. No garbage collector pauses, deterministic memory usage.
A Node-RED compatible runtime built in Rust. Import your flows, run them faster, deploy anywhere.
Watch RustRED run a Modbus-to-PostgreSQL flow with live memory and CPU monitoring.
RustRED is an open-source flow automation runtime built in Rust. It reads your Node-RED flow JSON files and executes them using a high-performance async engine powered by Tokio.
It is a drop-in runtime — import your existing Node-RED flows and run them with significantly lower memory usage, faster cold starts, and WASM-based plugin security. No Node.js required.
Everything you need to run flow automation in production.
Built on Tokio async I/O with zero-cost abstractions. No garbage collector pauses, deterministic memory usage.
Write custom nodes in Rust, Go, or C/C++ that compile to WASM and run in a sandboxed runtime. Hot-reloadable without restarts.
One 11.8MB static binary with no runtime dependencies. Runs on Linux, macOS, ARM, and WASI. Copy and deploy.
Import your existing flow JSON files directly. Compatible with the Node-RED flow format and editor.
Compile only what you need. Disable Modbus, PostgreSQL, AI, or clustering with cargo feature flags to minimize binary size.
Topic trie with wildcard matching, QoS 0/1, and retained messages. No external Mosquitto dependency needed.
How RustRED works under the hood.
All I/O is non-blocking via Tokio. HTTP, MQTT, Modbus, and file operations run concurrently on a multi-threaded scheduler.
Parses Node-RED flow JSON and builds an execution graph. Messages flow between nodes through typed input/output ports.
Custom plugins run inside a WASM sandbox with controlled capabilities. Each plugin gets its own memory space and cannot access the host system directly.
Built-in support for MQTT, Modbus TCP/RTU, and PostgreSQL. Each handler is a feature-gated module that compiles only when needed.
Every major subsystem is behind a cargo feature flag. Build minimal binaries for constrained devices by disabling unused features at compile time.
Built-in web editor for designing flows and a dashboard for monitoring runtime status. Accessible at localhost:1880.
Write custom nodes in Rust, Go, or C/C++. They compile to WASM and run in a secure sandbox.
Implement the FlowNodeBehavior trait in Rust, Go, or any language that compiles to WASM.
cargo build --target wasm32-wasip1 — produces a tiny ~13KB binary.
Place the .wasm file in your plugin directory. Hot-reloaded, no restart needed.
use rust_red_macro::*;
// Annotate with flow_node to register
struct MyCustomNode {
base: BaseFlowNodeState,
}
impl MyCustomNode {
fn build(
flow: &Flow,
base: BaseFlowNodeState,
config: &RedFlowNodeConfig,
) -> Result<Box<dyn FlowNodeBehavior>> {
Ok(Box::new(Self { base }))
}
}
impl FlowNodeBehavior for MyCustomNode {
async fn run(self: Arc<Self>, stop: CancellationToken) {
while let Ok(msg) = self.recv_msg(stop.clone()).await {
// Process your message
}
}
}Your existing flows work in RustRED without modification.
In Node-RED, select all nodes and export as JSON. Or copy your flows.json file directly.
Run rust-red --import flows.json. RustRED parses the same JSON format and builds the execution graph.
Your flows execute with the same logic. Open localhost:1880 to access the editor and dashboard.
Install, import your flows, and run.
Rust toolchain (rustup) or download a pre-built binary from GitHub Releases.
cargo install rust-red compiles and installs the binary to ~/.cargo/bin/.
Pass your Node-RED flows.json with --import. Your existing flows work as-is.
Navigate to http://localhost:1880 to access the flow editor and dashboard.
RustRED is open source. Contribute, report issues, or just say hello.