Turbo-boost your C++ development experience

with an extensive ecosystem of frameworks and libraries that have been built on top of the POCO C++ Libraries.
Trusted by leading companies and deployed in millions of devices.

POCO C++ Libraries ecosystem

POCOPRO C++ Frameworks

The POCOPRO C++ Frameworks include the open source POCO C++ Libraries and add the Remoting and Open Service Platform (OSP) frameworks under commercial source code license. Professional support is included.

macchina.io EDGE

macchina.io EDGE adds IoT-specific services and communication protocols implemented with Remoting and OSP frameworks. It also includes a JavaScript engine for simplified IoT edge application development. A C++ bridging framework also based on Remoting makes it easy to access C++ services from JavaScript.
Visit macchina.io/edge for more information.

macchina.io REMOTE

macchina.io REMOTE is a secure remote access solution for IoT devices. It consists of a device agent and SDK based on the POCO C++ Libraries and a server that is also built with POCO, Remoting and OSP.
Visit macchina.io/remote for more information.

Leading companies trust in the POCOPRO C++ Frameworks, macchina.io EDGE and macchina.io REMOTE to build their applications and devices.

Remoting for C++

Web services, Microservices, REST APIs and Remote Methods/RPC for C++.

Web services, REST APIs and microservices have significantly changed the way complex software systems are designed, built and deployed. POCOPRO Remoting makes these technologies and concepts available to C++ developers.

Multi-Protocol Stack and Code Generator

Remoting for C++ is a web services and remote method call framework for C++. Remoting supports different communication protocols. This includes JSON-based REST APIs, JSON-RPC, SOAP and a highly efficient binary protocol.
Remote services are implemented as C++ classes, annotated with special comments. The Remoting code generator takes care of the rest. There is no need to maintain a separate interface definition using an interface definition language (IDL).

SOAP and WSDL/XSD-to-C++ Code Generation

Remoting also includes a tool for generating C++ code from WSDL 1.1 (document/literal wrapped) and XML Schema (XSD) documents. This makes it possible to build C++ clients for SOAP 1.1 and 1.2 web services built with Java, Microsoft .NET, or other middleware technologies.

Remoting Features

Cross-Platform & Interoperability

Easily communicate between different hardware and operating system platforms. Or clients and servers built in other programming languages and environments such as Java or .NET.

Multi Protocol Support

Remoting supports sockets, HTTP, REST, JSON-RPC and SOAP. Thanks to a flexible and modular design, other protocols can be added by implementing a new protocol library.

Code Generator

The RemoteGen code generator generates protocol independent, human-readable communication code from annotated C++ header files.

Extensive C++ Type Support

All standard C++ types and some STL collection types (including enumerations, std::string, std::vector, std::set and std::multiset), as well as user-defined classes and structures are supported as method arguments and return types.


Implement REST API endpoints in C++. Supporting different forms of parameter passing (path, query string, header, body, JSON) as well as authentication, CORS, etc. Or generate client code to call external REST APIs.


Implement microservices in C++ exposing REST APIs for best interoperability. Or use the super efficient binary transport protocol for communication between C++ applications.


Generate C++ client and server code for SOAP web services from WSDL documents. Implement SOAP 1.1/1.2 web services in C++ that can be called from Java and .NET WCF applications with support for MTOM, HTTPS, HTTP compression (gzip content encoding) and HTTP Basic and Digest authentication.

Remote Events

Support for events in remote interfaces enables implementation of server-pushed asynchronous notifications or publish-subscribe messaging patterns.


The following code snipped shows an example for how to define a RESTful API with Remoting. This definition is specific to the Remoting REST transport. Note how the method names correspond to HTTP methods. Also note the special comments. The Remoting code generator (RemoteGen) parses these definitions and generates C++ code that implements serialization, deserialization and remote invocation.

//@ serialize
struct User
    std::optional<std::string> name;
    std::optional<std::string> password;
    std::optional<std::set<std::string>> permissions;
    std::optional<std::set<std::string>> roles;

