Skip to content
Thermite SCADA
Product Overview

Your projects, devices, screens, history, and alarms in one runtime.

Thermite SCADA is a Rust-native runtime, a project-as-app model, and a git-native development workflow — designed so a single unlimited license covers the capabilities your team actually ships, on as many servers as you deploy.

Gateway · Projects

One Thermite SCADA gateway can host many projects.

The gateway runs drivers, tags, history, alarms, HMI, APIs, and security. Each project has its own identity, screens, roles, device scope, and URL. Projects have separate tag namespaces and session scopes. A press line, a flow bench, and utility metering can share a gateway and its device and database connections.

  • One binary you can install, package, or containerize.
  • Each project ships as files: tags with alarm settings, screens, queries, and roles.
  • Project screens use URLs such as /p/press-line-a/hmi/overview/.
  • Your project manifest defines which shared devices and databases it can use.
line-a lab-1 utility Thermite SCADA gateway /p/line-a/ /p/lab-1/ /p/utility/ project scopes one URL per project
gateway
thermite-gw-01
projects
3 project scopes
URL surfaces
/p/line-a/ · /p/lab-1/ · /p/utility/
Project as files

Projects are folders. Folders are reviewable.

Your project contains manifests, tags, screens, transactions, and queries. Review them in Git and back up credentials, published state, and runtime data separately.

# Example site layout
plant-a/
├── config/
│   └── server.toml       # private gateway configuration
├── projects/
│   └── press-line-a/
│       ├── project.toml  # identity, scope, roles
│       ├── tags/
│       │   ├── hydraulics.toml
│       │   └── recipes.toml
│       ├── screens/
│       │   └── overview/
│       │       ├── index.html
│       │       ├── screen.js
│       │       └── style.css
│       ├── transactions/
│       │   └── cycle-log.toml
│       └── queries/
│           └── shift-summary.toml
├── published/            # CLI-managed snapshots
└── logs/                 # runtime journals
Why files

Git keeps your project history. Compare changes with branches and diffs, then publish with the thermite command line. Back up historian data, credentials, gateway identity, keys, and journals separately.

Why project scope

Each project has its own screens, roles, URLs, tag namespace, and session scope. Projects share the gateway process, device connections, and database resources.

Why one binary

Run the Rust gateway directly on Windows or Linux, or in a Docker container. Size your host for the devices, polling rates, screens, and history you need.

Subsystems

What's inside a Thermite SCADA gateway.

The gateway connects devices, hosts project screens, records history, evaluates alarms, and exposes data through HTTP and WebSocket interfaces.

Gateway / server

A Rust-native runtime that hosts your projects, runs drivers, serves screens, records history, evaluates alarms, and exposes APIs.

Project-as-app

Each project is a standalone industrial application with its own identity, branding, users, roles, device scope, screens, and URL path.

Tags & real-time engine

Hierarchical tags with type, quality, timestamp, scan groups, and read-only expressions. Updates flow over WebSocket to HMIs and APIs.
Learn more →

HMI runtime

Web-based screens served per project, with real-time bindings, a base theme, and HTML, CSS, and JavaScript stored as files.
Learn more →

Historian & queries

PostgreSQL history with per-tag recording, deadbands, sampling rate limits, and raw or aggregated JSON queries.

Transactions & named queries

Write tag values to PostgreSQL, read database values into tags, and execute parameterized named queries through the administrator API.

Alarming & notifications

Numeric limits, boolean alarms, deadbands, delays, shelving, notification escalation, schedules, and a JSON-lines alarm journal.

Security & project scope

With authentication on, project sessions and roles govern writes and history reads. The audit log records runtime events.
Learn more →

Your AI agent

Your agent edits project files, publishes drafts with the thermite command line, and reads live values over HTTP and WebSocket. You choose the agent and model. Your people review and decide.
Learn more →

Git-native workflow

Projects and config are human-readable files. Branch, diff, review, validate, and deploy like the rest of your software.

APIs & integrations

Project HTTP and WebSocket APIs, PostgreSQL named queries and transactions, and alarm-notification webhooks.

Deployment options

Run your gateway on Windows or Linux, or use the supplied Docker build.
Learn more →
Tag → HMI → Historian

From device values to screens and history.

Drivers normalize device values into tags. The runtime keeps them current and pushes updates to bound HMIs over WebSocket. The historian persists them with quality and timestamp according to each tag's recording settings.

01
Driver
Modbus TCP, EtherNet/IP/CIP, S7, OPC UA client, MQTT, BACnet/IP
02
Tag engine
type · quality · timestamp · scan group
03
Runtime cache
scoped values · expressions
04
HMI / API
WebSocket · REST · SQL · projects
05
Historian
PostgreSQL · deadbands · aggregation

See the platform on a running gateway.

Explore a working demo with simulated devices, live tags, and an HMI. Bring the agent you already use to a live session.