AWL (Anweisungsliste)

AWL — short for Anweisungsliste (German for “instruction list”) — is an assembly-like programming language used for programmable logic controllers (PLCs) in industrial automation. Born in the Siemens SIMATIC ecosystem in 1979, AWL became the German face of a concept that was later internationalized as Instruction List (IL) within IEC 61131-3, the foundational international standard for PLC programming languages published in 1993. For several decades, AWL served as the primary low-level textual language for programming Siemens industrial controllers, running logic on the factory floors, power plants, water treatment facilities, and manufacturing lines that form the backbone of industrial society. Though the language has been formally deprecated and ultimately removed from the IEC 61131-3 standard between 2013 and 2025, an enormous installed base of AWL code continues to operate in industrial systems worldwide.

History & Origins

The SIMATIC S5 and the Birth of AWL

AWL’s origins lie in the late 1970s, when Siemens introduced the SIMATIC S5 series of programmable logic controllers in 1979. PLCs at this time were purpose-built industrial computers designed to replace electromechanical relay logic — hardwired panels of relays, timers, and contactors that controlled industrial machinery. Early PLCs were programmed using dedicated keypads or handheld programming consoles that displayed code in a notation mirroring the relay ladder diagrams engineers already knew. For engineers with electronics or computing backgrounds, however, a more textual, procedural representation was valuable.

The STEP 5 programming software that accompanied the S5 series introduced Anweisungsliste as one of its representational forms. The name is purely descriptive: Anweisung means “instruction” or “statement” and Liste means “list” — an instruction list. AWL represented PLC programs as a linear sequence of simple instructions, each on its own line, analogous to assembly language for microprocessors. Where assembly language addresses CPU registers and memory locations, AWL addressed PLC accumulators, input/output bits, timer values, and flags specific to the industrial controller environment.

STEP 5 initially ran on the CP/M-based Siemens PG630 programming consoles — dedicated portable workstations purpose-built for programming SIMATIC hardware. By 1982, STEP 5 had been ported to MS-DOS, allowing engineers to develop AWL programs on standard IBM PC-compatible computers before transferring code to the PLC via a serial connection.

DIN 19239 and National Standardization

As Siemens AWL and similar notations from other PLC manufacturers proliferated through the 1980s, the German standards body DIN (Deutsches Institut für Normung) published DIN 19239, a national standard formalizing programmable controller programming language concepts including the Anweisungsliste. This pre-IEC standardization reflected Germany’s early leadership in industrial automation and PLC technology, and established the technical vocabulary that would later inform the international standardization effort.

Different PLC manufacturers had developed their own proprietary programming languages during the 1970s and 1980s — Allen-Bradley used its own ladder notation, Modicon had its approaches, and Siemens had AWL. While these systems shared conceptual similarities (virtually all supported some form of instruction list and ladder diagram), the specific syntax, instruction mnemonics, data types, and memory models were manufacturer-specific. A programmer skilled in Siemens AWL could not immediately work with an Allen-Bradley or Mitsubishi system without relearning the programming environment.

IEC 61131-3 and International Standardization

The response to this fragmentation was IEC 61131-3, the third part of the international IEC 61131 standard on programmable controllers, published in December 1993 by the International Electrotechnical Commission. The standard was developed under IEC Technical Committee 65, which covers industrial-process measurement, control, and automation.

IEC 61131-3 defined five programming languages for PLCs:

1. Ladder Diagram (LD) — graphical relay logic representation
2. Function Block Diagram (FBD) — graphical data flow representation
3. Sequential Function Chart (SFC) — graphical state machine representation
4. Instruction List (IL) — textual, assembly-like (the international equivalent of AWL)
5. Structured Text (ST) — textual, high-level, Pascal-like

Instruction List was the direct descendant of AWL and similar notations from other manufacturers. The IEC standardization effort unified the concept under the common name IL (or IL/AWL, as many practitioners used both terms interchangeably). The standard defined a common set of instruction mnemonics, operand types, and execution semantics intended to be implementable across different manufacturers’ PLC hardware.

In practice, while IEC 61131-3 established a common framework, implementations varied in their fidelity to the standard. Siemens continued to market its language as AWL/STL rather than IL, and Siemens-specific extensions and addressing modes meant that Siemens AWL code was not directly portable to other manufacturers’ IEC 61131-3 compliant systems. True cross-platform portability required careful adherence to the standard subset common to all implementations.

