Part of: Control

PLC programming with real software tooling.
The toolchain is free.

Compile-check and test IEC 61131-3 Structured Text from the command line, in VS Code and in CI. Tests run in virtual time, so a 10-second timer test takes milliseconds. Free for Linux, macOS and Windows. The Voltrus PLC IDE adds Ladder, FBD and SFC editors, a softPLC and deployment to ESP32 and Linux for $29.99 one-time.

Free
ST toolchain
$29.99
IDE, one-time
JUnit
Test reports for CI
Free ESP32
Runtime

Check and test PLC code like the rest of your code.

The compiler and test runner from the IDE, as free command-line tools for Linux, macOS and Windows, plus a language server and a VS Code extension. No licence key and no account.

Free

voltrus-plc check

Compiles every .st file in a folder and prints each problem as file:line:col. Exits with code 1 on any error, so a program that does not compile fails the build. Ladder, FBD and SFC files saved by the IDE are checked too.

Free

voltrus-plc test

Runs the scenarios in every *.test.yaml: seed variables, set inputs, advance time, check outputs. Time is virtual and nothing sleeps, so a test of a 10-second TON finishes in milliseconds and gives the same result every run. Writes JUnit XML or JSON.

Free

voltrus-lsp and VS Code

A language server for Structured Text with diagnostics, hover, go-to-definition and completion. The VS Code extension adds syntax highlighting, checks for test files and a Run Tests command.

