What Ylby Ozellink Actually Is
Ylby Ozellink is a middleware protocol that sits between edge devices and cloud orchestration layers. It handles data translation, latency management, and handshake verification across heterogeneous networks. If you are building anything that connects legacy industrial hardware to modern cloud stacks, you will run into it. I spent about eight months working with early implementations before it matured to a usable state. The core mechanism works by creating a persistent, bidirectional tunnel that negotiates schema differences on the fly. Instead of requiring every endpoint to speak the same protocol, Ozellink normalizes payloads internally and pushes the conversion overhead to the middleware layer. This means an old Modbus device can talk to a Kafka cluster without a single custom adapter on either side. The translation table lives in memory and updates dynamically when new node types join the network. I remember debugging a deployment where three different manufacturers' sensors were all reporting temperature readings, but each used a different byte alignment and timestamp format. The conventional approach would have been to write three separate ingestion pipelines. With Ozellink, I configured a single link definition that mapped all three schemas to a unified output format. The whole thing took about forty minutes to set up instead of the two days I was expecting. The link parser handles endian mismatches automatically, which is the part most people miss when they first evaluate it.
Setup is straightforward if you follow the standard pattern. You install the Ozellink runtime on a gateway machine or container, define your endpoints in the config file, and start the link service. The runtime auto-discovers devices on the local subnet if you are using standard industrial protocols. For custom protocols, you provide a schema descriptor and the link builds the translation layer from that. You should test with a small subset of your devices first before rolling it out across the full fleet. There are real limitations though. Ozellink adds about three to five milliseconds of latency per hop, which is negligible for most IoT and telemetry workloads but becomes a problem if you are doing real-time control loops that need sub-millisecond response times. I learned that the hard way during a pilot where someone tried to use it for motor coordination and the jitter caused synchronization failures. The workaround was to bypass the link entirely for the time-critical path and only route the non-critical monitoring data through it. Another thing nobody mentions enough is the memory footprint on the gateway. The translation engine loads schema definitions into RAM and each additional endpoint type increases memory usage roughly linearly. In a deployment with over two hundred distinct device types, the gateway needed about 4.2 gigabytes just for the link runtime. You have to plan your hardware accordingly or you will hit OOM errors during peak ingestion windows.
The configuration file uses YAML by default and lives at /etc/ozellink/config.yml on Linux installations. A typical entry looks like this: endpoints:
- id: sensor-01
protocol: modbus-tcp
address: 192.168.1.50
schema: /opt/ozellink/schemas/modbus-temp.yaml
- id: sensor-02
protocol: opendata-v2
address: 192.168.1.51
schema: /opt/ozellink/schemas/opendata-humidity.yaml The schemas themselves are JSON Schema documents with additional Ozellink-specific extensions for timestamp handling, unit conversion, and missing-value policies. You can write these from scratch or export them from tools like Node-RED or Kepware if you already have device mappings configured there.
Get the Full Details
Monitoring the health of active links is done through the built-in HTTP API on port 8400. A simple GET request to /api/v1/links/status returns connection states, throughput metrics, and any schema mismatches the parser has detected. I recommend setting up a Prometheus scraper to pull those metrics so you can see when a device starts sending malformed payloads before it corrupts your downstream data. The protocol is open source and you can find the runtime, documentation, and example schemas on the official repository. Community contributions have filled in support for several legacy protocols that the original maintainers had not covered yet. If you are evaluating this for production use, check the issue tracker to see how actively the project is being maintained, because some older branches have not seen updates in over a year. One counter-intuitive thing about Ozellink is that it performs worse with very small payloads. The overhead of the handshake and schema negotiation can make a single-byte message take longer to process than the message itself. If you are dealing with high-frequency, low-data-rate sensors that send a few bytes every tenth of a second, batching the payloads before they hit the link can improve throughput significantly. I saw a case where batching reduced CPU usage on the gateway by about sixty percent.
If your use case does not involve protocol translation at all and you are just moving data from point A to point B, Ozellink is overkill. Tools like Mosquitto for MQTT or a simple NAT setup will handle that faster and with less complexity. The link shines specifically when you have heterogeneous endpoints that cannot agree on a common format, which is the actual bottleneck in most industrial and smart infrastructure deployments. Documentation is available at the project wiki and covers installation, schema authoring, troubleshooting, and performance tuning. The troubleshooting section alone is worth reading because it lists the exact error codes and what they mean in practice. I spent two hours chasing a connection reset that turned out to be a TLS version mismatch between the gateway and one of the endpoints.
