PLC simulator — practical browser-based training

A PLC simulator is the cheapest way to learn ladder logic that exists. No racks, no panel meters going up in smoke, no rationed shop time, no waiting your turn behind eleven other learners. Open a browser, write a rung, watch the bit toggle. That is the whole sales pitch and it is enough on its own. This page goes deeper — what a PLC simulator actually does, what ours does specifically, where simulators stop and real iron has to start, and how to use one without picking up bad habits that bite you on your first plant attachment.

What a PLC simulator is — and what it isn't

A PLC simulator is software that pretends to be a programmable logic controller. It runs your program on a fake scan cycle. It exposes fake inputs that you can toggle by clicking buttons or by wiring up a fake sensor. It writes to fake outputs that you can watch as lamps, motor icons, or simply as bit-state badges next to the rung. The good ones honour IEC 61131-3 (iec.ch/standards/iec-61131-3) for instruction semantics so the program you write in the simulator behaves the same way it would on real hardware.

A PLC simulator is not the same thing as a PLC emulator, although the words get used interchangeably and the line is genuinely fuzzy. An emulator typically tries to replicate a specific vendor's runtime instruction-for-instruction — Rockwell's RSLogix Emulate or Siemens PLCSIM are emulators in the strict sense. A PLC simulator is broader: it might emulate a runtime, or it might just provide a faithful 61131-3 scan with vendor-flavoured instruction libraries layered on top. Most online PLC simulators sit in the second category, including ours, because nobody is going to download a half-gigabyte runtime to learn what an XIC contact is.

The simulator also is not a digital twin. A digital twin models the physical process — the conveyor belt's mass, the heat exchanger's thermal lag, the tank's fill rate. A simulator focuses on the controller. You can pair a simulator with a process model to get something close to a digital twin, and that is what our wiring track and sensor school start to do, but the focus stays on the program and the I/O behaviour.

Why you'd want one — versus real hardware in a workshop

Real hardware is wonderful and irreplaceable for the wiring half of the trade. It is also expensive, slow, and rationed. A typical demo rack with a Siemens S7-1200, a few digital input cards, a few output cards, an HMI panel, and a couple of sensors costs north of R45 000 once you've paid for the cabinet, the safety contactors, the switchmode supplies, and the wiring loom. Schools own a handful of these and ration them between classes. Most learners get under two hours a day of actual hands-on time across a five-day course. The rest is slides.

A PLC programming simulator inverts that. You run it for as long as you want. You break it as many times as you want. You write a thousand bad rungs in a weekend and the only cost is your patience. For the logic half of the trade — instruction selection, scan-cycle reasoning, addressing discipline, sequence design, fault diagnosis — a simulator is strictly more efficient. You build pattern reflexes faster on a virtual PLC simulator than on shared iron, because the iteration loop is seconds instead of minutes.

The trade-off is real and we'll come back to it: you don't learn to terminate a wire, you don't learn what a 24V short across a digital input card smells like, and you don't learn to torque a DIN-rail terminal. So the answer is never simulator-only forever. The answer is mostly simulator, then a focused wiring intensive when you actually need it.

What our simulator does

This is what your subscription gets you, with the marketing varnish off.

• Sandbox. A blank canvas. Drag instructions, lay rungs, wire signals, run. The sandbox persists to your account, so you can close the tab on a Tuesday at 23:14 and pick up at the same rung on Saturday morning. The scan engine matches IEC 61131-3 semantics — left-to-right, top-to-bottom rung evaluation with proper handling of branch parallelism. There is no "easy mode" that fakes the scan cycle. If you write a race condition, the simulator will reproduce it faithfully and you can learn from it.
• Curriculum. A guided 86-lesson path from "what is a contact" to "PID auto-tune on a heat exchanger model". Each lesson has an automatic grader. Your code runs against twelve test scenarios per lesson and tells you which ones failed and why. You don't get a star for "I think it works on my machine"; you get a pass when the rung actually behaves under all twelve conditions.
• Wiring track. Interactive panel layouts where you wire a sensor to an input card, configure the channel, and see what the input bit does. PNP versus NPN, sourcing versus sinking, 24V loop logic, analog 4-20 mA scaling. This is the bit nobody else in the online plc programming simulator space had built when we started. Most ladder logic simulators assume the I/O is already mapped and skip the part where most field faults actually live.
• Sensor school. A library of 22 industrial sensors — inductive proximity, capacitive, photoelectric retro-reflective, ultrasonic, RTDs, thermocouples, pressure transmitters, vortex flow meters, mag flow meters. Each one has a wiring diagram, a typical fault scenario, and a rung pattern you should recognise on sight.
• Cert packs. Pre-made study tracks for ISA CCST Level 1 and Level 2. Multi-choice question banks, scoring, and a weak-area report so you know where to drill before you book the exam.
• Portfolio PDF. When you finish the curriculum, the system exports a 14-page PDF with your completed exercises, simulator-recorded fault-find times, and your cert pack scores. You email this to a hiring manager. Three Cape Town learners last quarter got interviews on the strength of the PDF alone — small sample, but it works.
• Leaderboard. Optional. Top 100 fastest fault-find times by lesson. Off by default; opt in if you want it. We added it because intermediate learners asked for it, not because gamification is a virtue in itself.

