01 / CONNECT
Native protocol adapters
Modbus TCP, OPC-UA, MQTT, NATS/JetStream, HTTP, ClickHouse, PostgreSQL/TimescaleDB and FOCAS — first-class, Rust-native, feature-flagged per build.
Protocols
8 native
Battle-ready protocols.
Frictionless transforms,
in one engine.
OpexFlow unifies the industrial reach of a connectivity gateway with the agility of a flow tool — the Kepware alternative and Node-RED alternative in a single licensed binary. Ingest from Modbus, OPC-UA, MQTT and FOCAS, transform in flight, deliver to any sink.
Core
Rust · single binary
Edge
ARM64 ready
Telemetry
OTel native
Plugs into what you already run
OPC UA
OPC-UA
Modbus
Modbus TCP
MQTT
NATS / JetStream
JS Transforms
PostgreSQL
ClickHouse
Rust Core
Speaks every protocol your floor runs
Modbus TCP
OPC-UA
MQTT 3.1.1
NATS + JetStream
HTTP / Webhook
ClickHouse
PostgreSQL / TimescaleDB
FOCAS / Fanuc CNC
The pipeline, visible
From a single line to a branching mesh.
Start as simple as one source into one sink. Grow into multi-source fan-in, per-stream transforms, and branch deliveries — all in the same canvas. And because it's a Rust async core, not a single-threaded runtime, it moves real volume either way.
HTTP
HTTP Request
POST /ingest
Events / second
84,210
▲ flowing now
Processed today
7.2 B
no backpressure
p99 latency
0.41 ms
end-to-end
RAM / node
38 MB
at full load
Node-RED tops out in the low thousands of messages/sec on its single-threaded JS runtime — CPU pegged, memory climbing. OpexFlow runs a Rust async core: linear scaling, tens of thousands of events/sec per node, ~38 MB RAM. Illustrative figures.
AI transforms
Describe the transform. Ship the code.
Don't write transforms by hand. Tell OpexFlow what comes in and what you want out — the AI emits JavaScript for flexibility, or the native DSL for raw speed. You never learn either syntax. From sentence to running pipeline in seconds.
You describe
INPUT
{ device, temp_c, humidity }“Convert temp_c to Fahrenheit, drop humidity, and add a timestamp.”
OUTPUT
{ device, temp_f, ts }
DSL · °C → °FJS · filter anomaliesJS · redact PII
OpexFlow AInormalize.js
✓ JS runs in the sandboxed QuickJS runtime; the native DSL skips JSON marshalling and interpretation entirely — lowest latency, highest throughput.
✓ The AI picks JS or DSL for you and writes the syntax. Editable either way.
✓ Something Node-RED and Kepware just don't do.
Why OpexFlow
One engine where you used to need two.
Flow tools can't speak the factory floor. Connectivity gateways can't shape the data. OpexFlow does both — natively, in one licensed binary.
Flow tools
e.g. Node-RED
- ✕ No native Modbus / OPC-UA
- ✕ No FOCAS / CNC support
- ✓ Drag-and-drop canvas
- ✕ Node.js runtime overhead
- ✕ No single-binary edge deploy
- ✕ No built-in observability
OpexFlow
unified middleware
- ✓ 8 industrial protocols, native Rust
- ✓ JS + native DSL transforms in flight
- ✓ Multi-flow canvas + WebSocket preview
- ✓ Single binary, ARM64, <10 MB
- ✓ OpenTelemetry + Grafana built-in
- ✓ Durable routing, HMAC-signed push
Gateways
e.g. Kepware
- ✓ Strong protocol coverage
- ✕ No flow / transform canvas
- ✕ No inline JS logic
- ✕ Windows-centric deployment
- ✕ Per-tag licensing cost stacks up
- ✕ Opaque pricing post-acquisition
Capabilities
Built for the data backbone.
Everything needed to ingest, shape, route, and observe machine data — from the edge to the data lake.
02 / TRANSFORM
JS & native DSL transforms
Shape payloads in flight with JavaScript for flexibility, or the native OpexFlow DSL for maximum performance — no JSON marshalling, no interpreter overhead. AI-generated, so you never write syntax by hand.
03 / ORCHESTRATE
Multi-flow canvas
Wire sources to sinks visually. Live WebSocket preview, debug-copy, staged-wire feedback. Design the pipeline, not the boilerplate.
04 / OBSERVE
Observability built-in
Native OpenTelemetry traces and metrics — no collector required. Prometheus /metrics scrape and provisioned Grafana dashboards out of the box.
05 / DEPLOY
Edge-ready Rust core
Single binary with an embedded SPA. Cross-compiled for ARM64 — identical artifact on a Raspberry Pi or a rack server.
06 / ROUTE
Durable routing & push
SQLite-backed retention, HMAC-signed cloud push, and NATS/JetStream durability. Data survives restarts and network gaps without loss.
Architecture
Source → flow → sink. Always in flight.
A directed pipeline: ingest from any protocol, transform through a sandboxed stage, route to any sink. Observed end-to-end with OpenTelemetry.
Sources
Ingest
Modbus TCP
OPC-UA
MQTT
FOCAS / CNC
▶
OpexFlow
Transform + Route
JS + native DSL
Multi-flow canvas
Retention · HMAC push
OTel traces + metrics
▶
Sinks
Deliver
NATS / JetStream
ClickHouse
Postgres / Timescale
HTTP webhook
# OpexFlow — declarative flow + native DSL transform (no marshal, no interpreter)
flow "cnc-telemetry" {
source = focas { device = "fanuc-01" }
transform = dsl { rule = "temp_f = temp_c * 9/5 + 32; drop humidity" }
# transform = javascript { script = "./normalize.js" } # full JS when you need it
sink = nats { subject = "opex.machine.v1" }
observe = otel { trace = true }
}
Licensing
Priced like software, not like tags.
Per-node and per-site licensing — never metered by the tag. Transparent tiers benchmarked against what the market actually pays for gateways today.
Starter
Starter
Single edge node for pilots and small lines.
$499 / node
per year · billed annually
- ✓ All 8 protocol adapters
- ✓ Multi-flow canvas + JS transforms
- ✓ SQLite retention & HMAC push
- ✓ 1 edge node · ARM64 supported
- ✓ Email support
Most chosen
Pro
Pro
Production multi-flow deployments for a plant.
$1,490 / node
per year · billed annually
- ✓ Everything in Starter
- ✓ High availability & clustering
- ✓ RBAC + audit log
- ✓ OTel + Grafana package
- ✓ Priority support · SLA response
Enterprise
Enterprise
Unlimited sites & nodes — one company, one license.
from $19,000 / yr
flat annual · unlimited sites & nodes
- ✓ Everything in Pro
- ✓ Unlimited sites & nodes
- ✓ Air-gapped / on-prem deploy
- ✓ Custom adapter development
- ✓ Dedicated engineer · uptime SLA
- · License locked to one legal entity
What counts as a “node”?
A node is one running OpexFlow instance — one deployed binary on one host. That host can be an edge gateway, a Raspberry Pi, a VM, or a rack server. One node license covers unlimited flows, unlimited tags, and unlimited protocol connections on that single instance.
- ✓ 1 node = 1 host running the OpexFlow binary
- ✓ Unlimited flows, tags & device connections per node
- ✓ Single legal entity. Licensed to one named company / corporate group. Affiliates and subsidiaries under common ownership are included.
- ✓ Internal use only. Deploy within your own operations and OT environment — plants, sites, edge gateways you own or operate.
- ✕ No resale or re-hosting. Not for redistribution, white-labeling, or offering OpexFlow as a service to third parties.
- ✕ No multi-tenant SaaS. Each external customer or tenant requires its own license.
- ✓ Non-transferable. Bound to the licensed entity; cannot be sold, leased, or shared with unaffiliated organizations.
Pricing benchmarked against published Kepware (~$1,100 platform + ~$452/yr) and Ignition (~$2,000) market data. No per-tag metering. No surprise renewals.
Enterprise license — the fine print, up front
The flat Enterprise rate covers unlimited sites and unlimited nodes, subject to these binding terms:
Need to host OpexFlow for your own customers? Ask about our OEM / SaaS partner terms.
FAQ
Common questions.
Is OpexFlow a Kepware alternative?
Yes. OpexFlow covers the same industrial connectivity ground — Modbus TCP, OPC-UA, FOCAS — but adds flow-based transformation and a canvas, native OpenTelemetry, and a single binary that runs on Linux and ARM64. It's priced per node or per site, never per tag.
Is OpexFlow a Node-RED alternative?
Yes. OpexFlow gives you the same drag-and-drop flow experience and inline JavaScript transforms, but on a Rust core with industrial protocols built in — no Node.js runtime, no fragile plugin chain, no per-flow memory blowups. One binary from edge to server.
How does the transform layer work?
Two engines. JavaScript transforms run in an embedded, sandboxed QuickJS runtime — deterministic and isolated from the host. The native OpexFlow DSL is interpreted directly against the in-memory event: no JSON marshalling, no JS interpreter, so it's the fastest path for simple maps, filters, and field math. The AI generates either; you never write the syntax yourself.
Can it run on the edge, on a Raspberry Pi?
Yes. OpexFlow cross-compiles to ARM64 and ships as a single self-contained binary with an embedded UI. The same artifact runs on a Pi, an industrial gateway, or a rack server.
What does licensing look like?
OpexFlow is proprietary, commercially licensed software. Tiers run from Starter (single node) through Pro (production HA) to Enterprise (site license + SLA). No free tier — every deployment is supported and licensed.
What exactly counts as a “node”?
A node is one running OpexFlow instance — one deployed binary on one host (an edge gateway, a Raspberry Pi, a VM, or a server). One node license covers unlimited flows, unlimited tags, and unlimited device/protocol connections on that single host. A multi-host high-availability cluster needs one license per node in the cluster. Need many nodes across many sites? The Enterprise tier is a flat annual rate for unlimited sites and unlimited nodes, locked to one legal entity.
Does it integrate with the OpexMX CMMS?
OpexFlow is the data backbone for the Opex suite — it feeds normalized machine data into OpexMX and any downstream system via NATS, MQTT, ClickHouse, Postgres, or HTTP. It also stands alone as a general industrial middleware.
How can Enterprise be unlimited sites and nodes?
The Enterprise rate is a flat annual license for unlimited sites and nodes — but it is bound to one named legal entity (your company and its owned affiliates). It covers internal operational use across every site you own or operate. It does not permit resale, white-labeling, re-hosting, or offering OpexFlow as a multi-tenant service to outside customers — each external customer needs its own license. OEM and SaaS partner terms are available separately.
flow.opexcg.com
The data backbone for Opex.
Connect anything. Transform in flight. One licensed engine. Request access for your floor.