Part of: Monitor & connect

About 6× less RAM
than Node-RED
on the same flow.

One Modbus-to-PostgreSQL flow, measured twice. On a MacBook Pro M1 Pro (32GB): RustRED 17.2MB RAM at 0.39% CPU, Node-RED 129MB at 0.94% CPU. Reproduced on Linux x86_64: 20.4MB at 0.20% CPU against 126MB at 0.71%. RustRED is a fork of EdgeLinkd by Li Wei (Apache-2.0).

Node-RED · MacBook Pro M1 Pro

129 MB RAM · 0.94% CPU · Node.js

Node-RED Activity Monitor showing 129MB RAM and 0.94% CPU usage running a Modbus TCP to PostgreSQL flow.

RustRED · MacBook Pro M1 Pro

17.2 MB RAM · 0.39% CPU · Rust (Tokio)

RustRED Activity Monitor showing 17.2MB RAM and 0.39% CPU usage running an identical Modbus TCP to PostgreSQL flow.
Machine
RustRED
Node-RED
Source
MacBook Pro M1 Pro, 32GB
17.2 MB · 0.39% CPU
129 MB · 0.94% CPU
Activity Monitor screenshots above
Linux x86_64, 12 cores
20.4 MB · 0.20% CPU
126 MB · 0.71% CPU
Reproduction, method below

Linux method: pymodbus 3.6.9 simulator, PostgreSQL 16 in Docker, 10 holding registers polled every 500 ms, a function node building one INSERT per poll (about 2 rows/s on both sides, confirmed by row counts). 30 s warm-up, then 60 s sampled once per second; RAM is resident memory from /proc, CPU is user plus system time over wall-clock time. RustRED was the full build; Node-RED ran node-red-contrib-modbus and node-red-contrib-postgresql. The RustRED flow uses RustRED’s own node types. One machine, one flow: your numbers will differ. Details in the README.

Demo video

Watch the demo

A Node-RED compatible flow runtime in Rust: one binary, the built-in editor, import a flow and deploy, live debug data, a built-in MQTT broker, Modbus, and the footprint comparison.

Chapters

Your flow automation shouldn't need
a full server to run.

Node-RED brought visual flow programming to everyone. But on small devices and in production, teams hit the same walls: a heavy runtime and npm supply-chain risk.

01

About 6× less RAM

On the same Modbus-to-PostgreSQL flow Node-RED used 129MB on an M1 Pro Mac and 126MB on Linux. RustRED used 17.2MB and 20.4MB. With an empty flow, the default build idles at about 15MB on Linux x64.

02

Supply-Chain Risk

Every npm install is a risk, and Node-RED nodes run with full access to the process. RustRED nodes are Rust code compiled into the binary from source you can read. There is no runtime package install.

03

No runtime to install

Node-RED needs Node.js and an npm install on every device. RustRED is a native binary plus the editor folder, so a flow runner is two things to copy. We have not benchmarked cold start time.

Built for production.
Engineered for reliability.

RustRED runs flows built from Node-RED’s core nodes with a small memory footprint. Voltrus can host an instance for you, in early access.

01

Low overhead

Native async runtime on Tokio, no garbage collector. On the same Modbus-to-PostgreSQL flow it used 0.39% CPU where Node-RED used 0.94% (M1 Pro), and 0.20% against 0.71% on Linux.

02

Auditable custom nodes

Custom nodes are Rust crates in node-plugins/, compiled into your own build. Review the code, then ship the binary. An experimental WASM plugin host exists in the full feature set; release binaries do not include it.

03

Small deployment

A 17.0MB binary (default build; about 24MB with --features full) and an editor folder. No Node.js, no Docker, no package installs. Release archives for Linux and macOS, x86_64 and aarch64.

04

Node-RED flow format

Flows built from core nodes import and run, and the Node-RED editor is included. Stock MQTT nodes and the node-red-contrib-modbus and node-red-contrib-postgresql nodes run as exported.

05

Build only what you need

Protocols, databases, clustering and AI support sit behind cargo feature flags, so you can build a smaller binary for constrained devices.

06

Industrial and database nodes

Modbus, OPC-UA, BACnet, MQTT (with an embedded broker node), PostgreSQL, TimescaleDB, MSSQL, SQLite and InfluxDB nodes, all in the default build.