Pricing is in USD because the product is global. Free tier (unlimited sandbox, first six lessons), Basic at $12 a month (full curriculum), Pro at $29 a month (cert packs, portfolio PDF, sensor school full library), Teams at $199 per seat per year with a 5-seat minimum for technical colleges and in-house training programmes. The free PLC simulator tier is genuinely free — no credit card, no time limit on the sandbox, no nag screens. We expect roughly one in twelve free-tier users to upgrade, which is fine.

Browser-based versus install-required simulators

Most legacy PLC simulation software is a desktop install. PLCSIM, RSLogix Emulate, GX Works simulator, CODESYS soft-PLC. They are powerful and they are exactly what a working engineer needs once they're shipping projects. They are also miserable for learners. You need a Windows machine, sometimes a specific Windows build. You need a vendor licence, sometimes a paid one. The installer is half a gigabyte. The first-run setup eats an evening. By the time you've got the thing open, you've burned the focus you came in with.

Browser-based PLC simulators flip this. Open a tab. Sign in. Write a rung. The whole tooling cost collapses to "do you have a browser". This is the right shape for the first six to twelve months of learning. Once you're past the basics and you're targeting a specific vendor stack for actual employment, you graduate to that vendor's emulator. The simulator is the on-ramp; the vendor emulator is the highway.

There is also a hybrid case worth mentioning. We see learners run our online PLC simulator for daily practice and keep a lightweight CODESYS install on a laptop for occasional cross-checks. CODESYS (codesys.com) is open-ish, free for non-commercial use, and runs on most desktops. It is a fair sanity check that your browser-trained reflexes translate.

Brand-specific simulators — when you actually need them

Once you know which vendor stack you're heading for, the brand-specific simulator becomes worth its install cost.

Siemens TIA Portal with PLCSIM. PLCSIM Advanced lets you run a virtual S7-1500 with full Profinet and OPC UA. This is what a working Siemens programmer uses to check logic before commissioning. It does not replace a sandbox-style PLC trainer simulator for learning the basics, but it is essential once you're targeting a Siemens-heavy site.

Rockwell Studio 5000 with Logix Emulate. Emulate gives you a virtual CompactLogix or ControlLogix on your desktop. The tag database, the AOI behaviour, the routine structure — all faithfully reproduced. Pair it with FactoryTalk Logix Echo for newer projects.

Mitsubishi GX Works3 simulator. Less common in the South African market but still present in food, beverage, and packaging. The GX Works3 simulator is solid and bundled with the IDE. If you're heading into a Mitsubishi-aligned plant, learn it; otherwise skip it.

A practical rule: spend the first 200 hours of your learning on a vendor-neutral PLC programming online simulator. After that, pick the vendor stack the job market in your city actually uses, and switch to the vendor's own simulator. The skills transfer cleanly because the underlying semantics are 61131-3.

Building your first ladder rung — start-stop motor walkthrough

This is the rung everyone writes first. Bear with the detail; it matters.

You have three physical inputs. A start pushbutton, normally open, on input I0.0. A stop pushbutton, normally closed, on input I0.1 — wired to fail safe, so a broken wire stops the motor instead of starting it. An overload contact from the motor's thermal relay, normally closed, on input I0.2. You have one output, the motor contactor coil, on output Q0.0.

The rung looks like this in conventional ladder:

|--[ I0.0 ]--+--[ I0.1 ]--[ I0.2 ]--( Q0.0 )--|
|            |
|--[ Q0.0 ]--+

Two parallel branches feed into the stop and overload contacts. The first branch is the start pushbutton. The second branch is the seal-in: an XIC contact mapped to the output Q0.0 itself. Once Q0.0 latches true, the seal-in keeps it true even after the operator releases the start button. The stop and the overload, both wired as XIC against normally-closed field contacts, must remain true (closed) for the output to stay energised.

Three things to understand about why this rung is shaped this way.

First, the scan cycle. The PLC reads inputs, executes program logic from top to bottom and left to right, then writes outputs. Every cycle, every time, on the order of 5-15 ms for a small program. The seal-in contact reads Q0.0 from the output image — the value written on the previous scan — so when the rung evaluates this scan, the seal-in is using last scan's output. This is correct and important. If you tried to design a self-latching rung that read the live output, you'd create a logical race that the simulator would (correctly) reproduce as oscillation.

Second, the fail-safe stop. The stop button is wired normally closed, not normally open. When you press the stop, the contact opens and I0.1 goes false, breaking the rung and dropping Q0.0. If the wire to the stop button breaks — rodent, vibration, terminal coming loose — I0.1 also goes false and the motor stops. This is the entire reason the input is wired this way. A normally-open stop button would leave you with a motor that runs forever if a wire breaks. Do not invert this in software to "make it simpler". The hardware-software contract is the safety story.

Third, the overload. The thermal overload is a separate physical safety device that opens its contact when the motor's current exceeds its trip setting for long enough. In a properly designed panel, the overload also breaks the contactor coil circuit independently of the PLC, so the motor stops even if the PLC crashes. The PLC reads the overload state because the program needs to know — for HMI display, for alarm logging, for the operator's coffee mug. The PLC is not the safety device. The safety device is the safety device.

