Skip to content
Thermite SCADA
Why Thermite SCADA

Own the source of your industrial application.

Thermite SCADA gives your team plain-text project files, Git review, and explicit publication. Your agent can prepare changes using those files and the running gateway’s interfaces; your engineers review the result and decide what runs — on one license that never counts your servers.

Module-heavy stack
  • platform
  • browser HMI
  • historian
  • alarming
  • dataops
  • reporting
  • enterprise
  • redundancy uplift
≈ $31,000 list · per server
Thermite SCADA
  • platform license
$12,500 list · unlimited servers

One Rust runtime. HMI, historian, alarming, transactions, APIs, redundancy — included, on unlimited servers.

runtime
rust
config
git
Read it · Improve it · Pass it on

Keep the application understandable and reviewable.

Use plain-text source, published drafts, and the gateway’s data interfaces to inspect the system, review changes, and retain the knowledge behind them.

Read the configuration

Project manifests, tag definitions, alarm and history settings, screens, transactions, and queries are plain text. You and your agent search the same source to see how the application is configured.

Review the change

Use Git diffs and pull requests to compare a proposed edit with the version your team reviewed. Your people choose the review process and decide which source is ready to publish.

Publish explicitly

The CLI validates source before replacing a production or named draft snapshot. Review your draft, then run the publish command when you decide it is ready.

Keep runtime context

Project HTTP and WebSocket interfaces expose live tags, quality, current alarms, and history. Gateway interfaces expose device connection status and recent logs. These complement the configuration held in files.

Plan the deployment

Run a local gateway, host several project scopes, or configure a fenced active/standby pair. For redundant nodes, deploy matching configuration and provide a stable client endpoint with appropriate session handling.

Pass on the knowledge

Store reviewed project source and process documentation in your repository. Keep credentials, gateway identity, keys, journals, and historian data in a separate secured operational backup for recovery.

Text-first configuration

Find the setting in a file.

Configure gateway resources in config/server.toml and project content under projects/<slug>/. Search those files, inspect their context, and review the diff. Runtime values, logs, and history are available through the gateway’s interfaces.

Device configuration · example
# config/server.toml — example device entry
[[devices]]
name = "mf1"
driver = "modbus"
enabled = true

[devices.config]
host = "127.0.0.1"
port = 502
poll_rate_ms = 250

Device connections live in the site's gateway configuration, which stays private to the site. Tags, screens, and queries live in your repository.

Find it, change it
$ grep -n "poll_rate_ms" config/server.toml
10:poll_rate_ms = 250

# edit the value
- poll_rate_ms = 250
+ poll_rate_ms = 500

A search finds the setting. Change the value and the device polls every 500 ms; the gateway loads device changes without a restart.

Changes as diffs

Compare tag definitions, screen code, and alarm settings in Git. Review application references when changing a tag path, and test the affected screens before publishing production.

Keep the project knowledge

A new engineer can read source, review earlier changes, and consult the process documentation your team retains. Keep device maps and operating assumptions alongside the application source.

Files and runtime interfaces

Your agent can inspect the source files and read live values, quality, history, device status, and logs through gateway interfaces. You choose which tools and credentials it receives.

Your agent, your review

Every part, open to your agent.

AI-native means every part of Thermite SCADA is open to your own AI agent through plain-text project files, Git, the thermite command line, and the gateway’s HTTP and WebSocket interfaces. Your agent can read the project, prepare edits, publish a draft, and inspect the running result.

You choose the agent and model. Your people review changes and decide what runs. Bring your agent to a live demonstration with simulated devices, project files, live tags, and browser screens.

  • Read the system: your agent can inspect source, live values, device connection status, and recent gateway logs.
  • Review the change: your team chooses its Git review process and decides when to publish. Filesystem edits use your own access controls.
  • Choose your tools: edit the same source directly or with your agent, and publish using the thermite CLI.
Work with the agent you already use →
# Example task: prepare a melt-shop overview
# Give your agent the device maps and existing source.

Edit the secured gateway configuration:
  config/server.toml

Author project source:
  projects/melt-shop/project.toml
  projects/melt-shop/tags/melt-shop.toml
  projects/melt-shop/screens/overview/index.html
  projects/melt-shop/screens/overview/screen.js
  projects/melt-shop/screens/overview/style.css

