Industrial Edge Runtime
Loopze is an edge runtime built for the factory floor — not the data centre. One Go binary on every gateway. Native MQTT, Modbus and OPC-UA. Visual flows you can deploy without writing a build pipeline. Embedded NATS for offline buffering and store-and-forward.
What an edge runtime actually does
The "edge" sits between the messy industrial reality — PLCs, RTUs, energy meters, field buses — and your modern stack: historians, MES, dashboards, cloud platforms, Unified Namespaces. A good edge runtime does five things:
- Speaks industrial protocols — MQTT, Modbus, OPC-UA, S7, BACnet, EtherNet/IP. Not just MQTT.
- Translates payloads from raw registers and tags into structured, named, typed JSON.
- Runs local logic close to the equipment so latency-sensitive rules do not depend on the WAN.
- Buffers when connectivity drops so no telemetry is lost on a flaky uplink.
- Deploys to many devices with version control, observability and a sane update story.
How Loopze does it
One Go binary, not a stack
Most edge runtimes are containers full of microservices, or Java apps with a JVM, or Node.js installs plus a tree of npm packages. Loopze is a single statically-linked Go binary, ~5 MB, with no external dependencies. You scp it onto the gateway and run it. That is the whole install story.
Native industrial protocols
MQTT, Modbus TCP & RTU and OPC-UA are implemented inside the runtime, in Go, by us. They share the same back-pressure, reconnect and error semantics. They are not bolted on as community plugins of varying quality. See the dedicated pages for Modbus → MQTT and the OPC-UA gateway.
Goroutine-per-node parallelism
Every node in your flow runs in its own goroutine, scheduled across all CPU cores. A 200 ms Modbus poll on one branch does not stall a 1 kHz MQTT pipeline on another. This is the single biggest operational difference between Loopze and Node.js-based runtimes that share a single event loop.
Visual flows, real version control
Flows are drag-and-drop in the browser, but they serialise to plain files that live in your repo. Diff them. Code-review them. Roll them back. The editor is the convenient interface; git is the source of truth.
Embedded NATS for offline buffering
Loopze ships with NATS embedded. Use it as a local message bus between flows, expose it to the rest of your edge stack, or rely on JetStream's disk-backed persistence to buffer messages while the uplink is down. No separate broker container, no Redis, no RabbitMQ — unless you want them.
Type-safe transforms
Write transforms in expr-lang (fast one-liners), JavaScript (everyday logic) or Go (hot paths). Choose by the job, not by what the runtime forces on you.
Where Loopze fits
- OT-to-IT gateway: bridge the shop floor to your cloud / MES / historian.
- Unified Namespace adapter: map Modbus, OPC-UA and proprietary sources onto a UNS topic structure.
- Local rules engine: alarms, derived signals, setpoint logic that must not depend on the WAN.
- Protocol translator: Modbus ↔ MQTT, OPC-UA ↔ MQTT, MQTT ↔ HTTP, serial ↔ Ethernet.
- SCADA modernization: sit alongside legacy SCADA, lift the data into modern stacks without ripping out the old system.
What Loopze is not
Honesty matters. Loopze is not:
- A full SCADA / HMI replacement. Use it alongside Ignition, zenon, Inductive Automation or your existing SCADA.
- A historian. It pushes data into yours.
- A complete device-management plane like AWS IoT Greengrass or Azure IoT Edge. It runs flows; if you need OTA fleet orchestration, pair it with one.
- A Kubernetes thing. It runs as a single process on a single device. Multiple devices = multiple Loopze instances.
Try it in 60 seconds
curl -L loopze.dev/install | sh
loopze --port 1880Editor at http://localhost:1880. First flow in five minutes.
Frequently Asked Questions
What is an industrial edge runtime?
Software running on a gateway between PLCs/sensors and the rest of your stack. Reads industrial protocols, transforms payloads, runs local logic, buffers on outages, forwards to historians or cloud.
How is it different from a cloud IoT platform?
Cloud platforms assume reliable connectivity and devices that speak MQTT/HTTPS directly. Edge runtimes handle the messy real world: industrial protocols, unreliable WAN, latency-sensitive local rules.
Why pick Loopze?
Single binary, native MQTT/Modbus/OPC-UA, goroutine-per-node parallelism. See Loopze vs Node-RED for a direct technical comparison.
What hardware does it run on?
Linux/macOS/Windows on amd64 or arm64. Tested on Raspberry Pi, Moxa, Advantech, Siemens IPC, BeagleBone and similar gateways. ~5 MB binary, ~20–40 MB RAM.
Does it handle offline buffering?
Yes — via the embedded NATS broker and JetStream's disk-backed persistence. Critical local logic continues to run regardless of WAN state.