If you can write this rung from memory, in three flavours (XIC/XIO, function block, and structured text), and explain why each contact is wired the way it is, you're past the first hurdle. Most plc training simulator users get to this point in the first weekend.

Common simulator gotchas

Things that bite learners. None of these are the simulator's fault. All of them are real-world phenomena that the simulator faithfully reproduces.

• Force values look free. In a simulator you can force an input bit to true or false with a click. On real hardware that's a deliberate, dangerous override that bypasses field wiring. Learners who lean on forces in the sandbox develop a habit of forcing through problems instead of diagnosing them. Use forces sparingly. Untrain the click.
• Scan cycle visualisation can mislead. Our simulator slows the scan way down so you can step through it visually. This is a teaching aid, not reality. A real S7-1200 finishes a scan in under 10 ms. Don't write logic that depends on being able to "watch" intermediate states; the real PLC will run too fast for that to matter, and you'll have a bug nobody can reproduce.
• Race conditions in simulated I/O. When you wire two outputs to interact through a fast feedback loop, the simulator will reproduce oscillation that real I/O would dampen through filter time. Add a TON debounce or filter the input properly, the same way you would on hardware. The simulator is not your problem; the missing debounce is.
• Tag persistence between sessions. Retentive memory in the simulator persists across reload. This trips learners who expect a fresh start. Read the lesson notes on retentive areas; they map directly to how Siemens M memory or Rockwell Tag retain attribute behave on real hardware.
• HMI tag drift. Linking simulated HMI tags to PLC tags by name works perfectly until you rename one. Same on real iron. Develop the habit of renaming through the cross-reference, not by hand-editing.

From simulator to real hardware — how the skills transfer

The honest answer is: the logic skills transfer almost completely. The wiring skills transfer not at all. The diagnostic skills transfer partially, depending on whether you used the simulator's fault-injection features.

Logic transfer is near-total because IEC 61131-3 is real. An XIC behaves the same on a virtual PLC simulator as it does on a Siemens S7-1500 or a Rockwell ControlLogix. Timer behaviour, counter behaviour, scan order, branch evaluation — all standardised. The differences are syntactic and structural (Siemens absolute vs Rockwell tag-based, Siemens DBs vs Rockwell UDTs) and you learn those in a week of practice on whichever vendor's actual emulator you graduate to.

Wiring transfer is non-existent and we won't pretend otherwise. You cannot learn to terminate a ferrule on a screen. You cannot learn to ground a shielded analog cable through a video. You cannot learn to handle a thermocouple connector without the actual connector in your hand. Book a wiring intensive — one or two days, hands-on, before your first interview cycle.

Diagnostic transfer is partial. The simulator's fault-injection module — broken sensor, miswired output, crossed thermocouple polarity — teaches you the patterns of real faults. The thing you don't get is the time pressure of a production line that's down at R40 000 a minute. That comes only with site experience. But the diagnostic vocabulary, the where-to-look-first instinct, the "is this the program or the field" branch — that all builds in the simulator and shows up on site.

What we don't claim

A simulator is not site experience. A portfolio PDF is not a journeyman card. Our certificate of completion has no regulatory standing in South Africa — it is not SAQA-listed, MerSETA-aligned, or QCTO-recognised, and we are not a registered training provider. If your learnership requires SETA documentation for B-BBEE skills development credits, this is not the product you need. Go to a registered provider. We are a skill-building tool for people who want to be able to do the work and prove it through a portfolio, not a credentialling body.

The CCST exam preparation we offer is preparation only. The exam is run by ISA (isa.org), they own the credential, and you sit it through them. We are not affiliated with ISA, we just structure our content to match their exam objectives because the CCST is the most internationally portable cert worth chasing as a new technician.

We also don't claim that simulator practice replaces panel-building, commissioning, or live fault-finding under load. It doesn't. It builds the half of the trade that's about reading and writing logic and diagnosing program-vs-field faults — which is, depending on how you count, between 40% and 60% of the actual day-to-day work. The other 40-60% needs real iron eventually.

How to start

Three steps. Open the free tier. No card. Spend a weekend writing the start-stop rung and the next four lessons after it. If the format works for you, move to Basic at $12 a month and commit to the full curriculum. Most learners finish in fourteen to sixteen weeks at four hours a week. When you're three weeks out from interviewing, upgrade to Pro for the cert packs and the portfolio PDF.

Don't pay anyone for "PLC programming training" before you've spent at least one weekend writing your own rungs. If you can't sit through eight hours of writing ladder logic at home for free, you won't sit through it in a paid classroom either. The simulator filters for the kind of attention this work actually requires.

For the underlying standards, the IEC publishes the language definitions and runtime semantics at iec.ch. Read IEC 61131-3 if you want to understand why timers and counters behave the way they do across vendors, and IEC 61131-1 for the scan-cycle model. None of this is essential reading for a beginner. It becomes essential the first time you have to defend a design choice in a code review.

Open the simulator. Write your first rung tonight.