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.
- platform
- browser HMI
- historian
- alarming
- dataops
- reporting
- enterprise
- redundancy uplift
- platform license
One Rust runtime. HMI, historian, alarming, transactions, APIs, redundancy — included, on unlimited servers.
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.
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.
# 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.
$ 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.
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.
# 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/
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.
Write the application files.
- 1. Use your device address map to configure connections in the secured site configuration.
- 2. Define typed tags in TOML, with paths, units, and the required history settings.
- 3. Create the screen directory with index.html, JavaScript, CSS, and custom graphics.
- 4. Subscribe to tags and render values, quality, charts, and alarm state in your screen code.
- 5. Connect operator controls to the tag-write API and handle write failures.
- With authentication on, the gateway checks project tag-write permissions.
Inspect a draft. Review it. Publish.
- 1. Give your agent the screen requirements and the project files it needs to inspect.
- 2. Review its proposed tag paths, units, quality display, commands, and screen code.
- 3. Your agent can edit screens/hf2-overview/index.html and publish a named draft with the CLI.
- 4. Inspect the draft and its live tag values. Drafts share the gateway’s device connections.
- 5. Review the source and draft, then explicitly publish production. Keep Git history and runtime audit records.
- Publish and restart the gateway when changing alarm definitions.
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.
| 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 |
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.
| 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.
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.