---
title: "What Is LumiScan Keryx?"
description: "The concept behind LumiScan Keryx - one tree of named, typed values and functions that every LumiScan app, PLC, program and person reaches at one address - and what it gives decision makers, PLC programmers, commissioning engineers, developers and IT."
product: "LumiScan Keryx"
component: "lumiscan-keryx"
version: "1.0.0"
display_version: "1.0.0.7"
latest_version: true
language: "en"
url: "https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/what-is-keryx.html"
---

# What Is LumiScan Keryx?

**LumiScan Keryx** is the data backbone of the LumiScan vision apps. Every app puts its values, functions and results into **one tree of named nodes**, and everything else - a PLC, a SCADA system, your own program, a test script, the people commissioning the cell - reaches them at **one address**. Nothing is wired point to point.

The name comes from the Greek *kēryx*, the herald: the messenger who carries news between the parties.

**LumiScan Keryx connects the apps that provide data with everyone who uses it**

```mermaid
%% LumiScan Keryx - concept. Rendered by Mermaid in the browser; edit and preview at https://mermaid.live
flowchart LR
  subgraph users["Who uses the data: read · write · call · subscribe"]
    plc["`**PLC or SCADA**
    through the OPC UA Connector`"]
    prog["`**Your program**
    C++, Python or OPC UA`"]
    tests["`**Scripts and tests**
    krxclient`"]
    people["`**People**
    Keryx page, Cockpit`"]
  end
  keryx["`**LumiScan Keryx**
  the broker, one address for all:
  tcp://127.0.0.1:5555

  one tree of named, typed nodes:
  hdvisionsystems/lumiscan-cam-driver/camera1/...`"]
  subgraph apps["Who provides it: register nodes · publish"]
    cam["`**Cam Driver**
    camera images`"]
    ai["`**AI Object Matching**
    neural networks`"]
    find["`**Finders and readers**
    parts, codes, text`"]
    calib["`**Calibration**
    pixels to 3D`"]
    own["`**Your own function**
    C++ or Python`"]
  end
  plc & prog & tests & people <--> keryx
  keryx <--> cam & ai & find & calib & own
  class keryx key
  classDef key fill:#faf6dc,stroke:#a8961f,color:#1f2328
```

## Why Keryx {#why}

In a vision project, the image processing is only part of the work. The rest is getting it into the machine: a handshake with the PLC, a result format the PLC can read, a live view, a way to find out why a part was rejected, and tests without the real line. Without a common backbone this is built again for every project and every customer.

Keryx does this work once, for all LumiScan apps:

- every app offers its functions in the same way, at addresses built by the same rules;
- a PLC, a program or a person uses all apps through one connection;
- adding a second camera or another app means adding one more participant, not rewiring the cell.

## The concept {#concept}

### One tree of nodes {#nodes}

Everything on Keryx is a **node** with an **address**, written like a file path:

```none
hdvisionsystems/lumiscan-cam-driver/camera1/control/capture/execute
```

A node is a value (a number, a flag, a text, an image), a function you can call, or a folder that groups other nodes. Every node **describes itself**: what it is, its type, and whether it may be read, written, called or subscribed to. So a client can browse the tree and find out what an app offers without a separate interface description - in the same way as an OPC UA server.

The addresses follow one scheme in every app: `<app>/<module>/control/…` for the functions, `input/…` for what you write before a call, `output/…` for the results. See [Addresses and Modules](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/addresses.html).

### Providers, clients and the broker {#participants}

| Role | What it does |
| --- | --- |
| **Provider** | an app that serves nodes: it registers them and publishes changes. The Cam Driver, AI Object Matching, the finders, the readers and Calibration are providers. |
| **Client** | anyone who reads, writes, calls or subscribes: a PLC, your program, `krxclient`, the Keryx page, Cockpit - and an app that uses another app’s results. |
| **Broker** | the one program everybody connects to (`krxsystem`). It holds the tree and routes every request to the provider of the node. On a PC there is one broker, at `tcp://127.0.0.1:5555`; the first app that needs it starts it, and the apps start it again if it stops. |
| **Gateway** | a client that makes the tree available over another protocol. The [OPC UA Connector](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/opc-ua.html) shows the whole tree as an OPC UA server, so that any PLC or SCADA system with an OPC UA client can use the apps. |

### Three ways to call a function {#patterns}

How a function is called depends on how long it takes:

| Pattern | Use it for |
| --- | --- |
| [Execute](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/execute.html) | work that is done within about a second: one write, answered when the work is finished. Example: take an image. |
| [Handshake](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/handshake.html) | work that can take longer: the client sets `request`, the app answers through `ready` - the pattern every PLC programmer knows. Example: connect a camera. |
| [Stream](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/streams.html) (experimental) | continuous work: subscribe once and receive every result. Example: every camera frame goes to AI Object Matching, and every detection to your program. |

