PLC Simulator
Legacy PLC language workbenchLanguage workbench

PLC Instruction List Simulator: Run IEC IL Online

Write and execute accumulator-style Instruction List with declarations, located variables, Boolean logic, stores, latches, grouping and selected function blocks—useful for learning and maintaining older PLC code.

Run your first PLC program — no signupStudy the address map

Independent learning tool. No hardware connection, vendor project import or controller download. Technical scope verified August 7, 2026.

Program memory
IEC Instruction List
VAR  Start AT %I0.0 : BOOL;  Stop  AT %I0.1 : BOOL;  Motor AT %Q0.0 : BOOL;END_VAR LD    StartANDN  StopST    Motor
INPUTOUTPUT

Instruction List practice surface

Every capability below is tied to the current parser instead of a generic vendor claim.

  • IEC-style VAR declarations
  • LD / AND / OR / ST accumulator flow
  • Parenthesised grouping and latches
  • Selected timers, counters and arithmetic

Why an Instruction List simulator still has value

Instruction List is a compact, accumulator-oriented PLC language found in older systems, course notes and maintenance work. Reading it well means tracking the result of each load, Boolean operation and store.

New projects are generally better served by current supported languages and the target vendor’s tooling. This workbench exists to make legacy logic observable and to help learners compare common IL ideas with vendor mnemonics.

Address translation sheet

Read the memory map before the rung

These are the address forms this learning runtime recognises. The final column states the simulator behavior, including intentional simplifications.

Device / areaRoleExampleBrowser behavior
%ILocated input%I0.0Binds a declared Boolean to the browser input bus.
%QLocated output%Q0.0Binds a declared Boolean to the browser output bus.
%MInternal bit memory%M0.0Provides located internal Boolean state.
%MWInternal word memory%MW0Provides word storage for supported data operations.
SymbolicNamed variable / FBMotorRun, Delay1VAR declarations provide types and optional initial values.

Executable now

Supported instruction groups

Accumulator logic
LD, LDN, AND, ANDN, OR, ORN and NOT
Grouping and stores
AND(, OR(, ), ST, STN, S and R
Function blocks
CAL for selected timers, counters and edge triggers
Data operations
MOV, ADD, SUB, MUL and DIV as standalone operations

Do not assume

Not in the current subset

  • XOR and XORN
  • Every vendor’s IL extensions or legacy project format
  • Hardware-specific memory, scan timing and task behavior
  • Importing or downloading controller projects

Worked example

A typed IEC IL motor permissive

VAR binds readable symbols to I/O. The instruction sequence loads Start, ANDs the inverse of Stop, then stores the result in Motor.

Run your own program
IEC Instruction ListParser-valid example
VAR
  Start AT %I0.0 : BOOL;
  Stop  AT %I0.1 : BOOL;
  Motor AT %Q0.0 : BOOL;
END_VAR

LD    Start
ANDN  Stop
ST    Motor

Learning sequence

How to read Instruction List without guessing

  1. 01

    Mark declarations

    Record each variable type and located address before following instructions.

  2. 02

    Track the accumulator

    Write down the result after every LD, AND, OR or NOT.

  3. 03

    Locate side effects

    Identify ST/STN outputs, S/R latches and CAL function-block calls.

  4. 04

    Translate for maintenance

    Restate the logic as a Boolean expression or ladder rung, then validate against the target controller.

Engineering boundary

A learning interpreter for legacy logic

The simulator implements a documented IL subset in its own runtime. It is not a compiler for a specific controller and should not be used to claim binary or timing equivalence.

  • Unsupported instructions fail rather than being guessed.
  • Vendor extensions belong on their dedicated dialect pages.
  • Production migration requires the target vendor’s compiler, tests and hardware validation.

Technical evidence

Sources and verification

Page claims and the simulator support matrix were reviewed against the production parser and these primary technical sources on August 7, 2026.

Continue through the cluster

Related programming and simulator guides

Delta PLC programming

See WPLSoft/ISPSoft-style mnemonics and X/Y device mapping.

Mitsubishi PLC programming

Compare GX-style LD/OUT instructions and MELSEC devices.

Omron PLC programming

Compare CX-style mnemonics and channel-bit addresses.

Schneider PLC simulator

Practice IEC and legacy Modicon address forms.

Questions

PLC Instruction List Simulator FAQ

Instruction List is a compact accumulator-style PLC language. Programs load a value, combine it with Boolean operations and store the result, with additional instructions for state and function blocks.

Make legacy Instruction List observable

Run the typed example, trace the accumulator, and compare the result with the vendor dialect you maintain.

Run your first PLC program — no signupCompare all dialects

Runnable simulator field guide

PLC Instruction List simulator: test checklist

Direct answer

The learner can step through a bounded IL program, predict state and translate the behavior into a currently supported language with tests.

Written for learners and maintainers reading legacy IL mnemonics, Boolean result flow, accumulators, jumps and instruction-order behavior.

an automation engineer correlating ladder logic, scan timing, PLC I/O and a controlled test result at a debug bench while studying legacy IEC Instruction List execution and migration practice
System map / 02

NODE 01observable

Scenario setup

Source dialect, instruction set, operand and data types, result-of-logic state, accumulators, labels, jumps, calls, I/O, target and migration goal.

NODE 02observable

I/O and state map

Ordered IL statements through logic or accumulator state, stores, branches and calls to resulting output and modeled machine behavior.

NODE 03observable

Normal run

One Boolean network, timer or counter and numeric expression stepped from known input states.

NODE 04observable

Boundary run

Implicit state, parentheses, jumps, repeated stores, type conversion, unsupported mnemonic, retentive value and restart.

NODE 05observable

Injected fault

A dialect, mnemonic, operand, type, execution-order, control-flow, state, output or runtime mismatch.

NODE 06observable

Target check

Behavioral tests preserved while the code is translated and verified in a supported target language.

Answer surface / 07

Can I run PLC Instruction List online?

You can practice a bounded educational subset where provided, but exact legacy vendor behavior requires the original or supported official engineering environment.

Is Instruction List still used?

Legacy systems still contain it, but IEC deprecated IL. Maintenance should prioritize understanding, tests and risk-controlled migration.

PLC dialect transfer path

Keep the control pattern while the syntax changes

Compare address families and mnemonics around the same machine task, then validate the final project in the target vendor tool.