One Go binary. Goroutine-per-node parallelism. Native MQTT, Modbus and OPC-UA. Write transforms in Go, JavaScript or expr-lang — drag-and-drop signal flows, without the node_modules.
Loopze is a clean-room runtime informed by a decade of running flow-based systems in production. Same philosophy — visual flow programming. Different answers to the parts that hurt.
Most flow runtimes sit on a single-threaded event loop. One slow Function node stalls every other node — every other flow, every other message.
One goroutine per node. The Go runtime spreads work across every CPU core. Thousands of nodes run truly in parallel — not cooperatively-sequentially.
A scripting runtime, a package manager, and a directory full of dependencies. Multi-step installs, version conflicts, and orphaned community modules that rot in production.
A single Go executable. Frontend embedded, NATS embedded, credentials encrypted at rest. Drop the binary on an edge device and run it.
Context is a passive key-value store. To react to changes, flows poll every 500 ms — anti-patterns, race conditions, lost intermediate states.
Context lives on NATS JetStream KV. The Context Watch node subscribes to keys or patterns and fires a message the instant a value changes. No timers, no missed updates.
OPC-UA, Modbus, Sparkplug — usually community modules. Three-to-five forks per protocol, varying maturity, dependency chains that break on the next update.
MQTT, Modbus TCP/RTU, OPC-UA (Read · Subscribe · Write with structure-aware ExtensionObjects), Serial — all native, all maintained alongside the runtime, all using one shared config-node pattern.
Every node — MQTT, Modbus, OPC-UA, Function, Context, Queue — lives in the same repository as the runtime. They ship together. They're tested together. Upgrade Loopze and every node moves with it. No abandoned community modules, no version skew, no hunt through three forks for the one that still compiles.
Concrete capabilities that come from running flow-based systems in production for a decade — and noticing what was missing.
Need raw speed? Drop a Go Transform — runs natively in the runtime, no interpreter, full goroutine parallelism. Need flexibility? Function nodes run JavaScript via Goja. Need a one-liner? expr-lang for fast field-level expressions.
Drop a Validation node at any system boundary. Conforming messages pass through, non-conforming ones route to a separate error output. Explicit data contracts between flow sections.
Embedded NATS JetStream means a Queue node ships in the box. Configurable delivery (at-least-once, exactly-once), retries, dead-letter — no Redis, no RabbitMQ, no plugin.
Toggle the profiling overlay and see latency, msg/s and queue fill directly on every node. Slow nodes are highlighted on the canvas — performance issues become visible before they hurt.
Pick a single message and follow it through the flow. The path lights up on the canvas, with timestamps and payload snapshots at every hop. Debugging branched flows finally makes sense.
Secrets live in a separate file, AES-256-GCM at rest. Local user accounts with Argon2id, three roles (admin, editor, viewer), sliding sessions out of the box.