EdgeLink: A Node-RED Compatible Run-time Engine in Rust

English | 简体中文

Overview

EdgeLink is a high-performance, memory-efficient alternative to Node-RED's runtime engine, built from the ground up in Rust.

Why EdgeLink?

• 10x less memory usage than Node-RED (only 10% of Node-RED's memory footprint)
• Native performance with Rust's zero-cost abstractions
• Drop-in replacement - use your existing flows.json files
• Perfect for edge devices with limited resources
• Node-RED compatible - design flows in Node-RED, run on EdgeLink

EdgeLink executes Node-RED flows without the web editor overhead, making it ideal for production deployments on resource-constrained devices like IoT gateways, embedded systems, and edge computing platforms.

Only the "function" node uses the lightweight QuickJS JS interpreter to run JavaScript code; all other functionalities are implemented in native Rust code for maximum performance.

Features

High Performance & Efficiency

• Ultra-low memory footprint: Uses only 10% of Node-RED's memory
• Native speed: Rust's performance without JavaScript overhead
• Lightweight: No web UI, browser dependencies, or Node.js runtime

Compatibility & Migration

• Node-RED compatible: Run existing flows.json files without modification
• Easy migration: Drop-in replacement for Node-RED runtime
• Function node support: JavaScript execution via QuickJS interpreter

Edge Computing Ready

• Resource-constrained devices: Perfect for IoT gateways and embedded systems
• Cross-platform: Supports ARM, x86, and various Linux distributions
• Container-friendly: Minimal Docker images for edge deployment

Extensibility

• Plugin system: Support for custom nodes (statically linked)
• Future-ready: WebAssembly and JavaScript plugin support planned

Use Cases

• IoT Edge Gateways: Process sensor data with minimal resource usage
• Industrial Automation: Run control flows on embedded controllers
• Home Automation: Deploy smart home logic on Raspberry Pi
• Cloud-to-Edge Migration: Move Node-RED flows from cloud to edge
• Container Deployments: Lightweight containers for edge computing

Quick Demo

# 1. Design your flow in Node-RED (or use an existing flows.json)
# 2. Build EdgeLink
cargo build --release

# 3. Run your flow with EdgeLink
./target/release/edgelinkd ~/.node-red/flows.json

# That's it! Your flow is now running with 90% less memory usage

Quick Start

0. Install Node-RED

For the purpose of testing this project, we first need to install Node-RED as our flow designer and generate the flows.json file. Please refer to the Node-RED documentation for its installation and usage.

After completing the flow design in Node-RED, please ensure that you click the big red "Deploy" button to generate the flows.json file. By default, this file is located in ~/.node-red/flows.json. Be mindful not to use Node-RED features that are not yet implemented in this project.

1. Build

Prerequisites: Rust 1.80 or later

cargo build --release

Platform-specific notes

Windows users: Ensure patch.exe is in your PATH (included with Git) and install Visual Studio for MSVC.

Supported platforms:

• x86_64-pc-windows-msvc
• x86_64-pc-windows-gnu
• x86_64-unknown-linux-gnu
• aarch64-unknown-linux-gnu
• armv7-unknown-linux-gnueabihf
• armv7-unknown-linux-gnueabi

2. Run

cargo run --release

Or:

./target/release/edgelinkd

By default, EdgeLink will read ~/.node-red/flows.json and execute it.

You can use the --help command-line argument to view all the supported options for this program:

./target/release/edgelinkd --help

Run Unit Tests

cargo test --all

Run Integration Tests

Running integration tests requires first installing Python 3.9+ and the corresponding Pytest dependencies:

pip install -r ./tests/requirements.txt

Then execute the following command:

set PYO3_PYTHON=YOUR_PYTHON_EXECUTABLE_PATH # Windows only
cargo build --all
py.test

Configuration

Adjust various settings and configuration, please execute edgelinkd with flags. The flags available can be found when executing edgelinkd --help.

Project Status

Pre-Alpha Stage: The project is currently in the pre-alpha stage and cannot guarantee stable operation.

The heavy check mark ( ✔️ ) below indicates that this feature has passed the integration test ported from Node-RED.

Node-RED Features Roadmap:

• ✔️ Flow
• ✔️ Sub-flow
• Group
• ✔️ Environment Variables
• Context
  • Memory storage
  • Local file-system storage
• RED.util (WIP)
  • RED.util.cloneMessage()
  • RED.util.generateId()
• Plug-in subsystem¹
• JSONata

The Current Status of Nodes:

Refer REDNODES-SPECS-DIFF.md to view the details of the currently implemented nodes that comply with the Node-RED specification tests.

• Core nodes:
  • Common nodes:
    • ✔️ Console-JSON (For integration tests)
    • ✔️ Inject
    • Debug (WIP)
    • ✔️ Complete
    • Catch
    • Status
    • ✔️ Link In
    • ✔️ Link Call
    • ✔️ Link Out
    • ✔️ Comment (Ignored automatically)
    • GlobalConfig (WIP)
    • ✔️ Unknown
    • ✔️ Junction
  • Function nodes:
    • Function (WIP)
      • Basic functions
      • node object (WIP)
      • context object
      • flow object
      • global object
      • RED.util object
      • env object
    • Switch
    • ✔️ Change
    • ✔️ Range
    • Template
    • Delay
    • Trigger
    • Exec
    • ✔️ Filter (RBE)
  • Network nodes:
    • MQTT In
    • MQTT Out
    • HTTP In
    • HTTP Response
    • HTTP Request
    • WebSocket In
    • WebSocket Out
    • TCP In
    • TCP Out
    • TCP Request
    • UDP In
    • UDP Out
      • Unicast
      • Multicast (WIP)
    • TLS
    • HTTP Proxy
  • Sqeuence nodes:
    • Split
    • Join
    • Sort
    • Batch
  • Parse nodes:
    • CSV
    • HTML
    • JSON
    • XML
    • YAML
  • Storage
    • Write File
    • Read File
    • Watch

Roadmap

Check out our milestones to get a glimpse of the upcoming features and milestones.

Contribution

We welcome contributions! Whether it's:

• Bug reports and feature requests
• Documentation improvements
• Code contributions and new node implementations
• Testing on different platforms

Please read CONTRIBUTING.md for details.

Support the Project

If EdgeLink saves you memory and improves your edge deployments, consider supporting development:

Issues, Feedback and Support

We welcome your feedback! If you encounter any issues or have suggestions, please open an issue.

E-mail: oldrev(at)gmail.com

License

This project is licensed under the Apache 2.0 License - see the LICENSE file for more details.

Copyright © Li Wei and other contributors. All rights reserved.

Footnotes

1. Rust's Tokio async functions cannot call into dynamic libraries, so currently, we can only use statically linked plugins. I will evaluate the possibility of adding plugins based on WebAssembly (WASM) or JavaScript (JS) in the future. ↩