Most functions of the Cam Driver, AI Object Matching and Calibration are offered in more than one pattern, with one implementation behind them: the result is the same. See [Choosing a Pattern](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/calling-functions.html).

### The same on ctrlX OS and on a PC {#platforms}

On a PC with Windows 11 or Ubuntu 24.04 the apps use the Keryx broker. On ctrlX OS they use the ctrlX Data Layer instead. The **addresses, types and call patterns are the same** on both, so a PLC program or an application written for one works with the other. See [ctrlX Data Layer and LumiScan Keryx](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/platforms.html).

## What it gives you {#benefits}

### Decision makers and project leads {#benefits-decision-makers}

- **Less engineering per project.** The connection to PLC, live view and test tools is part of the product, not built again for every cell.
- **Standard interfaces, no lock-in.** Keryx follows the interface of the ctrlX Data Layer; towards the machine it speaks OPC UA; structured results use FlatBuffers, an open format with a published schema.
- **Modular.** Each function is its own app. Add a camera or an app, or replace one, without touching the others.
- **One design for two platforms.** The same apps and the same integration run on a ctrlX CORE and on a Windows or Linux PC.

### PLC programmers and system integrators {#benefits-plc}

- **Familiar patterns.** Long operations are a ready/request handshake; short ones a single call.
- **Plain values for the PLC logic.** Status codes, counts, positions and texts are plain variables. Full results are available as structured data with their schema.
- **Any PLC with OPC UA.** On a PC, the OPC UA Connector shows every node as an OPC UA node; its NodeId is the Keryx address. On ctrlX OS, the ctrlX PLC reads the nodes directly.
- **Apps work together without the PLC in between.** By stream, the camera feeds AI Object Matching, and its results go to Calibration; the PLC only reads the final result.

### Commissioning and service {#benefits-commissioning}

- **See everything.** The [Keryx page](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/keryx.html#data-layer-page) shows the whole tree: every value, its type and permissions. Write values, call functions and watch values change - without a PLC and without writing code.
- **Every module says how it is.** `control/status/code` and `control/status/text` tell what the last operation did and why it failed. See [Status Codes and Results](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/status-codes.html).
- **It keeps running.** Each app is a process of its own: one app that stops takes no other app with it. If the broker stops, it is started again within seconds, and the apps reconnect by themselves.
- **Results explain themselves.** Every stream result names the camera and frame it came from, the modules it passed and the settings they used - so a rejected part can be traced back to its image.

### Software developers {#benefits-developers}

- **No SDK needed to use the apps.** Any OPC UA client library, in any language, reaches every function. For scripts and tests there is the command line client `krxclient`. See [Tools](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/tools.html).
- **Test each step alone.** Call one function once, check its output, and only then chain the steps.
- **Self-describing.** Browse the tree to find nodes; the schemas of structured results are on the tree itself, under `types/hdvisionsystems/<app>/…`.
- **Bring your own function.** Algorithms and devices can be added as providers of their own, in C++ or Python, next to the LumiScan apps. Ask HD Vision Systems for the developer package.

### IT and security {#benefits-it}

- **Closed by default.** The broker accepts connections from the same PC only (`127.0.0.1`), and so does the Keryx page. Opening it to a network is a deliberate setting.
- **No cloud.** Keryx runs entirely on the machine; it needs no internet connection.
- **Control at the edge.** The OPC UA Connector can serve one part of the tree only, and can run read-only. On ctrlX OS, the apps use the ctrlX Data Layer with the user management of ctrlX OS.

> [!IMPORTANT]
> The Keryx broker and the OPC UA Connector have **no authentication and no encryption** today. Run them on one PC, or in a separate machine network you trust, behind a firewall. See [OPC UA Connector: Security](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/opc-ua.html#security).

## Good to know {#good-to-know}

- **One broker per PC.** All apps of one installation use the same broker. Several brokers on different ports are independent of each other; brokers on several PCs do not share one tree.
- **Values carry no timestamp of their own.** An app that needs one publishes it in a node or inside the result.
- **A new subscriber gets no initial value.** Read the node once, then subscribe.
- **Streams are experimental** in the current releases.

More in [LumiScan Keryx on a PC: Good to know](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/keryx.html#limits).

## Where to go next {#next}

- Try it yourself in 30 minutes: [Getting Started with LumiScan Keryx](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/getting-started.html).
- Install and run Keryx on a PC: [LumiScan Keryx on a PC](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/keryx.html).
- Use the apps on ctrlX OS: [ctrlX Data Layer on ctrlX OS](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/ctrlx-data-layer.html).
- Find the nodes of an app: [Addresses and Modules](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/addresses.html) and the **Data Layer Reference** in the app’s manual.
- Connect a PLC: [OPC UA Connector](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/opc-ua.html) (PC) [Connecting a PLC](https://docs.hdvisionsystems.com/en/lumiscan-keryx/1.0.0/ctrlx-data-layer.html#connecting-a-plc) (ctrlX OS).