IMD SolutionComputing LibraryShop main store

Selection guide

Choosing an operating system image for an industrial PC

Operating systems on the plant floor Published 8 min read

Short answer

Order the industrial PC with the vendor image closest to your runtime: Windows IoT Enterprise LTSC where the vendor documents it for your model, the vendor's qualified Linux for a Linux stack, or the BSD image if your code builds on FreeBSD. Bring-your-own images are the fallback for monitoring-class loads. Qualify your binaries on the exact model and image; support and real-time behavior are model-specific.

On this page
  1. What operating system do industrial PCs ship with?
  2. Can I install my own Linux on an industrial PC?
  3. Is the OS supported on my exact industrial PC model?
  4. Can I run my own binaries on the vendor's BSD image?
  5. Do I need a real-time OS for sensor monitoring?
  6. How do I test my software on an industrial PC image?
  7. Which operating system image should I order?
  8. Questions asked

Order the industrial PC with the vendor image closest to your runtime and qualify your own binaries on that exact model before you commit: Windows IoT Enterprise LTSC where the vendor documents it for the machine, the vendor's industrial Linux where your model is on its qualified list, or the FreeBSD-based image when your code and dependencies build there. A self-installed distribution is the fallback for a monitoring-class workload that no vendor image can run, and the wrong order for anything that needs a deterministic cycle in the 10 ms class. Support and real-time behavior are model-specific; a compatibility statement for one model says nothing about the next one.

What operating system do industrial PCs ship with? #

Four realistic options exist: Windows IoT Enterprise LTSC, a vendor-built industrial Linux, a BSD image carrying the vendor's control runtime, or no operating system at all. The first three arrive as vendor-supported orders; the fourth exists so you can bring your own.

Image What it is What you still own Fits when
Windows IoT Enterprise LTSC Long-term servicing Windows branch, licensed by the PC vendor for the machine Your application and its patch schedule A Windows-native stack the vendor documents on your model
Vendor industrial Linux A distribution the vendor builds and preconfigures for its hardware Your services and their dependency set A Linux runtime, with your model on the vendor's qualified list
BSD image with control runtime FreeBSD plus the TwinCAT runtime components, delivered as TwinCAT/BSD Your own binaries beside the idle runtime FreeBSD-portable code, with a later move to TwinCAT kept open
No operating system Blank machine, vendor driver repository Kernel, drivers, updates, security hardening No vendor image runs your stack and the load is monitoring-class

The no-OS option is on the list because the hardware is standard PC architecture; the vendor images exist because a driver set, kernel settings and runtime components tested together on one board are worth paying for in avoided integration work.

Can I install my own Linux on an industrial PC? #

Yes at the hardware level: vendors ship industrial PCs without an operating system so you can install your own, and a standard distribution install is what the no-OS order exists for. What you give up is the vendor's qualification — drivers, kernel configuration and every security update become your problem.

Ordering without an OS is a standard option, and running your own image on it is common practice. The catch is not possibility but ownership: the vendor's image is a tested set, while your distribution re-derives all of it. If you go this way:

  • Pin the distribution release and archive the installed image, so a rebuild reproduces it.
  • Confirm every device in the unit — network controllers, storage, graphics — has working drivers on your kernel version.
  • Take the update schedule as yours: kernel changes, security patches and the regression testing they demand.

The decision rule: a self-installed image is for monitoring-class loads that no vendor image can run. If the trial could grow into deterministic control, this is where the later project gets expensive — start from the vendor's qualified set instead.

Is the OS supported on my exact industrial PC model? #

Support is declared per model, so ask for a written statement that names both the computer and the OS build. Rockwell Automation, for example, documents full support for Microsoft Windows IoT Enterprise LTSC on its ASEM 6300 industrial computers.

That is the pattern to demand regardless of vendor. Beckhoff's documentation works the same way: TwinCAT/BSD is offered as an alternative operating system for its current industrial PC platforms, and Beckhoff RT Linux is a Debian-based distribution preconfigured for industrial use, with model coverage stated rather than implied. A vendor selling a Linux image on one model has told you nothing about the model you actually need.