How it compares to what you're using now

See how RustRED stacks up against the tools you're already using. Built for the same workflows, engineered for production.

Factor
RustRED
Node-RED
n8n
Runtime
Native Rust (Tokio)
Node.js (V8)
Node.js (V8)
Binary Size
17.0 MB (default build)
Node.js + dependencies
Node.js + dependencies
Memory (same Modbus→PostgreSQL flow)
17.2 MB (M1 Pro), 20.4 MB (Linux)
129 MB (M1 Pro), 126 MB (Linux)
Not measured
Custom nodes
Rust crates, compiled in
npm packages
npm packages
MQTT broker
Embedded broker node
Needs an external broker
Needs an external broker
Modbus
Read, write and server nodes
Via npm package
No
Edge Deployment
Binary + editor folder
Requires Node.js
Requires Node.js or Docker
GC Pauses
None
Yes (V8 GC)
Yes (V8 GC)
License
Apache-2.0
Apache-2.0
Fair-code (Sustainable Use)

Self-hosted vs Voltrus

Feature
RustRED (self-hosted)
Voltrus Cloud (early access)
Voltrus Enterprise
Price
Free (Apache-2.0)
$15 or $29 / month per instance (Rp 150.000 or Rp 250.000)
Custom
Hosting
Your infrastructure
We run and update it (Singapore)
On-premise or your cloud
Editor access
Whatever you set up
Behind your Voltrus sign-in
Agreed per contract
Flow snapshots
Your own backups
With rollback
Agreed per contract
Support
Community (GitHub)
Email (priority on Pro)
Agreed per contract

RustRED is the engine.
Voltrus Cloud runs it for you.

Self-host RustRED for free, or have us run and update an instance for you. Cloud is in early access: we are onboarding the first customers by hand.

01

We run and update it

No server to provision or patch. We run your RustRED instance in our Singapore region and keep it updated.

02

Sign-in in front of the editor

The flow editor sits behind your Voltrus sign-in, so it is not open on the internet.

03

Flow snapshots with rollback

Snapshots of your flows, so a bad deploy can be rolled back.

04

Fixed resource caps

Starter is capped at 128 MB of memory and about 100 messages per second per instance. Pro is capped at 512 MB and about 500 messages per second.

05

Migration help

Send us your Node-RED flows. We tell you which nodes import as they are and which do not, and help you fix the rest.

06

On-premise for Enterprise

Enterprise customers can have RustRED installed on their own servers or in their own cloud, with support agreed per contract.

Built for edge, IoT, and industrial automation.

From factory floors to solar farms to smart buildings: anywhere you need lightweight, reliable flow automation that runs on constrained hardware.

IIoT

Industrial IoT Gateways

Run flow automation on Raspberry Pi or industrial gateways with 512MB RAM. Collect data from Modbus devices, transform, and publish to MQTT.

PLC

PLC Data Collection

Poll PLCs over Modbus TCP/RTU, aggregate data, and push to PostgreSQL/TimescaleDB for dashboarding. One binary, no middleware stack.

SOL

Solar & Energy Monitoring

Collect inverter data, meter readings, and weather station values. Transform and forward to cloud platforms via MQTT. Runs on a Raspberry Pi.

BMS

Building Automation

Connect HVAC controllers, lighting systems, and sensors. Route data between BACnet, Modbus, and MQTT protocols with visual flows.

DEV

Node-RED Migration

Try your existing Node-RED flows on a smaller runtime. Flows made of core nodes, stock MQTT, node-red-contrib-modbus and node-red-contrib-postgresql nodes run as exported.

EDGE

Edge Computing

Copy a 16MB binary and the editor folder to your edge devices. Linux and macOS builds for x86_64 and aarch64.

Part of: Monitor & connect · See the plant: dashboards and alarms, machine OEE, remote access, messaging.

How RustRED differs from…

  • Voltrus Gateway

    Voltrus Gateway is a typed gRPC API over seven PLC protocols, for code. RustRED is a flow runtime where you wire the logic.

  • Voltrus Broker

    Voltrus Broker is a managed, dedicated MQTT broker. RustRED is free, and you run it yourself.

Not sure? See which one you need →

Common questions