SIMATIC S7 and STEP 7

In 1994, Siemens launched the SIMATIC S7 family — the S7-200 (compact), S7-300 (modular mid-range), and S7-400 (high-end) — which became among the most widely deployed PLC families in the world. The accompanying STEP 7 programming software continued to support AWL (called STL — Statement List — in English-language STEP 7 documentation) alongside Ladder Diagram (LAD) and Function Block Diagram (FBD).

STEP 7 Classic (versions 1 through 5.x, with continued releases through the 2010s) was the primary development environment for S7-300 and S7-400 PLCs for two decades. AWL/STL in STEP 7 had a specific character: it was closely tied to the S7 processor architecture, with direct access to CPU accumulators, status word bits, and a specific memory organization (bit memory, data blocks, peripheral I/O). Expert STEP 7 programmers often preferred AWL for performance-critical or memory-constrained code sections, as it allowed direct optimization that the higher-level languages could not guarantee.

Deprecation and Removal

The shift away from AWL/IL began formally with the IEC 61131-3 Third Edition in 2013. The standard’s committee deprecated Instruction List, citing that assembly-like languages were no longer appropriate for modern automation development practices. The rise of object-oriented programming, modular design patterns, and the growing complexity of automation software made the low-level, linear nature of IL increasingly difficult to maintain and debug at scale.

Siemens reflected this direction operationally: the TIA Portal (Totally Integrated Automation Portal), Siemens’ unified successor to STEP 7 Classic, progressively reduced AWL support in its newer controller families. According to Siemens documentation, by TIA Portal V16 (approximately 2019), creating new AWL/STL code blocks for the S7-1200 and S7-1500 families — Siemens’ current generation controllers — was no longer supported, though existing blocks could still be maintained.

The IEC 61131-3 Fourth Edition, reportedly published around 2025, completed the process by removing Instruction List entirely from the standard, leaving Structured Text as the primary textual language and focusing on the three surviving language types: ST, LD, and FBD.

Design Philosophy

Assembly Language for Industrial Control

AWL’s design philosophy is rooted in the world of assembly language programming applied to the specific memory model and execution cycle of a PLC. Where microprocessor assembly language manipulates CPU registers and memory addresses, AWL manipulates PLC-specific data structures: input bits (I), output bits (Q), memory bits (M), timers (T), counters (C), and data block registers (DB, in the Siemens model).

The instruction cycle of a PLC is fundamentally different from a general-purpose computer. A PLC executes in a continuous scan cycle:

1. Read all input states from physical I/O
2. Execute the user program from beginning to end
3. Write all output states to physical I/O
4. Repeat

AWL is designed for this deterministic, cyclic execution model. Every instruction executes in a predictable, bounded time. There is no dynamic memory allocation, no garbage collection, and (in traditional PLC implementations) no operating system preemption of the user program. This determinism is essential for industrial control, where a missed output update could mean a valve failing to close or a motor failing to stop.

The Accumulator Model

In Siemens AWL (and IEC 61131-3 IL), program logic flows through one or two accumulators — temporary registers that hold intermediate values during computation. Instructions load values into accumulators, perform operations, and store results. This is the same mental model as stack-based or accumulator-based assembly language:

L     MW10        // Load word memory location 10 into accumulator 1
L     MW12        // Move ACCU1 to ACCU2, load MW12 into ACCU1
+I              // Add integer: ACCU2 + ACCU1 → ACCU1
T     MW14        // Transfer (store) ACCU1 to memory word 14

For Boolean (bit) logic — the core of most PLC programs — AWL uses a result bit called the RLO (Result of Logic Operation):

A     I0.0        // AND: RLO = RLO AND input bit 0.0
A     I0.1        // AND: RLO = RLO AND input bit 0.1
=     Q0.0        // Assign: output bit 0.0 = RLO

This model gives the programmer direct control over how logic is constructed and evaluated.

Closeness to Hardware

AWL’s principal design virtue is its closeness to the PLC’s actual execution hardware. An experienced AWL programmer can read code and reason about its cycle time impact, its memory usage, and exactly what the processor will do on each scan. This transparency was valued in an era when PLC processors were constrained resources and cycle time budgets were tight.