Decision rule: no compatibility statement for your model number and OS version means the combination is unqualified. Choose a model that carries the statement, or budget a qualification program of your own — do not order on the strength of a same-vendor precedent on different hardware.

Can I run my own binaries on the vendor's BSD image? #

Yes, and it is a documented path: TwinCAT/BSD is FreeBSD with the TwinCAT runtime integrated, and its documentation covers compiling your own C/C++ code locally on the industrial PC and debugging it remotely. You install dependencies and run services; the runtime stays installed and idle.

Two boundaries shape the practice:

  • The TwinCAT components ship installed and remain installed. Stripping them out is not a supported path, and those who have attempted it report it is far from clean, so treat them as resident.
  • FreeBSD is not Linux. A binary built against Linux libraries will not load unchanged; the dependable route is building for FreeBSD — one cross-compile for a statically linked Go service, a porting exercise for anything tied to Linux-only libraries or kernel modules.

On the vendor's Linux image your service lives the way it does on any Debian system, under the image's normal service management — the same pattern as installing Node-RED natively on a Linux edge computer. For the choice between the vendor's two non-Windows images, Beckhoff RT Linux or TcBSD: which OS for a TwinCAT IPC lays out the trade-offs in one place.

Do I need a real-time OS for sensor monitoring? #

Decide by cycle time: deterministic PC-based control runtimes work in the 1 to 10 ms range, so if your data may be hundreds of milliseconds old — a 300-sensor monitoring feed with a one-second data-age limit — a standard image carries it, and the budget below shows the margin.

An ordinary operating-system service runs concurrent work well and still gives no bound on when a packet is handled; that unbounded scheduling is the entire difference. Monitoring tolerances are usually two orders of magnitude looser than control cycles, and a budget makes it concrete.

Worked example — the customer limit and the poll periods come from the process requirement; the transit and processing values are placeholders you replace with measurements from your own machine:

  • Inputs: 300 sensors; gateway publish period 100 ms; data-age limit 1,000 ms; DCS Modbus poll period 1,000 ms; LAN transit 1 ms (placeholder); service processing 15 ms (placeholder).
  • Worst-case age with the current poll period: 100 ms + 1 ms + 15 ms + 1,000 ms = 1,116 ms. That breaches the limit, and the offender is the DCS poll period, not the operating system.
  • Poll period cut to 500 ms: 100 ms + 1 ms + 15 ms + 500 ms = 616 ms. Margin: 1,000 ms − 616 ms = 384 ms, or 38 percent of the limit.
  • Decision: the standard image holds this load once the poll period is fixed; re-run the budget with measured values before you sign the architecture.

The decision reverses when the requirement is a 10 ms deterministic scan or the sensors sit on a real-time fieldbus segment such as EtherCAT: acquisition then belongs in the vendor's real-time stack on a model qualified for it, which is what the vendor kernel's scheduling control is for. One boundary no image crosses: none of this makes a data feed safety-rated, and any function that trips equipment stays in certified safety hardware.

How do I test my software on an industrial PC image? #

Qualify on the exact model, image and version you will ship, because a driver result or boot behavior proven on one build is a claim about that build only. Install, load, measure, and prove unattended recovery before sign-off.

Run the qualification as a fixed sequence and record each result:

  1. Order one unit of the exact model with the exact image and version you plan to deploy; record model, image build and version in the project file.
  2. Install your runtime and dependency set on that image and pin every package version.
  3. Prove the network driver on the target: link speed, sustained throughput, and a capture showing gateway traffic arriving intact. A virtual dry run such as validating Linux driver work in QEMU before hardware catches build breaks early, but only the target hardware proves the driver.
  4. Load-test at the real rate: generate or replay all 300 sensor streams at their publish period and measure end-to-end data age against the budget above.
  5. Prove recovery: cut power under load, restore it, and confirm the firmware's power-loss restart setting boots the machine and your service reconnects with no keyboard attached.
  6. Freeze the build: image version, kernel, package list and the measured results go into the tender record, so any later OS change restarts qualification deliberately.