# From the site directory, publish a review draft
thermite project draft melt-shop review

Open /draft/melt-shop/review/hmi/overview/
Review source, live values, quality, and screen behavior.

# After your team reviews the result
thermite project publish melt-shop
Open /p/melt-shop/hmi/overview/
inspect source
review diff
inspect draft
publish explicitly
Day in the life

Build and review a new furnace screen.

For a new holding-furnace screen, define the device mappings, process values, operator controls, quality indicators, and alarm display. Review the application against the process before publishing it.

Author the screen

Write the application files.

  1. 1. Use your device address map to configure connections in the secured site configuration.
  2. 2. Define typed tags in TOML, with paths, units, and the required history settings.
  3. 3. Create the screen directory with index.html, JavaScript, CSS, and custom graphics.
  4. 4. Subscribe to tags and render values, quality, charts, and alarm state in your screen code.
  5. 5. Connect operator controls to the tag-write API and handle write failures.
  6. With authentication on, the gateway checks project tag-write permissions.
Thermite SCADA

Inspect a draft. Review it. Publish.

  1. 1. Give your agent the screen requirements and the project files it needs to inspect.
  2. 2. Review its proposed tag paths, units, quality display, commands, and screen code.
  3. 3. Your agent can edit screens/hf2-overview/index.html and publish a named draft with the CLI.
  4. 4. Inspect the draft and its live tag values. Drafts share the gateway’s device connections.
  5. 5. Review the source and draft, then explicitly publish production. Keep Git history and runtime audit records.
  6. Publish and restart the gateway when changing alarm definitions.
At a glance

Architectural choices and the Thermite model.

Choose how you want to author, review, and deploy an industrial application. Thermite uses project files, Git workflows, and explicit publication.

Architectural choices across runtime, configuration, version control, workflow, validation, agent access, deployment, and pricing.
Dimension Alternative approach Thermite SCADA
Runtime Managed runtime or a service stack Compiled Rust binary
Configuration storage Platform-specific exports Plain-text project source
Version control Export snapshots for comparison Git branches, diffs, and reviews
Finding a setting Navigate a graphical configuration tool Search project files and gateway configuration
Development workflow Edit through a graphical authoring tool Edit files · Review a draft · Publish
Validation Checks supplied by the authoring tool Draft and publish validate TOML and expression graphs
Agent access Depends on the available files and interfaces Your agent uses files, Git, CLI, HTTP, and WebSocket; your team reviews changes and decides what runs
Deployment Separate services or application packages Gateway runtime with a configured site directory
Pricing model Per-module, per-server, + redundancy uplift One $12,500 license — unlimited servers, redundancy included
Pricing model

Per-server licensing compounds. One license doesn't.

The single-server comparison is already lopsided: a representative module-heavy stack tops $31,000 in public list prices, per server, while Thermite SCADA is $12,500 with everything included. But one server is the smallest comparison you can make. Real architectures are redundant pairs, per-site gateways, dev and staging environments, and fleets of edge nodes — and every one of them multiplies the per-server column. None of them changes ours.

Plan the deployment around the devices and applications each site needs. Review local operation, historian storage, access settings, redundancy, and client routing together. Your team retains the project source and deploys configuration to each gateway.

How per-server licensing compounds with architecture size, compared to one Thermite SCADA platform license.
Architecture Per-server stack Thermite SCADA
Single gateway $31,000 $12,500
Redundant pair $62,000 $12,500
Four sites, redundant — plus dev & staging (10 servers) $310,000 $12,500
Enterprise fleet — 40 servers across plants, standbys, and edge $1,240,000 $12,500

Left column: the representative $31,000 public-list stack × server count, before negotiated discounts. The right column isn't a volume discount — it's the model. One license, unlimited servers, redundancy included.

Discuss your requirements

Bring your device list, protocol requirements, screen needs, and operational constraints to a technical discussion. We can review tag mappings, database connections, local operation, and redundancy with your team.

View the product roadmap →

See the difference on a working demo.

Bring your agent to a live walkthrough with simulated devices, project files, live tags, and a browser HMI.