The trade-off is that AWL programs are verbose relative to higher-level alternatives. Logic that can be expressed in a few lines of Structured Text may require many lines of AWL to express explicitly, including the intermediate accumulator manipulations that a compiler would handle automatically.

Key Features

Boolean Bit Logic

The most fundamental AWL operations are Boolean logic on individual bits — the digital on/off signals from sensors, switches, and field devices:

// Motor start interlock: run motor if start pressed, stop not pressed, and no fault
A     I0.0        // AND start button (input 0.0)
AN    I0.1        // AND NOT stop button (input 0.1, NC contact)
AN    M0.0        // AND NOT fault memory bit
=     Q0.0        // Assign to motor output

The instruction mnemonics in Siemens AWL use German abbreviations:

• A — Und (AND)
• O — Oder (OR)
• N — negation suffix (NOT)
• = — assignment
• L — Laden (Load)
• T — Transferieren (Transfer/Store)

Timers and Counters

PLCs include built-in timer and counter functions that AWL accesses through dedicated instructions:

// On-delay timer: energize output Q0.1 two seconds after input I0.2 goes true
A     I0.2        // Load timer condition
L     S5T#2S      // Load 2-second timer preset
SD    T1          // Start on-delay timer T1
A     T1          // AND timer output
=     Q0.1        // Assign to output