Which operating system image should I order? #

Match the image to the runtime: Windows IoT Enterprise LTSC for a Windows-native stack the vendor documents on the model, the vendor Linux for a Linux stack on a qualified model, the BSD image for FreeBSD-portable code, and no OS only as a monitoring-class fallback.

The five cases, each with its order:

  • Windows-native application and a compatibility statement in hand — order the LTSC image; your risk is application testing, not drivers.
  • Linux application, model on the qualified list — order the vendor Linux image and run your service under its service management.
  • FreeBSD-portable code, a later TwinCAT move plausible — order the BSD image as shipped and build your binaries for FreeBSD.
  • Deterministic 10 ms-class control, or a real-time fieldbus in the acquisition path — order the vendor's real-time runtime on a model qualified for exactly that combination, never a self-built kernel.
  • Nothing above fits and the load is monitoring-class — order without an OS, deploy your pinned distribution, and put your own name on every update.

For a trial host of this shape — a cabinet-mounted box ingesting gateway data and serving Modbus to the DCS — a fanless industrial mini PC ordered with the chosen image preinstalled starts the qualification clock from a supported baseline instead of a blank machine.

Questions asked

Does installing my own operating system affect the vendor's hardware warranty?

Hardware warranty and operating-system support are separate agreements. The vendor supports the images it documents and the machine itself; a self-installed distribution is owner-maintained, so driver questions and kernel faults are yours to solve even while the hardware warranty stands. Read the vendor's support terms for the exact split before ordering a machine without an OS.

Will Linux binaries run on a FreeBSD-based image?

Not unchanged. FreeBSD is a different kernel, so a binary built against Linux libraries will not load; FreeBSD's Linux compatibility layer runs some programs, but the dependable path is building for FreeBSD. A statically linked Go service is the easy case, one build target producing a native FreeBSD binary, while Linux-only modules or glibc-specific tooling need porting or a different image.

What does Windows IoT Enterprise LTSC give me over a desktop Windows install?

It is the long-term servicing branch: security and quality fixes arrive without feature updates, so a validated image does not drift under a running application. The PC vendor licenses it for the machine and ships the matching drivers with it, which a desktop edition installed from your own media does not give you.

Can one industrial PC run my collection service and a control runtime together?

Yes, hosting user software beside the runtime is the design intent of the vendor images, but treat the CPU as shared. Reserve cores for the real-time runtime when one runs, keep your service lightweight, and load-test both together. A collection pipeline that is comfortable alone can push a deterministic control cycle past its deadline when it shares the machine.

Should I wait for a vendor's next OS release before ordering the trial hardware?

Order on what is qualified today and pin it. A trial has a deadline, and an unreleased distribution cannot be qualified against it. If the newer release lands before the tender, rerun the same qualification on it; until then you deploy the image your binaries were proven on, not the newest one.

Keep reading

  • How-to

    Running TwinCAT XAR on a third-party industrial PC

    Do not clone a factory IPC image onto other hardware. Install a licensed Windows 10 IoT Enterprise LTSC edition, install the runtime fresh, and qualify the real-time Ethernet port, CPU priority and jitter on the actual machine. A successful boot proves nothing, and network hardware the runtime vendor did not sell you is a self-supported component.

    Operating systems on the plant floor

  • How-to

    Install Node-RED Natively on a Linux Edge Computer

    Install Node-RED directly on the Debian-based edge computer rather than in Docker: give the login account sudo, install build-essential, git and curl, then run Node-RED's official Debian install script and start the runtime without the -v flag. The script installs Node.js, npm and Node-RED and registers a systemd service, so the runtime also starts at boot.

    Edge computing and IIoT