UNS OpenHub

Open-source industrial data tooling

One namespace.
Every signal in context.

Turn fragmented industrial signals into one governed, queryable data layer on infrastructure you control. Publish with TypeScript, Python, or Node-RED, preserve context in MQTT, and use the same identity for live and historical data.

Explore on GitHub Runtime preview
  • On-premyour infrastructure
  • 2 SDKsTypeScript + Python
  • MITpublic components

Live namespace

PLC Equipment OT signals
NR Node-RED Edge flows
Controller / cluster MQTT cluster · master serves API
DB Archive QuestDB history
API Data APIs Live + historical
Discover Schema + Data Catalog
Automate Triggers + captures
Handover Drain + resume
Supervise Health + memory guards
Observe Process + MQTT telemetry
Assistant Guidance + authoring · later
01

Publish with context

Give industrial data a stable hierarchy and identity at the source.

02

Govern continuously

Keep schemas and metadata consistent as connected systems change.

03

Reuse everywhere

Query live and historical data through the same namespace model.

UNS DataHub Runtime

Run the stack on your infrastructure.
Finish setup in the browser.

Keep operational data on premises with an integrated controller and open-source PostgreSQL, Eclipse Mosquitto, QuestDB, and Caddy infrastructure. The core data plane requires no managed cloud service.

RUN Private preview
uns-datahub-runtime

UNS DataHub Runtime

Install the integrated controller and local services, then configure the namespace through the browser setup wizard.

Open components, integrated preview. The SDKs, supporting services, reference application, and bootstrap are public. The complete Runtime is currently distributed through a private preview.

Already have access? 
curl -fsSL \
  https://github.com/uns-datahub/uns-datahub-bootstrap/releases/latest/download/install.sh |
  sh
"$HOME/.local/bin/uns-bootstrap" install

Requires Docker or Podman with Compose. During the private preview, the bootstrap asks for a read-only GitHub token, does not store it, verifies the matching download, and starts the setup wizard.

Read the Runtime quickstart → Review the public bootstrap ↗
Need access?

Request Runtime access

Join the list and we will contact you about access to the private UNS DataHub Runtime preview.

We’ll use your email only to contact you about Runtime early access. No marketing or sharing; deleted after notification.

Built for operations

Change the system.
Keep the flow under control.

Runtime makes service lifecycle, health, and controller authority visible. Planned changes use explicit handover; recovery actions stay configurable and observable.

01 Continuity

Coordinated service handover

Start the next version beside the active instance. The current subscriber drains queued work, passes a queue checkpoint, and exits after the replacement acknowledges the handover.

  • Parallel start
  • Drain + resume
  • Acknowledged cutover
02 Recovery

Health guards, not blind restarts

Combine process state with MQTT heartbeats and required service signals. Opt-in guards can restart on exit, enforce a memory ceiling, and recover unhealthy services after a threshold and cooldown.

  • Exit restart
  • Memory ceiling
  • Health cooldown
03 Visibility

One view across process and data health

Inspect versions, instances, active and alive state, memory, uptime, restarts, message counters, routes, logs, and dependency health from the same control plane.

  • Process + MQTT
  • Routes + dependencies
  • Logs + counters
04 Controller continuity

Heartbeat-led controller failover

Controllers coordinate through MQTT, elect a master from fresh heartbeats, and re-elect when authority becomes stale. Workloads can run across controller nodes while the master serves the control API.

  • Master election
  • Stale-heartbeat detection
  • Distributed workloads
05 Secret providers

Resolve secrets where services run

Reference environment variables or Infisical paths from typed configuration instead of placing credentials in repository files. Optional caching, Machine Identity token refresh, and a narrow bootstrap environment keep rotation and recovery operational.

  • Environment + Infisical
  • Machine Identity
  • Scoped bootstrap
06 Add-on catalog

One catalog for public add-ons and private services

Discover compatible system add-ons from configured public GitHub sources, then deploy your own tagged microservices from GitHub or Azure DevOps. Repository allowlists, add-on and controller compatibility checks, and commit verification keep the install path explicit.

  • Public + private
  • GitHub + Azure DevOps
  • Manifest + commit checks
07 Configuration