The S5 time format (S5T#2S for 2 seconds) is a Siemens extension that became familiar to STEP 5 and STEP 7 users, though it differs from pure IEC 61131-3 IL notation.

Arithmetic Operations

AWL supports integer and floating-point arithmetic through accumulator-based operations:

// Calculate a scaled analog value: output = (raw_input * 100) / 27648
L     IW64        // Load analog input word
ITD             // Convert integer to double integer
DTR             // Convert to real (floating point)
L     1.000000e+002   // Load 100.0 as real
*R              // Multiply real values
L     2.764800e+004   // Load 27648.0 (full-scale count for S7 analog modules)
/R              // Divide
T     MD10        // Store result to memory double word 10

Analog signal scaling of this kind — converting raw A/D converter counts to engineering units — is a common AWL pattern in industrial applications.

Jump Instructions

AWL supports conditional and unconditional jumps using labels, enabling structured control flow within the linear instruction sequence:

A     I0.0        // Check condition
JCN   SKIP        // Jump Conditionally Not: skip if RLO = 0
// ... code executed when I0.0 is true ...
SKIP: NOP   0     // Label for jump target; NOP = no operation

Jump instructions allow implementation of conditional execution and loops, though structured alternatives (in Structured Text) are generally preferred for complex control flow in modern development.

Function Calls

AWL supports calling functions (FC) and function blocks (FB), enabling modular program organization:

CALL  FC10        // Call Function 10
CALL  FB20, DB20  // Call Function Block 20 with instance Data Block 20

Function blocks in the S7 model maintain their own data in an associated instance data block, providing a form of encapsulation.

Evolution

From STEP 5 to STEP 7

The transition from the S5/STEP 5 to the S7/STEP 7 platform in the mid-1990s brought significant changes to AWL even as the language’s surface appearance remained similar. The S7 AWL instruction set was not a simple extension of S5 AWL — it reflected the new S7 CPU architecture, with different accumulator handling, a revised memory model, and an expanded instruction set addressing the more powerful S7 processors.

STEP 7 Classic (the desktop application environment, as distinct from the later web-based TIA Portal) provided dedicated AWL editing and debugging features, including the ability to view live data values in online monitoring mode — watching the actual values of operands while the PLC was running, with instructions highlighted based on whether they were logically true or false.

TIA Portal and the Transition

Siemens’ TIA Portal, introduced around 2010, represented a comprehensive re-engineering of the STEP 7 development environment. TIA Portal V10.5 through V15 supported AWL for S7-300 and S7-400 hardware. However, for the newer S7-1200 and S7-1500 controllers — Siemens’ hardware direction from 2009 onward — AWL support was progressively restricted. By TIA Portal V16 (2019), new AWL organization blocks could not be created for S7-1200 or S7-1500 projects. Structured Text and Function Block Diagram became the recommended textual and graphical approaches for new development on current hardware.

This transition reflects the general industry direction: as PLCs have become more powerful and programs have grown more complex, the productivity and maintainability advantages of higher-level languages have outweighed the direct hardware control advantages of AWL.

AWL vs. Structured Text

The replacement of AWL by Structured Text as the preferred textual PLC language represents a shift similar to the broader move from assembly to high-level languages in general-purpose programming. Structured Text is syntactically similar to Pascal or C, supporting structured control flow (IF/THEN/ELSE, FOR, WHILE, CASE), complex expressions, and function calls with parameter lists:

(* Structured Text equivalent of the motor logic shown earlier in AWL *)
IF StartButton AND NOT StopButton AND NOT FaultBit THEN
    MotorOutput := TRUE;
ELSE
    MotorOutput := FALSE;
END_IF;

This is arguably more readable than the equivalent AWL, particularly for engineers without a background in assembly language programming. For routine logic development on modern PLCs, the productivity and maintainability arguments favor Structured Text.

Platform Support and Tooling

AWL is not a general-purpose language that runs on commodity computing hardware. It executes on PLC hardware within a PLC runtime environment, and its “platform” is the PLC operating system and CPU architecture rather than Windows or Linux.

Primary environments where AWL runs or ran:

• Siemens SIMATIC S5 PLCs (1979–end of S5 production): via STEP 5 software
• Siemens SIMATIC S7-300 and S7-400 PLCs: via STEP 7 Classic and TIA Portal (full AWL support)
• Siemens SIMATIC S7-200: limited AWL/STL support via STEP 7 Micro/WIN
• Third-party IEC 61131-3 compliant systems: implementations vary by manufacturer and typically use the IL designation rather than AWL

No official Docker image exists for AWL because the language executes within the proprietary Siemens PLC runtime environment. The awlsim open source project (hosted on GitHub) provides a software simulator that can execute S7 AWL code on standard computers running Python, making it possible to develop and test AWL logic without physical Siemens hardware.

Current Relevance

AWL/STL occupies an interesting position in 2025: formally deprecated and removed from the IEC 61131-3 standard, yet running in enormous quantities of industrial equipment that will remain operational for years or decades. Industrial automation systems are characterized by long operational lifetimes — it is common for PLC installations to run continuously for 20 to 30 years. The S5 and S7 systems programmed in AWL during the 1980s, 1990s, and 2000s represent a vast installed base that requires ongoing maintenance.

For industrial automation engineers maintaining legacy Siemens S5 and S7-300/400 systems, AWL remains a practical necessity. Modifying or troubleshooting existing AWL logic is a day-to-day reality in many plants. The demand for engineers who can read and modify AWL code will persist for years despite the language’s formal deprecation.

New AWL development, however, is increasingly rare. Siemens’ current hardware direction (S7-1200 and S7-1500 controllers) does not support AWL for new blocks, and the IEC 61131-3 community has clearly moved to Structured Text as the preferred textual language for PLC programming. Automation engineering training programs have shifted their curricula to reflect this direction.

Why It Matters

AWL’s significance in programming language history is twofold. First, it represents the assembly language tier of the PLC programming world — the low-level foundation on which industrial automation was built for decades. Just as assembly language knowledge illuminates what happens beneath high-level programming abstractions, AWL knowledge illuminates what PLC execution actually looks like at the hardware level: scan cycles, accumulators, bit operations, deterministic timing.

Second, AWL illustrates the lifecycle of a programming language in a specific industrial domain. Unlike most programming language deprecations, which affect code running on commodity servers or desktops that can be updated or replaced relatively quickly, AWL’s deprecation plays out against a backdrop of 20-year PLC installation lifetimes, remote industrial sites, safety-critical applications, and organizations that cannot afford the risk of migrating working code. The formal standard reportedly eliminated IL around 2025, but the language will continue to run — and to need maintenance — in the field for years to come.

The AWL era in industrial automation corresponds to a period when PLC programming was primarily practiced by electrical engineers and technicians familiar with relay logic and assembly-like notations, rather than software developers. The language’s evolution toward deprecation tracks a broader shift: PLC programming has become increasingly recognized as software engineering, and the tools have evolved accordingly.