Your plant still runs on forty years of protocols.RetroBridge serves every one of them as OPC UA.
Walk any brownfield site and the data is already there, measured every second and going nowhere: OPC Classic behind a DCOM stack nobody wants to open, Modbus registers in a panel, DNP3 outstations down the pipeline, HART instruments on a 4-20 mA loop, ROC at the wellhead. Four decades of installed base, all of it working, none of it visible to anything built this century.
RetroBridge is one runtime that speaks all of it and serves the result as OPC UA. Point any modern OPC UA client straight at the bridge, or connect it into the H2 Innovations platform and have the same data delivered anywhere in the plant ecosystem. Nothing in the field is replaced, re-pointed, or restarted — the equipment keeps doing its job, and its data finally leaves the floor.
The status quo
Why forty years of data stays stranded
The interface most facilities standardized on is running out of road, and everything else in the plant speaks something different again. Neither problem gets solved by pulling equipment out.
01The incumbent interface is running out of roadOPC Classic is the generally accepted interface in most facilities, and it is rapidly becoming obsolete. Its foundations are why: DCOM underneath it, an identity and integrity model from a different era, and a hard dependency on Windows machines that are already treated as untouchable. The interface did not stop working — everything it stands on became a liability.
02Every other protocol is its own projectHART is not Modbus, Modbus is not DNP3, and none of them resemble OPC Classic's COM interfaces. Each one means a driver, a vendor manual, a test rig, and a set of edge cases learned the hard way on a live system. The effort never compounds: the plant pays for the same integration again with the next protocol, and the one after that.
03The equipment still works, so there is no outage to spendReplacing a legacy server or controller means touching every client bound to it at once: a coordinated shutdown, a re-point, and a re-validation across systems owned by different people. It is not a technical problem; it is a scheduling one, and it is why "next year" has been the answer for a decade.
04Everything modern is UA-onlyNew historians, MQTT and Unified Namespace pipelines, analytics, and the OT/IT layer above them all expect OPC UA. Data that only exists behind a COM interface, a serial poll, or a register map is invisible to them. The tags are being measured; they are just stranded.
How it works
One runtime. Every protocol the plant already speaks.
RetroBridge sits beside the equipment rather than in front of it. Each protocol is a connector behind one internal contract, so the OPC UA side never has to know whether a value came off a COM interface, a register map, or a serial poll.
Every legacy protocol, one runtimeOPC Classic, Modbus, DNP3, HART and ROC connect today, each as a connector behind the same internal contract. Adding a protocol means loading another connector into a runtime that is already deployed, commissioned and trusted — not shipping a second product with its own installer, its own service, and its own operational story for the people who have to run it.
The protocols come out of the factoryProtoGenerator reads a vendor's own manual and recreates the protocol it defines. RetroBridge is where those protocols run: an artifact is checked against its manifest — identity, ABI version, protocol hash, and a SHA-256 of the binary itself, fail-closed — before a single symbol is resolved. The library grows; the bridge does not change shape when it does.
The old network stays where it isThe bridge talks to equipment the way that equipment expects: COM on the same machine, a poll on the same segment. What crosses the plant network is an OPC UA session on a single TCP port — 17080 by default, deliberately not the port a Flowgate node takes, so a bridge and a full node can share a machine. And the bridge is one more client on gear that already serves several: nothing is re-pointed, reconfigured, or taken down to add it.
The field's semantics survive the tripIdentifiers cross verbatim — a DA item ID, a register-map tag path — and arrive as UA nodes carrying their real data type, access rights and browse structure. Quality is mapped, not invented. The source timestamp is the device's own, not the moment the bridge happened to read the value, and a source that supplies no timestamp is reported as having none rather than stamped with the bridge's clock.
The subscription drives the deviceThe sampling interval the UA server actually granted is the rate the southbound side runs at. For OPC Classic that means one DA group per granted interval, populated in a single call, so a fast subscriber joining does not tear down and rebuild everyone else's items and a slow one is not dragged to the fastest rate on the node. The same demand accounting drives every other connector.
Reads, writes and browse all go throughA UA client writes a batch of values and gets back one true per-item StatusCode derived from the device's own error — bad rights, unknown point, out of range — not a blanket success. If a write times out the outcome is reported as unknown rather than failed, because a write that timed out may already have reached the device. Browse is answered on demand, so a point added after startup appears on the next browse without restarting anything.
Northbound: any UA client, or straight into the platformPoint a historian, an HMI, an analytics stack or a UA browser at the endpoint and read it like any other OPC UA server. Or connect the node into the H2 Innovations platform, where it is managed like any other relay and its data is routed anywhere in the plant ecosystem. Where the boundary demands it the node dials out instead of listening — to a platform parent, or to a SCADA client waiting on a reverse listener — so the OT side needs no inbound rule.
It fails honestlyEvery connector runs supervised. When a connector process exits, a link faults, or no data arrives for three polling periods, the served values go Bad and the source is relaunched on a 1-second to 30-second backoff that resets after a minute of stable running. A UA client sees bad quality, which is the honest answer, instead of a stale value that still reads Good. A version mismatch between the runtime and a connector is deliberately fatal rather than retried: skew is a defect, and crash-looping it would hide it.
The incumbent interface
OPC Classic is everywhere, and its foundations are the problem
Most facilities standardized on OPC Classic, and most of them are now stuck on it. Three things underneath it are why — and each one is a reason a modernization project stalls, not a reason to keep it.
DCOM is firewall-hostile by designReaching a DA server from another machine means the endpoint mapper on TCP 135 plus a dynamic high port range. Subscriptions make it worse: DA pushes changes back through a COM callback, so the client has to stand up its own object exporter and accept a call in the other direction too. Microsoft's hardening enforcement on 14 March 2023 (KB5004442, CVE-2021-26414) made the rules stricter rather than looser — packet integrity is now mandatory on every call. There is no version of this that a network segmentation plan is happy about.
The security story does not survive reviewCross-machine OPC Classic means NTLM or Kerberos identity lined up across two hosts, service accounts holding launch and access rights, and an architecture designed when the plant network was assumed friendly — all of it sitting in the path of live process data. A modern OT security review pushes back on that, correctly. Re-implementing the protocol over the network does not help either: it means hand-writing an RPC stack, NTLM and Kerberos, and the packet-integrity signing Windows already enforces, which puts new authentication code where a proven control used to be.
It is welded to Windows boxes nobody may touchOPC Classic exists only on Windows, and in practice only on the specific machine it was installed on years ago. The vendor may be gone, the operating system may already be a compliance exception, and the upgrade is a project of its own with its own validation. Any plan that begins with "first, upgrade that box" does not survive contact with the people who own it.
How RetroBridge gets past all threeThe RetroBridge connector for OPC Classic runs on the machine that already hosts the DA server and speaks COM to it locally, the way a client on that box always could. The DCOM problem disappears because there is no DCOM on the network. The security surface narrows to one OPC UA session on one TCP port, with the policy and certificate handling that comes with UA. And the untouchable Windows box is not upgraded, reconfigured, or restarted, because nothing about it changes — one connector process per DA server, contained, with DA quality, access rights and source timestamps carried across intact. What modern tooling sees is a normal OPC UA server.
Under the hood
One shape, whatever it came off
In plain terms
Every protocol lands in the same internal form: a point, a value, a quality, a timestamp. Once a connector has produced that, the OPC UA side does not know or care whether the data came off a COM interface on a twenty-year-old Windows box, a register map in a panel, or a poll at a wellhead. That is why adding a protocol does not change the product.
The engineering
Southbound connectors register into one seam and speak a single common data model — the same Protocol Buffers contract the rest of the platform uses — so a connector is responsible for its own wire and nothing else. Protocol implementations that come out of ProtoGenerator load as verified artifacts: kernel identity, ABI version and protocol hash checked against the manifest, plus a fail-closed SHA-256 of the binary before a symbol is resolved. OPC Classic is the exception that proves the seam: COM cannot be reached in-process from the host, so its connector is a .NET Framework 4.8 process that runs on the DA server's own machine — hand-written COM interop rather than a generated stack, deliberately, because the Windows COM runtime is already the proven control — and talks to the host over a named pipe carrying length-prefixed protobuf frames. That handshake exchanges an ABI number and a hash of the contract file itself, compared for strict equality, so a mismatched pair fails loudly at the pipe instead of halfway through a subscription. The DA client itself is ported ComIOP: 26 files, each checked against its own MIT header before it was carried in, from the OPC Foundation's sample repository at a pinned commit and never the member-licensed one. The host owns the OPC UA server, the namespace — points are served under the node's own application namespace URI, which clients resolve from the namespace table rather than a hardcoded index — the subscription demand accounting, and the management plane. Values the common model cannot represent still browse, but deliver Bad with a logged marker rather than a silent gap. The endpoint's default policy set includes None for bring-up alongside Basic256Sha256 and the AES policies in Sign and SignAndEncrypt; a production node pins that list in configuration, and the end-to-end probe suite never connects with None.
Protocols on the seam, and the library keeps growing
The OPC Classic chain — DA server, connector, host, OPC UA client — runs end to end and is validated with the same test probe the platform uses as its regression baseline. In the lab it serves a live DA server as an OPC UA endpoint from a Windows service, validated from a separate machine, at a requested one-second rate granted unrevised, every item updating across a two-minute measurement window, no stalled items, every value Good. Modbus TCP drives real devices in the same lab through the same seam, and every protocol the factory recreates lands here the same way.
5 protocols
OPC Classic, Modbus, DNP3, HART and ROC — connected today and served as OPC UA
40 years
of installed base the bridge is built to carry forward instead of replace
No outage
to add it — nothing in the field is replaced, reconfigured, or restarted, and existing clients keep running
One endpoint
for all of it — any modern OPC UA client, or straight into the H2 platform for delivery anywhere in the plant
ShippedOPC Classic, end to endA connector wraps a live OPC Classic DA server and the chain reaches a UA client with quality and source timestamps intact, measured against the platform's own probe suite — then deployed as a standalone Windows service and validated from another machine.
ShippedWrites, browse and rate-matched subscriptionsUA writes carried through to the device with the true per-item StatusCode returned, browse answered one branch at a time so points added after startup appear without a restart, and one poll group per granted sampling interval. Landed as coordinated contract changes on both sides of the seam, gated by a version check that fails loudly.
ShippedModbus TCP on the same seamA polled, coalesced, writable Modbus connector with an operator-authored register map, exercised against a deployed slave and a third-party simulator in the lab. The second protocol behind the same contract, and the proof that the seam is not OPC-Classic-shaped.
ActiveThe protocol libraryDNP3, HART and ROC come out of ProtoGenerator and load through the same seam as verified artifacts. Every protocol the factory recreates widens the catalog behind one runtime that is already deployed and commissioned, rather than adding another product to operate.
ActiveCommissioning from the browserAdding a source from the node's own web UI: the handful of fields an operator actually chooses — a ProgID and update rate, an endpoint and unit id — while the deployment plumbing is derived and the connector's config file generated. Certificate approval, endpoint setup, status and browse live in the same UI, and the changes that genuinely cannot be applied live are restart-gated on purpose, with service recovery wired to bring the node back.
PlannedRemote DCOM, hardening, packagingReaching a DA server on another machine over DCOM with packet integrity, for the cases where the connector genuinely cannot live on the DA server's own box; a hardened pipe ACL and the role-based gate on the management plane; reconnect and degraded-mode behaviour under an agreed failure test plan; and an installer that carries the runtime and the OPC Core Components with it.
Nothing in a plant gets stranded because it is old. It gets stranded because nothing modern can read it. RetroBridge reads it — forty years of protocols, one runtime, one OPC UA endpoint — and hands the result to whatever you are building next.