//@ remote
//@ path="/api/1.0/users"
class UserCollectionEndpoint
    User post(const User& user);
        /// Create a new user.

    //@ $maxResults={in=query, optional}
    //@ $start={in=query, optional}
    std::vector<User> get(int maxResults = 0, int start = 0);
        /// Return a list of user objects, starting with
        /// the given start index, and return at most
        /// maxResults items.

//@ remote
//@ path="/api/1.0/users/{name}"
class UserEndpoint
    //@ $name={in=path}
    User put(const std::string& name, const User& user);
        /// Update a user (calls patch()).

    //@ $name={in=path}
    User patch(const std::string& name, const User& user);
        /// Update a user.

    //@ $name={in=path}
    User get(const std::string& name);
        /// Retrieve a user by name.

    //@ $name={in=path}
    void delete_(const std::string& name);
        /// Delete a user.

Remote Method (RPC) Sample

The following code snipped shows an example for a remote methods-based service that can use the efficient binary Remoting transport over sockets or HTTP, the JSON-RPC or the SOAP transport. Again, note the special comments. The Remoting code generator (RemoteGen) parses these definitions and generates C++ code that implements serialization, deserialization and remote invocation.

//@ serialize
struct User
    std::string name;
    std::optional<std::string> password;
    std::optional<std::set<std::string>> permissions;
    std::optional<std::set<std::string>> roles;

//@ remote
class UserManager
    void addUser(const User& user);
        /// Create a new user.

    void updateUser(const User& user);
        /// Update a user.

    User getUser(const std::string& username);
        /// Retrieve a user by name.

    //@ $maxResults={optional}
    //@ $start={optional}
    std::vector<User> getUsers(int maxResults = 0; int start = 0);
        /// Return a list of user objects, starting with
        /// the given start index, and return at most
        /// maxResults items.

    void deleteUser(const std::string& username);
        /// Delete a user.

Open Service Platform

Dynamic C++ module system, nanoservices and application server.

Today's applications are becoming ever more complex. A large part of this complexity stems from the need to support different configurations, e.g. for different devices, operating system environments or customer needs. Huge monolithic applications like the ones developed in the past do not (or only at an enormous cost) provide the necessary flexibility required today.

Build, deploy and manage dynamic, modular C++ applications

Open Service Platform (OSP) enables the creation, deployment and management of dynamically extensible, modular applications, based on a powerful plug-in and (nano-) services model. Applications built with OSP can be extended, upgraded and managed even when deployed in the field. At the core of OSP lies a powerful software component (plug-in) and services model based on the concept of bundles. A bundle is a deployable entity, consisting of both executable code (shared libraries) and the required configuration, data and resource files.

Plug-in and service-based architecture

Bundles extend the functionality of an application by providing certain services. A central Service Registry allows bundles to discover the services provided by other bundles. Bundles can be installed, upgraded, started, stopped or removed from an application (programmatically, or using a web- or console based administration utility) without the need to terminate and restart the application.

Open Service Platform

Simplify large-scale C++ application development and deployment

This component-based architecture of OSP addresses an increasing problem in software development: The large number of application configurations that need to be developed and maintained. The standardized OSP component architecture simplifies this configuration and deployment process significantly.

Open Service Platform Features

Plug-In and Services Architecture

Create dynamically extensible C++ applications based on a powerful plug-in/component and services architecture. Combine executable code (shared libraries), configuration files and other resources like web pages or images in bundles - easily manageable deployment units.

Dynamic Deployment & Lifecycle Management

Install, start, stop, upgrade or uninstall an application's bundles dynamically, at run-time. Without the need to restart the entire application.

Dependency Management

Automatically manage version dependencies between bundles. OSP makes sure that all dependencies are satisfied and that bundles are started or stopped in correct order.

Service Registry

Provide and find services in an application through a central ServiceRegistry. Dynamically react to availability of services through events or ServiceListener objects.