Coming soon VS Code Marketplace listing
Install and runLinux · macOS · Windows
# Linux x86_64 (also: linux-aarch64, macos-aarch64, macos-x86_64, windows-x86_64)
url=$(curl -fsSL https://dl-voltrus-plc.voltrus.id/releases/toolchain/latest.json | jq -r '.files["linux-x86_64"].url')
mkdir -p ~/.local/bin && curl -fsSL "$url" | tar -xz -C ~/.local/bin

# voltrus-plc and voltrus-lsp are now on your PATH:
voltrus-plc check src/
voltrus-plc test tests/ --junit report.xml
src/StartDelay.stStructured Text
PROGRAM StartDelay
VAR
  start_cmd   : BOOL := FALSE;
  motor_on    : BOOL := FALSE;
  start_timer : TON;
END_VAR
start_timer(IN := start_cmd, PT := T#10s);
motor_on := start_timer.Q;
END_PROGRAM
tests/StartDelay.test.yamlruns in milliseconds
# tests/StartDelay.test.yaml
program: ../src/StartDelay.st
scan_ms: 10

scenarios:
  - name: motor starts 10 s after the start command
    steps:
      - set: {start_cmd: true}
        advance: 9.5s
        expect:
          motor_on: false
      - advance: 1s
        expect:
          motor_on: true
.github/workflows/plc.ymlGitHub Actions
# .github/workflows/plc.yml
name: PLC
on: [push, pull_request]
jobs:
  check-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install the Voltrus PLC toolchain
        run: |
          url=$(curl -fsSL https://dl-voltrus-plc.voltrus.id/releases/toolchain/latest.json | jq -r '.files["linux-x86_64"].url')
          mkdir -p "$RUNNER_TEMP/plc" && curl -fsSL "$url" | tar -xz -C "$RUNNER_TEMP/plc"
          echo "$RUNNER_TEMP/plc" >> "$GITHUB_PATH"
      - run: voltrus-plc check src/
      - run: voltrus-plc test tests/ --junit report.xml
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: plc-test-report
          path: report.xml

Each step can set inputs, advance by scans (25scans) or time (500ms, 2s), and expect exact values or a numeric window ({approx: 42.0, tol: 0.001}). Exit code 0 means everything passed; any compile error or failed scenario exits non-zero, so CI fails the build. Toolchain manifest: latest.json.

PLC code rarely gets the tooling other code gets.

Application developers expect a compiler they can script, tests that run on every commit and an editor that knows the language. In most PLC work the program lives inside one vendor IDE, and the test is a person watching I/O on a bench.

01

No build gate

If the only compiler is inside a desktop IDE, nothing stops a change that does not compile from being merged. voltrus-plc check runs in any CI job and fails it.

02

Tests that wait for real time

Testing a timer sequence on a simulator means waiting for every timer to run out, again after each change. Virtual time runs the same scans without the waiting.

03

Projects git can't read

Binary or XML project files give diffs nobody can review. Voltrus PLC keeps ST as plain .st files and tests as YAML, so a pull request shows what changed.

04

Paid or Windows-only tooling

Modern editor tooling for PLC languages is often a paid subscription, and most PLC IDEs run only on Windows. The Voltrus toolchain is free and runs on Linux, macOS and Windows.

The IDE: four languages, a softPLC and real I/O.

The Voltrus PLC IDE is $29.99 one-time for macOS, Windows and Linux. It uses the same compiler as the free toolchain and adds graphical editors, a softPLC with a watch table and debugger, protocol drivers and deployment to hardware.

01

Structured Text Editor

CodeMirror 6 with IEC 61131-3 ST syntax highlighting, bracket matching, code folding, and autocomplete for keywords, types, and standard functions. Feel like you're in VS Code, not a 1990s ladder editor.

02

Built-in SoftPLC Runtime

Custom bytecode VM with cyclic scan engine. Compile ST → bytecode → run locally. Adjustable scan cycle from 1ms to 1s. Run, Stop, and Step controls. Watch your program execute in real-time, no hardware required.

03

Modbus TCP + RTU I/O

Real I/O drivers wrapping mt-modbus. Direct address support (%IX0.0, %QW100, %MW200). Map variables to Modbus registers through the I/O mapping panel. Read/write real devices from your ST program.

04

Live Watch Table

Monitor variable values in real-time while the runtime is running. Add variables to watch, see values update every scan cycle. No more printf debugging: see exactly what your PLC program is doing at every step.

05

Timer & Counter Blocks

Real implementations of IEC 61131-3 standard function blocks: TON, TOF, TP (timers), CTU, CTD, CTUD (counters), R_TRIG, F_TRIG (edge detection). Not stubs: properly implemented with correct timing behavior.

06

Diagnostics Panel

Compile errors and warnings with source locations. Inline error squiggles in the editor. See exactly what failed and where, not a cryptic "Compilation failed" dialog.

07

AI-Assisted Programming

Describe logic in plain language and get ST code. Click a diagnostic and get a suggested fix. The assistant sees your variables, POU structure and I/O mapping. Use your own Anthropic API key or a local Ollama model.

08

Multi-File Projects

Project tree sidebar with folder-based .st files. Multi-file tabs with save/load to disk. Go-to-definition for variables and function blocks. Structured like a real software project, because PLC code is software.

09

Deploy to ESP32-S3

Write ST, compile to bytecode, deploy to a $5 ESP32-S3 microcontroller over WiFi. The VM runs on bare metal with FreeRTOS, connecting to real GPIO, RS485, and Modbus devices. Free runtime: no per-device license.

10

Deploy to Linux

Run the standalone runtime on RevPi Core, Raspberry Pi, Wago PFC200, UniPi Neuron, or any industrial PC. Full protocol support: Modbus, S7, EtherNet/IP, OPC-UA, MQTT. From $49/device.

11

Offline Simulation

Built-in softPLC runs on your Mac, no hardware needed. Develop and test your ST programs locally with the watch table and trend chart. Toggle between local simulation and remote deployment with one click.

12

SCADA Integration

Native connection to Voltrus SCADA for live dashboards, alarm management, and HMI screens. Variables stream directly from the runtime, no OPC-UA bridge required. One ecosystem from code to visualization.

How it stacks up against the incumbents

Voltrus PLC doesn't try to be CODESYS. It's for engineers who want to write ST code, run it locally, and talk to real devices, on their Mac. Here's the honest comparison.

Factor
Voltrus PLC
CODESYS
TIA Portal
Beckhoff TwinCAT
macOS Native
Yes: Apple Silicon
Windows only (IDE)
Windows only
Windows only
IDE Size
~30MB
~2GB
~20GB
~4GB
Price
Toolchain free · IDE $29.99 one-time
Free IDE + per-device runtime €50-500
€2K–€20K+
Paid: not transparent
ST command-line tools, language server, VS Code extension
Free toolchain: Linux, macOS, Windows
Part of the Windows IDE
SIMATIC AX: paid subscription
Part of the Windows IDE
AI-Assisted Programming
Yes: code gen + explain + fix
No
No
CoAgent (2025, Windows only)
Modern Editor
CodeMirror 6 in the IDE, or VS Code with the free extension
Legacy custom editor
Custom GUI toolkit
Visual Studio shell
Git-Friendly
Plain-text .st files
Binary .project files
Binary: API only
XML (noisy diffs)
IEC 61131-3 Languages
ST + LD + FBD + SFC
All 5 + CFC
All 5 + SCL
All 5 + C++
Hardware Targets
SoftPLC + ESP32-S3 + Linux IPC + Modbus + OPC-UA + S7 + MQTT
400+ manufacturers
Siemens only
Beckhoff only
Vendor Lock-In
None: standard ST code
Low: 85% portable
Total: Siemens only
Beckhoff hardware
SoftPLC Included
Yes: free
Yes: free
PLCSIM €1,500+
Yes: local runtime
Runtime Targets
ESP32 + Linux + Simulation
400+ vendors
Siemens only
Beckhoff only
Runtime Price
Free ESP32 / $49-149 Linux
€50–500 per device
Included in €2K+ license
Paid: not transparent
SCADA Integration
Native: Voltrus SCADA
Via OPC-UA bridge
Via OPC-UA bridge
Via ADS/OPC-UA
Protocols
Modbus + OPC-UA + S7 + MQTT + EIP
Everything via add-ons
PROFINET native
EtherCAT native

Where Voltrus PLC is stronger: free command-line and editor tooling, tests that run in CI, macOS support, size, runtime pricing and ESP32 deployment. Where CODESYS, TIA Portal and TwinCAT are stronger: protocol breadth and the hardware ecosystem (400+ vendors). Vendor offerings change; check current terms with each vendor.

Every release shipped: v0.1 → v2.0.

This isn't a promise list: every phase below is live in the current v2.0: ST + LD + FBD + SFC graphical editors, mixed-language projects, and interactive simulation mode. Deploy to ESP32, Linux, or simulation.

v0.1: Done

Core Pipeline

ST compiler + bytecode VM + CM6 editor + watch table + runtime controls. Compile → Run → Watch working end-to-end.

v0.2: Done

Editor & Real I/O

Multi-file projects, project persistence, autocomplete, inline errors, dark/light theme. Modbus TCP driver with I/O mapping. Timer/counter FBs.

v0.3: Done

AI-Assisted Programming

Claude API + local Ollama integration. AI chat, code generation, code explanation. Context-aware with diff-based apply. Multiple POU types, arrays, templates.

v0.4: Done

Debugging & Multi-Driver

Breakpoints, single-step, call stack, force variables, trend chart. OPC-UA + Siemens S7 + MQTT + EIP drivers. .voltrus project format, cross-reference.

v1.0: Done

Production Release

Full IEC 61131-3 ST compliance. Comprehensive standard library. License activation. Auto-update. Direct download via Cloudflare.

v1.1: Done

Standalone Runtime

Deploy bytecode to ESP32-S3 (free) and Linux industrial PCs ($49-149/device). gRPC for Linux, WebSocket + FlatBuffers for ESP32. SCADA integration. Write once, deploy anywhere.

v2.0: Current

Graphical Languages

Ladder Diagram (LD), Function Block Diagram (FBD), Sequential Function Chart (SFC) editors with drag-and-drop canvases. Mixed-language projects. Interactive simulation mode with I/O toggle panel.

Write once, deploy anywhere

Same ST code runs in simulation on your Mac, on a $5 ESP32 microcontroller, or on a production-grade Linux industrial PC. One compiler, one bytecode format, three deployment targets.

ESP32-S3

Microcontroller PLC

Free Runtime

Turn a $5 ESP32-S3 into a PLC. Flash Voltrus Runtime, deploy your ST program over WiFi, and it runs 24/7 on bare metal with FreeRTOS. Connect to real GPIO, RS485, and Modbus devices.

  • 240MHz dual-core, PSRAM
  • WiFi + GPIO + RS485
  • WebSocket + FlatBuffers transport
  • ~140KB RAM available for VM
Linux Industrial

Industrial PC Runtime

Run on RevPi, Raspberry Pi, UniPi Neuron, Wago PFC200, or any Linux industrial PC. Full protocol support: Modbus, S7, EtherNet/IP, OPC-UA, MQTT. Deploys as a systemd service.

  • ARM64 + x86_64
  • gRPC remote control + streaming
  • Breakpoints, force variables, trend
  • mDNS auto-discovery
Simulation

Built-in SoftPLC

Included with IDE

Develop and test without any hardware. The softPLC runs directly in the IDE on your Mac. Watch variables in real-time, set breakpoints, plot trends. Toggle between simulation and remote with one click.

  • Zero-config: just press Run
  • Adjustable scan cycle 1ms–1s
  • Full debugging support
  • No hardware dependencies

Write once, deploy anywhere. Same ST code runs in simulation on your Mac, on a $5 ESP32, or on a production-grade Linux industrial PC. No per-device tax on the ESP32, it's free.

Built for engineers who carry MacBooks into the field.

PLC programming on Mac isn't a niche anymore. Engineering students, field commissioners, machine builders, and IoT developers are all choosing macOS, and they all need PLC tools.

EDU

PLC Training & Education

Learn IEC 61131-3 Structured Text without buying a $2,000 PLC trainer. Start with the free toolchain and VS Code, write tests for each exercise, then move to the IDE's softPLC and a $5 ESP32 for real hardware.

FLD

Field Commissioning

You're on-site with a MacBook. The PLC is running but a register looks wrong. Write a quick ST program, map it to the device's Modbus registers, and verify the behavior, natively, no VM.

OEM

Machine Builder R&D

Prototype control logic on your Mac, test in simulation, then deploy to a RevPi or industrial PC running Linux. No CODESYS runtime license per device: $49 for Basic, $149 for Pro with all protocols.

IOT

IoT Edge Control

Deploy ST programs to $5 ESP32-S3 microcontrollers for sensor monitoring, or to Linux edge devices for protocol bridging. Free ESP32 runtime: no per-device licensing for your IoT fleet.

LAB

Lab & Bench Testing

Test PLC logic without a PLC. Map your ST variables to a Modbus simulator, run scenarios, verify behavior. No hardware on the bench: just your Mac and the app.

CI

Reviewed, Tested PLC Changes

Keep ST in git, run voltrus-plc check and voltrus-plc test on every pull request, and read the JUnit report in your CI. The toolchain is free, so every runner and every reviewer can have it.

Compile ST code in your browser. No download required.

The same IEC 61131-3 Structured Text compiler that powers Voltrus PLC, compiled to WebAssembly and running right here. Edit the code, hit compile, see the results.

Editor
Loading compiler...
Output Waiting

Click Compile to run the
ST compiler in your browser

Part of: Control · Give your own software protocol access to PLCs and field devices.

How Voltrus PLC differs from…

  • Voltrus Gateway

    Voltrus Gateway runs no logic: it exposes existing PLCs to your software over one gRPC API.

  • Voltrus S7 Explorer

    The MacTools explorers read and test PLCs that are already running. Voltrus PLC is where you write the program.

Not sure? See which one you need →

Common questions

Yes. Voltrus PLC is a native app built with Rust and Tauri. It runs natively on both Apple Silicon and Intel Macs. No Rosetta, no virtual machines, no translation layers. The compiler, VM, and editor are all compiled to ARM64.
For ST, LD, FBD, and SFC-based projects, increasingly yes. You can develop on Mac, deploy to ESP32 ($5 hardware, free runtime) or Linux industrial PCs ($49-149/device), and integrate with Voltrus SCADA natively. If you need support for 400+ hardware targets, CODESYS is still the standard. Voltrus PLC is the Mac-native, lightweight alternative with four IEC languages and real deployment targets.
Structured Text (ST) is the primary language with full compliance. Ladder Diagram (LD), Function Block Diagram (FBD), and Sequential Function Chart (SFC) editors are available in v2.0 with visual editors and ST transpilation. All four languages can be mixed in the same project.
Three deployment targets: (1) Built-in softPLC on your Mac for simulation, no hardware required. (2) ESP32-S3 microcontrollers: flash the free Voltrus Runtime, deploy your ST program over WiFi, connect real GPIO and RS485. (3) Linux industrial PCs: RevPi, Raspberry Pi, UniPi, Wago, or any Linux box. For communicating with existing PLCs (not running Voltrus), Modbus, OPC-UA, Siemens S7, MQTT, and EtherNet/IP drivers are all included.
No. The Structured Text toolchain (voltrus-plc CLI, voltrus-lsp language server, VS Code extension) is free. The IDE is a one-time purchase of $29.99 with no yearly fee. The ESP32 runtime is free; Linux runtime licences are $49 (Basic) or $149 (Pro, all protocols) per device. Optional cloud plans for hosted AI, cloud projects and team sharing are coming later and are not priced yet. The toolchain and the IDE work without them.
The voltrus-plc command-line tool and the voltrus-lsp language server, for Linux, macOS and Windows, plus a VS Code extension. voltrus-plc check compiles every .st file in a folder and exits with an error code when something fails. voltrus-plc test runs the scenarios in *.test.yaml files and can write JUnit XML or JSON for CI. The extension gives you syntax highlighting, diagnostics, hover, go-to-definition, completion and Run Tests. No licence key or account is needed. See install and examples.
voltrus-plc test runs the program in virtual time. Each scan advances the clock by scan_ms (10 ms by default) without sleeping, and TON, TOF and TP timers follow that clock. A scenario that advances 10 seconds runs 1,000 scans and finishes in milliseconds, with the same result on every run.
(1) Generate ST code from natural language: describe "start a motor when sensor reads above 50°C" and get the code. (2) Explain selected code in plain English. (3) Click a compile error, get a suggested fix. (4) Auto-generate test cases. The AI knows your variables, POU structure, and I/O mapping: it sees what you see in the editor. It runs on your own Anthropic API key or a local Ollama model. Hosted AI without your own key is planned for the cloud plans.
Yes. The standalone Voltrus Runtime (v1.1) runs on Linux industrial targets including RevPi Core, Raspberry Pi 4/5, UniPi Neuron, Wago PFC200, and any x86_64 industrial PC. The IDE compiles your ST to bytecode and deploys it over gRPC. The same bytecode also runs on ESP32-S3 microcontrollers. Develop on your Mac, deploy to real hardware: same code, three targets (simulation, ESP32, Linux).
The Voltrus PLC IDE compiles your ST code to a bytecode bundle. You deploy it over WiFi to an ESP32-S3 running the Voltrus Runtime firmware. The ESP32 executes the bytecode in a FreeRTOS task with a cyclic scan loop (read inputs, execute VM, write outputs). It connects to real hardware via GPIO pins and RS485, and streams variable values back to the IDE via WebSocket. The runtime is free: buy any ESP32-S3 board for about $5 and you have a PLC.
Yes. The free toolchain has builds for Linux, macOS and Windows. The IDE is built with Tauri and downloads as a DMG for macOS (Apple Silicon and Intel), a .deb for Linux and a .zip for Windows. macOS is where the IDE gets the most testing.
Now. Install the free toolchain from the toolchain section and point it at your .st files. The IDE (v2.0) is available with four IEC 61131-3 languages (ST + LD + FBD + SFC), softPLC runtime, AI-assisted programming, multi-driver I/O, debugging, mixed-language projects, and simulation mode. Deploy to ESP32-S3 (free) and Linux industrial PCs ($49-149/device).

Pricing

Start free.
Pay once for the IDE.

The toolchain costs nothing. The IDE is a one-time licence. Runtimes are priced per device only when you deploy to Linux hardware.

Free

ST toolchain

$0
No licence key, no account
  • voltrus-plc check and test
  • JUnit XML and JSON reports for CI
  • voltrus-lsp language server
  • VS Code extension (Marketplace listing coming soon)
  • Linux, macOS, Windows
Get the toolchain
One-time

Voltrus PLC IDE

$29.99
Pay once, keep it
  • ST, Ladder, FBD and SFC editors
  • SoftPLC with watch table, breakpoints and trends
  • Modbus, OPC-UA, S7, EtherNet/IP, MQTT drivers
  • AI assistant with your own key or Ollama
  • Deploy to ESP32-S3 and Linux
Buy the IDE: $29.99
Coming soon

Cloud plans

Solo and Team plans with hosted AI (no API key of your own), cloud projects and team sharing at app.plc.voltrus.id. Prices are not set yet. The toolchain and the IDE do not need them.

Runtimes: deploy to hardware (optional, later)

ESP32
Runtime
Free
No license
ESP32-S3 target. $5 hardware. No per-device fee.
Linux
Runtime Basic
$49
Per device
RevPi, RPi, IPC. Modbus + MQTT.
Buy license →
Linux
Runtime Pro
$149
Per device
All protocols. S7, OPC-UA, EIP, SCADA link.
Buy license →
Buy the IDE: $29.99 Download the IDE for Mac (Apple Silicon)

Stay Updated

Get notified about the VS Code extension and cloud plans

An email when the Marketplace listing goes live and when cloud plan prices are set, and when new runtime targets and drivers ship. Product updates only.