RustRED is a flow runtime written in Rust that reads Node-RED flow JSON. It is a fork of EdgeLinkd by Li Wei, licensed under Apache-2.0, and is not affiliated with the Node-RED project. Learn more about the runtime →
Flows built from Node-RED’s core nodes (inject, function, change, switch, debug and similar) import and run. The stock MQTT nodes and flows built on node-red-contrib-modbus or node-red-contrib-postgresql run as exported too. Credentials in flows_cred.json are not read, so add them to the config nodes. A config node that fails to load is logged and disabled, and the rest keeps running. Start by running rust-red run flows.json and read the log.
Yes, as Rust crates. Put a crate in node-plugins/, annotate the node with the flow_node macro, and build RustRED. The node is compiled into your binary. The repository also contains an experimental WASM plugin host, which is part of the full feature set and not in release binaries.
The default build has nodes for Modbus, OPC-UA, BACnet, MQTT (with an embedded broker node), PostgreSQL, TimescaleDB, MSSQL, SQLite and InfluxDB, plus HTTP, TCP, UDP and WebSocket. The README lists them all.
RustRED is licensed under Apache-2.0, the same license as the EdgeLinkd project it is forked from; the upstream copyright is kept in the LICENSE and NOTICE files. The source is on GitHub. You can self-host, modify, and extend it, including for commercial use.
Releases include an aarch64 Linux build, which fits a Raspberry Pi running a 64-bit OS. We have not benchmarked a Pi ourselves. On Linux x64 the default build idles at about 15MB with an empty flow and the binary is 17.0MB.
RustRED is the open-source flow runtime (Apache-2.0): visit the project page. Voltrus Cloud is our managed hosting of it, in early access, and Voltrus Enterprise is on-premise installation with support agreed per contract.
Download the archive for your platform from GitHub Releases, unpack it, and run ./rust-red run flows.json. Then open http://127.0.0.1:1888. To build from source, clone the repository with --recursive and run cargo build --release, or run cargo install --git https://github.com/dzulfikar08/rust-red for the binary alone (without the editor files).

Start free.
Let us host it when you want.

RustRED is free and open source (Apache-2.0). Voltrus Cloud is in early access: we run and update an instance for you.

Self-Hosted

Free

Apache-2.0 · Fork of EdgeLinkd

  • ✓ RustRED runtime and editor
  • ✓ Modbus, OPC-UA, BACnet, MQTT, PostgreSQL, SQLite, InfluxDB and more
  • ✓ Imports Node-RED flows built from core nodes
  • ✓ Linux and macOS builds
  • ✓ Community support on GitHub
Download

Cloud Starter · early access

$15 / month

or Rp 150.000 / month, per instance. Pay yearly, get 2 months free ($150 or Rp 1.500.000).

  • ✓ 1 RustRED instance
  • ✓ 128 MB memory cap
  • ✓ Up to ~100 messages/s
  • ✓ Editor behind your Voltrus sign-in
  • ✓ Flow snapshots with rollback
  • ✓ Singapore region
  • ✓ Email support
Request early access

Cloud Pro · early access

$29 / month

or Rp 250.000 / month, per instance. Pay yearly, get 2 months free ($290 or Rp 2.500.000).

  • ✓ Everything in Starter
  • ✓ 512 MB memory cap
  • ✓ Up to ~500 messages/s
  • ✓ More projects
  • ✓ Priority email support
Request early access

Enterprise

Custom

On-premise or your cloud

  • ✓ On-premise installation
  • ✓ Support agreed per contract
  • ✓ Migration help for Node-RED flows
Contact Sales

Early access. We are onboarding the first customers by hand. Request access and we reply within two business days.

Get Started

Run RustRED free.
Or have us host it.

RustRED is free and open source (Apache-2.0). If you would rather not run it yourself, ask for Voltrus Cloud early access.

View Pricing View on GitHub

Help when you
want it.

01

Migration help

Send us your Node-RED flows. We check which nodes import as they are and which do not, and help you fix the rest.

02

Managed hosting

Voltrus Cloud is in early access. We run your instance in Singapore and keep it updated.

03

On-premise installation

For Enterprise customers: we install RustRED on your servers or in your cloud, with support agreed per contract.

Tell us about your plant

We reply on WhatsApp or email.

Prefer email? [email protected]