Management Console & CLI

Manage an application's bundles through a built-in web-based Bundle Administration Utility or through an extensible console based shell (CLI) administration service.

Web Application Server

An integrated web application server enables powerful dynamic C++ web applications. Routing, sessions, authentication, access permissions and CSRF protection can be configured using metadata and are handled by the framework, without the need for extra code.

Signed Bundles

Bundles can be cryptographically signed. Make sure bundles installed in your system come from a known publisher and have not been tampered with.

Standard Services

Readily available services for user authentication and authorization, settings, preferences and configuration data, extension points, database access, email, network environment change detection, web events, etc.


Built-in authentication and authorization framework with accounts database, two-factor authentication (OTP), LDAP integration and flexible roles and permissions-based access control.

Licensing & Pricing

The POCOPRO C++ Frameworks and macchina.io EDGE are available under a commercial source code license.

Please contact us for licensing and purchasing inquiries.

Contact Applied Informatics

Please contact us for a quote, to order licenses, or with any questions regarding the POCOPRO C++ Frameworks, macchina.io EDGE or macchina.io REMOTE.

Download Free Trial

Download a free trial version of the POCOPRO C++ Frameworks to try out the included demo applications or build your own programs.

Getting Started

Please read the Getting Started Guide before downloading and installing the software. This document contains valuable information that will help you get the best out of the POCOPRO C++ Frameworks, including setup instructions and tips to get you started.

The Windows trial version is available for Visual Studio 2017, 2019 and 2022. Only 64-bit builds are supported by the trial version. The full version supports both 32-bit and 64-bit builds.
Need an trial version for a different platform? Please let us know.

A license file is required for running applications (including the samples) built with the POCOPRO C++ Frameworks trial version. Receive the license file via email by filling out the form on the right.

No license file will be required once you purchase a source code license.

Get Your License File

Requests for license files are processed automatically. You should receive the license file via email within a few minutes after submitting the form. If not, please check your junk mail folder.

Download POCOPRO C++ Frameworks Release 2023.2

Platform   Toolchain Hash (SHA-256)
Microsoft Windows
Windows 10/11 (x64) Visual C++ 2019 57b8f8bdcb2f529d684f436c2fe477cd50d7c0bef0c6edaed3dc3b171fee68f2
Windows 10/11 (x64) Visual C++ 2022 2f9a22fdeadca6cebaa73683590b45882fd9367be335d89973c22ee845e55599
Apple macOS
macOS 13.x/14.x (x86_64) Clang/Apple LLVM 15.0.0 (Xcode 15) e598d0c827aac14382292bba71a0d777e81fa0d21bdce4a0cd98c00af2324e13
macOS 12.x/13.x (arm64) Clang/Apple LLVM 15.0.0 (Xcode 15) 544f22e5678443cc2200df405eae525efb488f1eb3e3cd4466cb9c2909579ae3
Ubuntu 20.04 (x86_64) GCC 9.3.0 691083469d2f1bc33d860790097322c354376f04df7c546e7145262c425c21b2
Ubuntu 22.04 (x86_64) GCC 11.2.0 f36bd66937db05c86390be220a2379cdf92d598b737e1d98c059a5a49b42b538
Debian 11 (x86_64) GCC 10.2.1 42d62274de01fe9961728490c9f475cc15c92756a58b7361682de1ca6c0b5851
Debian 12 (x86_64) GCC 12.2.0 719fb710deed720004f34afdee99c5e41478771f259637148db7a51f5be656b2
RedHat 9 (x86_64) GCC 11.4.1 89e81a21d37fa662c90c6cfdce664647bbd2ee496b932539e5971c95af381347

macchina.io EDGE

An evaluation version of macchina.io EDGE, licensed under the GPLv3, is available on GitHub.
Please note that this version only contains a subset of all features available in the full, commercially-licensed version.
To get access to the full-featured version of macchina.io EDGE for evaluation purposes, please contact Applied Informatics.