CDP's fork of the open62541 OPC UA stack (

thomas d85503f975 added the pubsubtsn architecture, that allows to send all UDP traffic with highest routing priority 7 4 years ago
.azure-pipelines 8bcea80e8b ci(debian): Split debian build into separate build and move to azure pipeline 4 years ago
.github efb52e6800 Add reaction bot setting 5 years ago
arch d85503f975 added the pubsubtsn architecture, that allows to send all UDP traffic with highest routing priority 7 4 years ago
debian b6baa5906e fix(debian):use texlive-plain-generic since debian/bullseye or ubuntu/eoan 4 years ago
deps 95b3deb6a1 fix(core): Avoid buffer overflow in base64 decoding (length check) 4 years ago
doc 53793d9e79 feat(doc): example debian packaging inside docker container 4 years ago
examples 6f79ec6e8f Server: Reload folders with certificates during runtime 5 years ago
include ad52836b5e fix(json): signed integer overflow if value is UA_INT64_MIN 4 years ago
plugins a06a792fa8 fix(server): Correctly initialize application description discovery urls for custom hostname 4 years ago
src e0b7665b15 fix(server): Suppress duplicate results in UA_browseRecursive 4 years ago
tests 7b31e40641 test(server): Add speed test for AddNodes 4 years ago
tools ffb0afb041 fix(ci): Pin msys2 to specific version otherwise install fails. 4 years ago
.clang-format 3a37fb29aa ClangFormat: Correct order of includes 5 years ago
.clang-tidy 648498145b CMake: add static analyzer during build process (by option) 5 years ago
.cquery 729e95677c Add .cquery file for code completion in vim, VS Code, etc. 6 years ago
.dockerignore 5284910907 fix: Start ctt server as default application in docker container 4 years ago
.editorconfig e4e3f1e6eb Add clang-format and editorconfig file 6 years ago
.gitignore c64322933d Ignore Visual Studio Code config files in .vscode 5 years ago
.gitmodules 6474270eb4 Update UA-Nodeset to Head of official v1.04 branch 5 years ago
.travis-apt-pin.preferences 5b2b18b376 Use simpler clang setup for fuzzing. 7 years ago
.travis.yml 8bcea80e8b ci(debian): Split debian build into separate build and move to azure pipeline 4 years ago
AUTHORS 67cbd86018 Set the correct copyright for @jpfr 6 years ago
CHANGELOG 3af3d9d969 Also add client to monitoredEvent callback 6 years ago
CMakeLists.txt d05677afae build(core): Add static library to dev package 4 years ago aa3c4be4ba Doc: Fix various Codacy formatting issues 5 years ago aa3c4be4ba Doc: Fix various Codacy formatting issues 5 years ago
CPPLINT.cfg 58d08d5dc2 Linting: Additional fixes and cleanup 5 years ago
Dockerfile 395b254c97 fix(ci): Dockerfile do not delete build 4 years ago 7c7e0d925c Fix Dicovery typo in 5 years ago f101e78ede Add more help for cmake options 5 years ago
LICENSE e5865742fc Update LICENSE 7 years ago
LICENSE-CC0 f8265df738 clean up include structure 9 years ago ce5209d78d fix(doc): Update the description of the achieved certification 4 years ago
TinyDockerfile 7e08e6dbc2 Fix docker file copy command 7 years ago
appveyor.yml 745d7f503e ci: Migrate from Appveyor to Azure Pipelines 4 years ago
azure-pipelines.yml 8bcea80e8b ci(debian): Split debian build into separate build and move to azure pipeline 4 years ago
cppcheck-suppressions.txt 648498145b CMake: add static analyzer during build process (by option) 5 years ago 8636298d0b debian: use GNUInstallDirs vars to set multiarch-tuple in pkg-config file 5 years ago
open62541.spec dbeb02b54c Remove dependency on python-six 5 years ago cefc1d91d5 Reduce SonarCloud scope (see #1715) 6 years ago


open62541 ( is an open source and free implementation of OPC UA (OPC Unified Architecture) written in the common subset of the C99 and C++98 languages. The library is usable with all major compilers and provides the necessary tools to implement dedicated OPC UA clients and servers, or to integrate OPC UA-based communication into existing applications. open62541 library is platform independent. All platform-specific functionality is implemented via exchangeable plugins. Plugin implementations are provided for the major operating systems.

open62541 is licensed under the Mozilla Public License v2.0 (MPLv2). This allows the open62541 library to be combined and distributed with any proprietary software. Only changes to the open62541 library itself need to be licensed under the MPLv2 when copied and distributed. The plugins, as well as the server and client examples are in the public domain (CC0 license). They can be reused under any license and changes do not have to be published.

The library is available in standard source and binary form. In addition, the single-file source distribution merges the entire library into a single .c and .h file that can be easily added to existing projects. Example server and client implementations can be found in the /examples directory or further down on this page.

Project Information

Build Status:

Build Status Build Status Build Status Build Status

Code Quality:

Fuzzing Status Codacy Badge Total Alerts Coverage Status codecov

General Project Info:

Open Hub Project Status Overall Downloads

Features and Certification

open62541 implements the OPC UA binary protocol stack as well as a client and server SDK. The final server binaries can be well under 100kb, depending on the selected features and the size of the information model.

  • Communication Stack
    • OPC UA binary protocol
    • OPC UA JSON encoding
    • Secure communication with encrypted messages
    • Exchangeable network layer (plugin) for using custom networking APIs (e.g. on embedded targets)
    • Support for generating data types from standard XML definitions
  • Server
    • Support for all OPC UA node types
    • Access control for individual nodes
    • Support for generating server-side information models from standard XML definitions (nodesets)
    • Support for adding and removing nodes and references also at runtime.
    • Support for inheritance and instantiation of object- and variable-types (custom constructor/destructor, instantiation of child nodes)
    • Support for subscriptions/monitoreditems (data change notifications and events)
  • Client
    • All OPC UA services supported
    • Asynchronous service requests
    • Background handling of subscriptions
  • Publish/Subscribe
    • UADP Binary protocol with UDP-multicast or Ethernet communication
    • PubSub JSON encoding

Official Certification

The sample server (server_ctt) built using open62541 v1.0 is in conformance with the 'Micro Embedded Device Server' Profile of OPC Foundation supporting OPC UA client/server communication, subscriptions, method calls and security (encryption) with the security policies 'Basic128Rsa15', 'Basic256' and 'Basic256Sha256' and the facets 'method server' and 'node management'. See for more details.

PubSub (UADP) is implemented in open62541. But the feature cannot be certified at this point in time (Sep-2019) due to the lack of official test cases and testing tools.

During development, the Conformance Testing Tools (CTT) of the OPC Foundation are regularly applied. The CTT configuration and results are tracked at The OPC UA profiles under regular test in the CTT are currently:

  • Micro Embedded Device Server
  • Method Server Facet
  • Node Management Facet
  • Security Policies
    • Basic128Rsa15
    • Basic256
    • Basic256Sha256
  • User Tokens
    • Anonymous Facet
    • User Name Password Server Facet

See the page on open62541 Features for an in-depth look at the support for the conformance units that make up the OPC UA profiles.


On most systems, open62541 requires the C standard library only. For dependencies during the build process, see the following list and the build documentation for details.

  • Core Library: The core library has no dependencies besides the C99 standard headers.
  • Default Plugins: The default plugins use the POSIX interfaces for networking and accessing the system clock. Ports to different (embedded) architectures are achieved by customizing the plugins.
  • Building and Code Generation: The build environment is generated via CMake. Some code is auto-generated from XML definitions that are part of the OPC UA standard. The code generation scripts run with both Python 2 and 3.

Note: Specific optional features are dependent on third-party libraries. These are all listed under the deps/ folder. Depending on the selected feature set, some of these libraries will be included in the resulting library.

More information on the third-party libraries can be found in the corresponding deps/

Code Quality

We emphasize code quality. The following quality metrics are continuously checked and are ensured to hold before an official release is made:

  • Zero errors indicated by the Compliance Testing Tool (CTT) of the OPC Foundation for the supported features
  • Zero compiler warnings from GCC/Clang/MSVC with very strict compilation flags
  • Zero issues indicated by unit tests (more than 80% coverage)
  • Zero issues indicated by clang-analyzer, clang-tidy, cpp-check and the Codacy static code analysis tools
  • Zero unresolved issues from fuzzing the library in Google's oss-fuzz infrastructure
  • Zero issues indicated by Valgrind (Linux), DrMemory (Windows) and Clang AddressSanitizer / MemorySanitizer for the CTT tests, unit tests and fuzzing

Documentation and Support

A general introduction to OPC UA and the open62541 documentation can be found at Past releases of the library can be downloaded at To use the latest improvements, download a nightly build of the single-file distribution (the entire library merged into a single source and header file) from Nightly builds of MSVC binaries of the library are available here.

For individual discussion and support, use the following channels:

We want to foster an open and welcoming community. Please take our code of conduct into regard.

Jointly with the overall open62541 community, the core maintainers steer the long-term development. The current core maintainers are (as of April 2018, in alphabetical order):

  • Chris-Paul Iatrou (Dresden University of Technology, Chair for Process Control Systems Engineering)
  • Florian Palm (RWTH Aachen University, Chair of Process Control Engineering)
  • Julius Pfrommer (Fraunhofer IOSB, Karlsruhe)
  • Stefan Profanter (fortiss, Munich)

Support & Development

Commercial Support

The open62541 community handles support requests for the open source library and its development. Custom development and individual support is provided by commercial partners that are affiliated with open62541:

For custom development that shall eventually become part of the open62541 library, please keep one of the core maintainers in the loop. Again, please note that all changes to files that are already licensed under the MPLv2 automatically become MPLv2 as well. Static linking of the open62541 library with code under a different license is possible. All architecture-specific code is implemented in the form of exchangeable plugins under a very permissible CC0 license.


As an open source project, new contributors are encouraged to help improve open62541. The following are good starting points for new contributors:

Success Stories and Users of open62541

A list of projects and companies using our open62541 stack can be found in our Wiki:

Installation and code usage

For every release, we provide some pre-packed release packages which you can directly use in your compile infrastructure.

Have a look at the release page and the corresponding attached assets.

A more detailed explanation on how to install the open62541 SDK is given in our documentation.

You can not directly download a .zip package from the main branches using the Github UI, since then some of the submodules and version strings are missing. Therefore you have three options to install and use this stack:

  • Recommended: Use any of the prepared packages attached to every release or in the package repository of your distro (if available).
    Please check the install guide for more info.

  • Download a .zip package of special pack/ branches.
    These pack branches are up-to-date with the corresponding base branches, but already have the submodules in-place and the version string set correctly.
    Here are some direct download links for the current pack branches:

  • Clone this repository and initialize all the submodules using git submodule update --init --recursive. Then either use make install or setup your CMake project correspondingly.


A complete list of examples can be found in the examples directory.

To build the examples, we recommend to install the open62541 project as mentioned in previous section.

Example Server Implementation

The following simple server example can be built using gcc, after you installed open62541 on your system.

Using the GCC compiler, just run gcc -std=c99 -lopen62541 -DUA_ARCHITECTURE_POSIX <server.c> -o server (under Windows you may need to add -lws2_32 and change -DUA_ARCHITECTURE_POSIX to -DUA_ARCHITECTURE_WIN32).

#include <signal.h>
#include <open62541/server.h>
#include <open62541/server_config_default.h>

UA_Boolean running = true;
void signalHandler(int sig) {
    running = false;

int main(int argc, char** argv)
    signal(SIGINT, signalHandler); /* catch ctrl-c */

    /* Create a server listening on port 4840 */
    UA_Server *server = UA_Server_new();

    /* Add a variable node */
    /* 1) Define the node attributes */
    UA_VariableAttributes attr = UA_VariableAttributes_default;
    attr.displayName = UA_LOCALIZEDTEXT("en-US", "the answer");
    UA_Int32 myInteger = 42;
    UA_Variant_setScalar(&attr.value, &myInteger, &UA_TYPES[UA_TYPES_INT32]);

    /* 2) Define where the node shall be added with which browsename */
    UA_NodeId newNodeId = UA_NODEID_STRING(1, "the.answer");
    UA_NodeId parentReferenceNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES);
    UA_NodeId variableType = UA_NODEID_NULL; /* take the default variable type */
    UA_QualifiedName browseName = UA_QUALIFIEDNAME(1, "the answer");

    /* 3) Add the node */
    UA_Server_addVariableNode(server, newNodeId, parentNodeId, parentReferenceNodeId,
                              browseName, variableType, attr, NULL, NULL);

    /* Run the server loop */
    UA_StatusCode status = UA_Server_run(server, &running);

    return status;

Example Client Implementation

#include <stdio.h>
#include <open62541/client.h>
#include <open62541/client_config_default.h>

int main(int argc, char *argv[])
    /* Create a client and connect */
    UA_Client *client = UA_Client_new();
    UA_StatusCode status = UA_Client_connect(client, "opc.tcp://localhost:4840");
    if(status != UA_STATUSCODE_GOOD) {
        return status;

    /* Read the value attribute of the node. UA_Client_readValueAttribute is a
     * wrapper for the raw read service available as UA_Client_Service_read. */
    UA_Variant value; /* Variants can hold scalar values and arrays of any type */
    status = UA_Client_readValueAttribute(client, UA_NODEID_STRING(1, "the.answer"), &value);
    if(status == UA_STATUSCODE_GOOD &&
       UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_INT32])) {
        printf("the value is: %i\n", *(UA_Int32*);

    /* Clean up */
    UA_Client_delete(client); /* Disconnects the client internally */
    return status;