CODESYS
CODESYS is a manufacturer-independent software platform for developing and running automation applications in industrial control systems, centered on the international IEC 61131-3 standard for programmable logic controllers (PLCs).[1] It consists of the CODESYS Development System, an integrated development environment (IDE) that supports all five IEC 61131-3 programming languages—Function Block Diagram (FBD), Ladder Diagram (LD), Instruction List (IL), Structured Text (ST), and Sequential Function Chart (SFC)—along with object-oriented extensions for creating reusable code.[2] The platform also includes the CODESYS Control runtime system, a SoftPLC that executes applications on diverse hardware or virtual environments, enabling hardware-independent solutions for tasks like motion control, visualization, and fieldbus integration.[1] Developed by the CODESYS Group, founded in 1994 by Dieter Hess and Manfred Werner in Germany, the software has evolved into a leading tool for industrial automation, supporting standards such as OPC UA, PROFINET, EtherCAT, and CANopen.[3] Key features include integrated debugging, project wizards, security mechanisms, and compatibility with over 500 device manufacturers worldwide, making it suitable for applications in factory automation, energy systems, and machine building.[2] Recent advancements, such as the CODESYS V3.5 SP21 release and the certified SIL3 Virtual Safe Control SL for safety-critical operations, enhance its flexibility and cost-efficiency by allowing virtual controllers on standard hardware.[1] With tens of thousands of users and a global ecosystem, CODESYS promotes open, scalable automation solutions across industries.[3]Introduction
Definition and Purpose
CODESYS is a comprehensive software platform designed for industrial automation technology, serving as both an integrated development environment (IDE) and a runtime system to facilitate the creation, testing, and deployment of automation applications on programmable logic controllers (PLCs), programmable automation controllers (PACs), embedded control units (ECUs), and building controllers.[4][5] The core purpose of CODESYS is to enable hardware-independent programming of controllers in diverse industrial settings, allowing applications to run on both virtual soft PLCs and physical hardware targets while adhering to the IEC 61131-3 standard for structured text, ladder logic, and other programming paradigms.[6][7] This hardware independence promotes vendor-neutrality, permitting users to select optimal hardware from multiple manufacturers without being locked into proprietary ecosystems, which enhances flexibility in system design and integration.[8] Key benefits include significant cost reductions through streamlined development processes, such as pre-certified components and tool-guided integration that minimize risks and accelerate time-to-market for automation devices.[4] Additionally, CODESYS offers scalability across a wide range of applications, from compact edge devices to large-scale systems, supported by its modular runtime that adapts in size and functionality to varying processor architectures like Arm Cortex and operating systems such as Linux.[4][5] The platform is developed and maintained by the CODESYS Group, with CODESYS GmbH as the central entity headquartered in Kempten, Germany, overseeing product innovation and supported by subsidiaries in China, Italy, and the United States to ensure global reach and service.[9][7] This structure underscores the platform's commitment to reliable, ISO 9001:2015-certified development practices since 2005, fostering high market acceptance among automation professionals.[4]Standards Compliance
CODESYS serves as a comprehensive implementation of the IEC 61131-3 standard, which establishes a unified framework for programmable logic controller (PLC) programming in industrial automation. This international standard, developed by the International Electrotechnical Commission (IEC), specifies five graphical and textual programming languages: Ladder Diagram (LD) for relay-style logic, Function Block Diagram (FBD) for modular function-based designs, Instruction List (IL) for low-level assembly-like instructions, Structured Text (ST) for high-level algorithmic programming, and Sequential Function Chart (SFC) for state-machine and process-oriented control. CODESYS fully supports these languages in its development environment, enabling users to create, compile, and deploy applications that adhere to the standard's syntax, semantics, and execution models, including features like data types, function blocks, and task management. This compliance ensures that CODESYS applications are executable on any conforming PLC runtime system, fostering interoperability in diverse hardware ecosystems.[10][6] Beyond core programming standards, CODESYS holds several certifications that validate its reliability and safety for industrial applications. In January 2025, the CODESYS Virtual Safe Control SL achieved TÜV SÜD certification for Safety Integrity Level 3 (SIL3) under IEC 61508, allowing safety-critical functions to run on non-certified hardware via virtualization. Additionally, the CODESYS OPC UA Server SL is certified by the OPC Foundation for compliance with the OPC Unified Architecture (OPC UA) standard, enabling secure, platform-independent data exchange in industrial IoT environments. For fieldbus integration, CODESYS supports EtherCAT as an open real-time Ethernet protocol, with its Safety for EtherCAT Safety Module certified to SIL3, ensuring deterministic communication in distributed control systems. These certifications underscore CODESYS's adherence to safety and communication norms essential for automation.[11][12][13] Compliance with IEC 61131-3 and related standards promotes code portability across vendors and hardware platforms, reducing development costs and enhancing maintainability in multi-supplier projects. By standardizing programming practices, it minimizes vendor-specific lock-in and supports global collaboration in automation engineering, as evidenced by its adoption across over 1,000 different device types from more than 500 manufacturers worldwide.[6][7] As of the 2025 roadmap, CODESYS integrates containerization technologies through products like Virtual Control SL, enabling deployment on edge computing platforms for scalable, hardware-agnostic automation in cloud-edge hybrids.[14][15]History and Development
Founding and Early Years
CODESYS originated from the establishment of 3S-Smart Software Solutions GmbH in July 1994 by Dieter Hess and Manfred Werner in Kempten, Germany. The company was created to address the growing need for software-based automation solutions in industrial control systems, focusing initially on developing a SoftPLC platform that enabled programmable logic control without dedicated hardware dependencies. This early emphasis on software marked a shift toward more flexible, PC-based alternatives to traditional hardware PLCs.[16] The first version of the software, 1.0, was released in 1994 as a comprehensive SoftPLC system compliant with the emerging IEC 61131-3 standard for programmable controllers. Amid the rapid expansion of PLC usage in the 1990s, 3S faced challenges in transitioning from vendor-specific proprietary programming environments to open, standardized approaches, which often involved adapting ladder logic and other legacy methods to multi-language support. This period required innovative engineering to ensure reliability and interoperability in industrial applications, positioning the company as a pioneer in automation software.[17][18] Over the years, the company underwent significant branding evolution to reflect its core product. In 2018, 3S-Smart Software Solutions began aligning more closely with the CODESYS trademark for its development system, emphasizing the software's central role. This culminated in a full rebranding to CODESYS GmbH on June 19, 2020, as part of the newly structured CODESYS Group, which consolidated global operations and subsidiaries.[19][7]Evolution of Versions and Milestones
CODESYS began as a foundational programmable logic controller (PLC) programming tool with the release of version 1.0 in July 1994, providing essential support for IEC 61131-3 text-based languages like Structured Text (ST) and Instruction List (IL) on early hardware platforms.[16] This initial version established the core runtime environment for industrial automation but lacked advanced graphical interfaces, focusing instead on basic code compilation and device integration for OEMs.[16] By the early 2000s, version 2.3 marked a significant expansion, introducing graphical programming languages such as Ladder Diagram (LD), Function Block Diagram (FBD), and Sequential Function Chart (SFC), which broadened accessibility for engineers transitioning from relay-based systems.[20] This release enhanced visualization capabilities and supported multi-language projects within a single environment, enabling more intuitive development for complex control logic while maintaining compatibility with prior versions.[20] The V2 series laid the groundwork for broader adoption, with ongoing patches addressing fieldbus integration and runtime performance up to the mid-2000s. The shift to version 3.5 around 2010 introduced a modular architecture, decoupling components like the development environment, runtime system, and libraries to allow scalable installations and easier extensions via plug-ins. This design facilitated integration with emerging standards like OPC UA and supported diverse hardware from embedded controllers to high-performance servers. Subsequent service packs built on this foundation: SP17 in 2022 completed a major architectural restructuring, transitioning to add-on-based delivery for faster updates and customized setups, including signed packages for enhanced security.[21] By SP20 in 2024, optimizations focused on compilation efficiency and multi-platform support, while SP21 in 2025 added native Git integration for version control in the Professional Developer Edition—featuring hierarchical repository management and conflict resolution tools—and advanced static analysis capabilities, such as cognitive complexity metrics and one-click fixes for code issues without requiring compilation.[22][23] Key milestones underscore CODESYS's evolution toward cloud-native and virtualized automation. The platform celebrated its 30th anniversary in 2024, reflecting on three decades of innovation from standalone PLC tools to comprehensive ecosystems.[16] In 2018, the CODESYS Automation Server launched as a cloud-based platform for remote management, monitoring, and deployment of automation projects, enabling centralized control over distributed devices.[24] The introduction of CODESYS Virtual Safe Control SL in 2024 provided a hardware-agnostic, SIL3-certified safety runtime, with full TÜV SÜD certification achieved in early 2025, allowing virtualized safety functions on standard IT infrastructure without dedicated hardware.[25][26] Looking ahead, 2025 roadmaps emphasize interoperability and modernization: the OPC UA PubSub SL library reached version 1.3 in October, enhancing real-time data exchange via publisher-subscriber mechanisms with improved license metrics and example project streamlining.[27] Container support advanced through the Virtual Control SL, enabling deployment of IEC 61131-3 runtimes in Docker-compatible environments for scalable, multi-instance operations.[14] However, legacy support wanes, with the Windows CE runtime entering discontinuation on April 1, 2025, following Microsoft's end-of-life, prompting migrations to Linux or modern Windows variants.[28] Recognition for these advancements includes the CODESYS Static Analysis tool earning Product of the Year 2025 in the software and IT category, praised for its role in early detection of code vulnerabilities and enforcement of best practices in industrial applications.[29]Core Components
Development Environment
The CODESYS Development System serves as the central integrated development environment (IDE) for creating, editing, and managing automation projects in industrial control systems. It provides a comprehensive suite of tools for engineers to design applications using standardized programming paradigms, facilitating project creation from initial setup to final code generation for target controllers. Available in both 32-bit and 64-bit versions, the IDE runs on Windows 10 and 11 operating systems, ensuring compatibility with modern development workflows.[2][6] Key tools within the CODESYS Development System include a visual project explorer that organizes project elements such as programs, function blocks, and libraries in a hierarchical tree structure for intuitive navigation. The IDE features an integrated compiler that supports IEC 61131-3 languages, generating optimized, platform-independent code for various CPU architectures while incorporating object-oriented extensions from the standard's third edition. Debugging capabilities encompass online and offline modes, with features like breakpoints, variable watch windows, and sequence control to troubleshoot and refine application logic during development. Additionally, simulation tools, such as the integrated CODESYS Control Win SL SoftPLC demo, allow for testing without physical hardware. For advanced users, the Professional Developer Edition extends functionality with version control integration via CODESYS Git, enabling multi-user collaboration, branching, and repository management compatible with platforms like GitHub and GitLab; it also includes static code analysis with over 100 rules for detecting issues, UML modeling support, automated testing via CODESYS Test Manager, and profiling for runtime analysis.[6][30][31] The typical workflow in the CODESYS Development System begins with hardware selection, where users import device descriptions (DDs) from a vast ecosystem to configure target controllers without vendor-specific adaptations. Engineers then create projects using wizards and smart coding assistants, reuse libraries for modular development, and build applications through compilation and linking processes, culminating in project archiving for version tracking. License management is handled seamlessly via the CODESYS Store, offering free downloads of the base IDE with optional security mechanisms like certificates, dongles, and passwords to protect intellectual property during engineering.[6][2] A hallmark of the CODESYS Development System is its hardware independence, achieved through standardized device descriptions that enable support for programmable devices from over 500 manufacturers, encompassing several million individual devices and around 1,000 device types. This vendor-agnostic approach allows developers to select and integrate hardware from diverse suppliers using a unified interface, promoting flexibility in automation project design.[32]Runtime System
The CODESYS Runtime, also referred to as CODESYS Control or Control RTE, functions as the soft PLC kernel responsible for interpreting and executing compiled IEC 61131-3 code on target devices. It transforms standard hardware into programmable controllers by providing a modular execution environment compatible with embedded systems, Windows operating systems, Linux distributions, and virtual machines. Supported architectures include Intel 80x86, ARM, PowerPC, and others such as TriCore and RX, ensuring broad applicability across industrial hardware.[33][34][35] Core features of the runtime emphasize reliable operation in automation scenarios, including real-time execution for deterministic task processing, compatible with real-time OS extensions like OSADL. It enables pre-emptive multitasking to manage concurrent operations with priority-based scheduling, alongside integrated I/O handling for fieldbus protocols such as PROFIBUS and EtherCAT. Diagnostic capabilities are built-in through an event logger and test frameworks for monitoring system health and troubleshooting. The runtime also incorporates SoftMotion extensions, which facilitate kinematics processing for single- and multi-axis motion control, electronic gearing, CNC programming, and robotics tasks directly on the device.[33][36][37] Deployment involves downloading binary application code to the target via the CODESYS Deploy Tool for straightforward installation on controllers. Hot-swapping support, provided through the redundancy toolkit, allows for module replacement without halting runtime operations. Remote monitoring is achieved using protocols like OPC UA and PLCHandler, enabling oversight and adjustments from external development stations. The CODESYS Control RTE SL version extends these capabilities for safety-critical applications, achieving SIL3 certification under IEC 61508 in early 2025.[33][38][39][40][11] Performance is optimized through native machine code execution, supporting cycle times as low as 200 microseconds in configurations like EtherCAT synchronization. Scalability for multi-core processors allows task assignment to specific CPU cores, enhancing throughput and reducing load under heavy conditions; this was further improved in V3.5 SP21 with substantially reduced cycle times even during peak usage.[41][42][23][40]Programming and Tools
Supported Languages
CODESYS supports the five programming languages defined in the IEC 61131-3 standard, enabling developers to create control applications using a mix of graphical and textual paradigms suited to industrial automation tasks.[6] These languages—Ladder Diagram (LD), Function Block Diagram (FBD), Instruction List (IL), Structured Text (ST), and Sequential Function Chart (SFC)—are integrated into the development environment, allowing seamless switching between them within a single project. Ladder Diagram (LD) is a graphical language that mimics traditional relay logic diagrams, using rungs with contacts, coils, and other elements to represent Boolean logic and control sequences. It is particularly intuitive for electricians and those familiar with hardwired relay panels, facilitating the design of simple interlocking and sequencing logic. A basic LD example involves a rung where an input contact (e.g., a normally open switch) energizes an output coil when closed, depicted as--| |--( )--.[6]
Function Block Diagram (FBD) is another graphical language focused on data flow, where function blocks (predefined or custom) are connected via inputs and outputs to model signal processing and algorithmic operations. It supports modular design by reusing blocks like timers, counters, and mathematical functions, making it ideal for complex control algorithms. In an FBD example, an AND block takes two Boolean inputs and outputs true only if both are true, connected to a subsequent action block.[6]
Instruction List (IL) is a low-level, textual language resembling assembly code, consisting of mnemonic instructions for operations on registers and memory. It allows compact, efficient code for performance-critical sections but is marked as obsolete by PLCopen, was removed from the IEC 61131-3 standard in its 4th edition (published May 2025), and is no longer actively maintained in CODESYS, though it remains available for legacy compatibility. A simple IL snippet for adding two variables might read: LD %IX0.0; AND %IX0.1; ST %QX0.0;, loading inputs, performing a logical AND, and storing the result.[6][43]
Structured Text (ST) is a high-level, textual language similar to Pascal or C, supporting structured programming constructs like loops, conditionals, and expressions for algorithmic tasks. It enables readable, compact code for calculations and data manipulation, often used alongside graphical languages for hybrid approaches. An example ST statement is IF Input1 AND Input2 THEN Output := TRUE; END_IF;, which sets an output based on two inputs.[6]
Sequential Function Chart (SFC) is a graphical language for modeling state machines and sequential processes, using steps (actions) connected by transitions (conditions) to represent ordered execution flows, such as machine cycles or batch processes. It promotes structured sequential logic with parallel branches and jumps for handling complex workflows. In an SFC example, a transition from Step1 to Step2 might trigger on a Boolean condition like %IX0.0, advancing the process when the input is true.[6]
CODESYS extends these core languages with object-oriented programming (OOP) features compliant with the third edition of IEC 61131-3, introduced in version 3.5, allowing encapsulation, inheritance, and polymorphism directly within function blocks without external tools. The 4th edition of IEC 61131-3 (published May 2025) introduces enhancements to OOP, such as properties with getter and setter methods and new synchronization tools like mutexes and semaphores for concurrent execution. CODESYS is aligning with these updates in recent versions, including keyword reservations as of mid-2025.[6][44][45] Function blocks serve as classes, supporting methods (procedures within blocks), interfaces (abstract contracts for polymorphism), properties (data accessors), and inheritance for extending base blocks, enabling reusable, modular code for large-scale applications.[46] For instance, a derived function block can inherit from a base class and override methods, such as a specialized motor control block extending a generic actuator class.
Libraries in CODESYS further enhance reusability by encapsulating OOP code or standard functions into distributable packages with defined interfaces, allowing developers to import and instantiate them across projects for consistent functionality like communication protocols or algorithms.[6]
All languages in CODESYS are compiled by the integrated compiler into platform-independent bytecode, which the CODESYS Runtime system loads, interprets, and executes efficiently on target devices without requiring an external compiler, ensuring portability and optimal performance.[47] This process includes syntactic checks, optimization, and generation of executable application code tailored to the runtime's virtual machine.[33]
Integrated Development Features
The CODESYS Integrated Development Environment (IDE) incorporates a suite of tools designed to streamline programming workflows and boost productivity for automation engineers. These features extend beyond basic language support by providing mechanisms for code organization, testing, and team-based development, enabling efficient handling of complex industrial projects. Key among them is the library manager, which facilitates the creation and management of custom function blocks as reusable program organization units (POUs). A function block is defined as a POU that retains state after execution and requires an instance for invocation, allowing developers to encapsulate logic such as timers or controllers into modular components.[48] Custom libraries can be built by adding function blocks via the Project menu, declaring inputs/outputs in structured text (e.g.,FUNCTION_BLOCK <name>), and implementing reusable code that is accessible only through instance variables.[48] This promotes code reuse across projects, reducing redundancy in applications like machine control sequences.
Recipe handling serves as a specialized tool for data management, allowing engineers to define and manipulate sets of variable values for consistent configuration in production processes. A recipe consists of a user-defined list of variables (recipe definition) whose values can be saved, loaded, or activated simultaneously on the controller, supporting tasks such as batch adjustments in manufacturing.[49] The Recipe Manager object, added to the device tree, enables file-based storage and programmatic control via the RecipeManCommands function block, with options for hexadecimal encoding of floating-point values to optimize memory (e.g., approximately 267352 bytes for 100 INT variables).[49] This feature integrates seamlessly with visualizations for runtime monitoring, ensuring data integrity without manual variable tweaks.
Trend visualization aids in development by rendering time-based curves of variable values directly within the IDE, facilitating analysis of system behavior during testing. The Trend element connects to a Trend Recording object to display long-term data from local or remote applications, with configurable properties like cursor tooltips, zoom/pan controls via BOOL variables, and time stamps in absolute (e.g., 18.03.2016 12h30m50s) or relative formats.[50] Developers can program dynamic interactions, such as deleting recordings at runtime, to simulate and debug trends like sensor data over extended periods, enhancing early issue detection.[50]
Static code analysis stands out as an award-winning tool for proactively identifying issues in source code, even when syntactically correct. It detects inefficiencies like duplicate code or unused variables, improving software quality in industrial automation.[29] In 2025, CODESYS Static Analysis earned first place in the "Software and IT" category of the Product of the Year award from the German trade magazine Computer & Automation, recognizing its role in efficient error detection.[29]
Version control is integrated via built-in Git support, which embeds the distributed system directly into the IDE for tracking changes across all application objects without requiring external installations. This includes logging modifications, restoring versions, and archiving project states in a readable JSON format, with recommendations for Git hosting services like GitHub to enable multi-developer synchronization.[51] Enhancements in Q1 2025 improved usability, such as better integration in the installer and support for safety applications, fostering collaboration by allowing teams to coordinate access and resolve conflicts seamlessly.[52] These features require the Professional Developer Edition and CODESYS V3.5.19.30 or later.[51]
Simulation capabilities support offline testing through the IDE's built-in mode, activated by selecting the PLC and enabling Simulation, which executes applications without physical hardware for rapid prototyping. The SoftPLC simulator, part of CODESYS Control SL, runs as a virtual runtime on platforms like Raspberry Pi for non-commercial validation, while the Simulation Interface enables software-in-the-loop integration via OPC UA for toggling between real and simulated data.[53][54] Hardware-in-the-loop testing is facilitated by connecting the IDE to external simulators, allowing control hardware to interact with virtual models for safe, cost-effective verification of complex systems.[55]
Modularization enhances project partitioning and reuse, introduced as a major architectural update in CODESYS 3.5 SP17 in 2021. This separates core IDE components (e.g., compiler, UI) from add-ons (e.g., language editors), allowing independent updates and custom installations to optimize performance.[56] For projects, it supports partitioning via the device tree, where POUs and libraries can be reused across applications, with flagged incompatibilities (e.g., red crosses for unknown objects) ensuring backward compatibility.[56] The CODESYS Installer manages multiple setups, enabling export for team consistency and beta testing without disrupting stable environments, thus streamlining large-scale reuse in modular automation designs.[56]