• High-level and easy to use classes similar to the Python opcua/asyncua API:
  • opcua::Server
  • opcua::Client
  • opcua::Node
• Free functions in services namespace as an alternative to the opcua::Node class
• Safe wrapper classes for open62541 UA_* types to prevent memory leaks
• Native open62541 objects can be accessed using the handle() method of the wrapping classes
• Extensible type conversion system to convert arbitrary types to/from native UA_* types
• Asynchronous model similar to (Boost) Asio
• Cross-platform (tested on Windows, Linux and macOS)
• Compatible with all stable open62541 versions ≥ v1.0
• Easy installation and integration with CMake
• Use modern C++ (C++ 17) and best practices
• Less hurdle to get started with OPC UA

The latest stable open62541 release is integrated as a submodule. Depending on the value of the CMake flag UAPP_INTERNAL_OPEN62541, the submodule or an external open62541 installation is used. All open62541 releases since v1.0 are supported and tested in a CI pipeline with debug/release builds and as static/dynamic library.

The project is currently in beta stage but already used in production. Version v1.0.0 is planned for 2025. No major breaking changes are expected.

While in v0.x.x, breaking changes may occur in minor releases. This projects follows the two-version deprecation path: when a feature is marked as deprecated in v0.x.0, it may be removed as early as v0.(x+2).0. Deprecated APIs are declared with the [[deprecated]] attribute and noted in the changelog.

Explore all examples in the examples/ directory.

#include <open62541pp/node.hpp>
#include <open62541pp/server.hpp>

int main() {
    opcua::Server server;

    // Add a variable node to the Objects node
    opcua::Node parentNode{server, opcua::ObjectId::ObjectsFolder};
    opcua::Node myIntegerNode = parentNode.addVariable({1, 1000}, "TheAnswer");
    // Write value attribute
    myIntegerNode.writeValue(opcua::Variant{42});

    server.run();
}

#include <iostream>

#include <open62541pp/client.hpp>
#include <open62541pp/node.hpp>

int main() {
    opcua::Client client;
    client.connect("opc.tcp://localhost:4840");

    opcua::Node node{client, opcua::VariableId::Server_ServerStatus_CurrentTime};
    const auto dt = node.readValue().to<opcua::DateTime>();

    std::cout << "Server date (UTC): " << dt.format("%Y-%m-%d %H:%M:%S") << std::endl;
}

Type conversion from and to native UA_* types are handled by the opcua::TypeConverter struct. Have a look at the typeconversion example.

Compile-time checks are used where possible:

opcua::Variant var;

// ✅ will compile
int number = 5;
var.assign(&number);

// ❌ won't compile, because std::string can't be assigned without copy (conversion needed)
std::string str{"test"};
var.assign(&str);

// ✅ will compile
var.assign(str);

You can add template specializations to add conversions for arbitrary types:

namespace opcua {

template <>
struct TypeConverter<std::byte> {
    using NativeType = UA_Byte;
    [[nodiscard]] static std::byte fromNative(const UA_Byte& src) { /* ... */ }
    [[nodiscard]] static UA_Byte toNative(const std::byte& src) { /* ... */ }
};

}  // namespace opcua

The library can be built, integrated and installed using CMake.

Please check out the open62541 build options here: https://www.open62541.org/doc/1.3/building.html#build-options

Open62541pp provides additional build options:

• UAPP_INTERNAL_OPEN62541: Use internal open62541 library if ON or search for installed open62541 library if OFF
• UAPP_ENABLE_NODESETLOADER: Enable nodeset loader to load NodeSet2.xml files at runtime
• UAPP_BUILD_DOCUMENTATION: Build documentation
• UAPP_BUILD_EXAMPLES: Build examples for examples directory
• UAPP_BUILD_TESTS: Build unit tests
• UAPP_ENABLE_COVERAGE: Enable coverage analysis
• UAPP_ENABLE_CLANG_TIDY: Enable static code analysis with Clang-Tidy
• UAPP_ENABLE_SANITIZER_ADDRESS/LEAK/UNDEFINED/THREAD: Enable sanitizers

Add it to your project as a Git submodule (git submodule add https://github.com/open62541pp/open62541pp.git) and link it with CMake:

add_subdirectory(extern/open62541pp)  # the submodule directory
target_link_libraries(myexecutable PRIVATE open62541pp::open62541pp)

If you build and install this package to your system, a open62541ppConfig.cmake file will be generated and installed to your system. The installed library can be found and linked within CMake:

find_package(open62541pp CONFIG REQUIRED)
target_link_libraries(myexecutable PRIVATE open62541pp::open62541pp)

The library is available through the following package managers:

• vcpkg: Please refer to the vcpkg documentation how to use it within your project. You can easily use vcpkg to build and install open62541pp:

  vcpkg install open62541pp

# clone repository
git clone --recursive https://github.com/open62541pp/open62541pp.git
cd open62541pp

# build
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DUAPP_BUILD_EXAMPLES=ON -DUAPP_BUILD_TESTS=ON ..
cmake --build .                   # single-configuration generator like Make or Ninja
cmake --build . --config Release  # multi-configuration generator like Visual Studio, Xcode

# run tests
ctest --output-on-failure

# install to system
cmake --install .

• open62541 as integrated submodule or external dependency
• catch2 for tests

Contributions and feature requests are very welcome. Please have a look at the contribution guidelines.