Version configuration, not just packages

Edit service configuration against its JSON Schema, begin from a packaged template, and retain snapshots per version and instance. Load and validate an earlier snapshot before applying it again.

  • Schema validation
  • Packaged templates
  • Version snapshots
08 Workload placement

Preflight a controller handover

Before starting matching service instances on another controller, Runtime checks package versions, process identity, target state, and normalized configuration. Any mismatch blocks the request and returns a reason for each affected instance.

  • Version match
  • Config hash
  • Per-instance results

Seeded Runtime demo

From industrial signal to reusable data.

A seeded rolling-mill application publishes equipment and measurements. UNS OpenHub discovers the hierarchy, exposes live values, and preserves governed metadata as the system changes.

01 Simulation

Hot rolling mill

Generate realistic equipment states and measurements from a seeded source.

HRM process watch showing a fictional rolling mill furnace, materials, process zones, descaling, rolling, and warehouse states
02 Hierarchy

Unified namespace

Discover equipment and signals in one shared hierarchy.

UNS OpenHub namespace tree showing a fictional steel plant, its equipment, material, and measurement attributes
03 Measurements

Live explore

Follow live measurements and inspect timestamped values.

UNS OpenHub Explore view charting a live temperature measurement with its timestamped values
04 Metadata

Governed schema

Keep asset identity and metadata stable across rebuilds.

UNS OpenHub Schema view listing discovered assets with status, namespace paths, and curated metadata
05 Preview · later phase

Ask with live context

Review live UNS measurements against retrieved operating guidance. Assistant capabilities are planned for a later phase.

Assistant preview assessing fictional stand bearing temperature and vibration against cited demo guidance with a five-minute temperature chart

These views use a seeded, fictional hot-rolling process.

Run the Runtime locally

The public stack

Small pieces that work
as one system.

Choose the pieces your architecture needs or connect the complete flow. Each project covers a distinct role and shares the same namespace model.

01 Toolkit

uns-kit

TypeScript and Python runtime libraries and project scaffolding for typed, structured UNS applications.

  • MQTT lifecycle
  • TypeScript + Python
  • Project scaffolding
Open repository ↗
02 Storage

UNS Archiver

Persist scalar and table packets to QuestDB with stable mappings, buffering, and recovery.

Open repository ↗
03 Access

UNS API Global

Authenticated current-value and historical queries, summaries, and bucketed time series.

Open repository ↗
04 Integration

Node-RED nodes

Subscribe to and publish contextualized UNS messages from familiar visual flows.

Open repository ↗
05 Reference app

Hot rolling mill simulator

See material flow, recipes, telemetry, storage, and APIs working together in one end-to-end example.

Explore the demo ↗

On the roadmap

What arrives next.

Connectivity bridges will bring external MQTT and OPC UA data into the same governed namespace model. The later Assistant direction connects governed process context with operator-reviewed schema and service authoring, while tool access stays policy-gated.

MQTT Planned public
uns-bridge-mqtt

External MQTT mapping bridge

Browse external MQTT brokers and map their payloads into a governed Unified Namespace structure.

OPC Planned public
uns-bridge-opcua

OPC UA Bridge

Browse OPC UA servers and map nodes and values into the same UNS model.

AI Later phase

Assistant for
governed operations

The direction goes beyond chat: connect live values with retrieved guidance, draft governed changes, prepare service bundles, and expose selected tools through a controlled local bridge.

01 · Context

Live signals + RAG

Compare live and historical measurements with retrieved operating guidance and cited source material.

02 · Schema

Operator-reviewed drafts

Search existing definitions, then propose reuse, updates, or new object types and attributes without auto-publishing.

03 · Services

Validated service bundles

Resolve confirmed UNS topics and prepare a service.bundle.json for TypeScript or Python scaffolding.

04 · Tool bridge

MCP-compatible, policy first

Early local access uses scoped short-lived tokens, loopback clients, read-only defaults, allowlists, traces, and audits.

Private implementation work currently uses OpenAI. Provider and on-prem inference alternatives are being evaluated; public scope and delivery are still under review.

Start from the source

Build the namespace
your data deserves.

View GitHub organization Browse @uns-kit on npm