Most C++ projects don’t fail on algorithms — they fail on threads, IPC, and fragile wiring. Unlike traditional frameworks, Areg SDK automates communication, unifying async RPC, Pub/Sub, and service discovery. Its self-managed service mesh enables scalable, fault-tolerant systems across threads, processes, and devices — with no boilerplate, no fragile wiring.

Areg SDK is a lightweight C++17 framework that automates communication in distributed applications.

• Why Areg SDK: Benefits and Compare
• Getting Started: Build and Integration
• Core Modules and Architecture
• Use Cases: Distributed, RPC and IPC
• Roadmap
• Documentation
• License
• Call to Action

Areg SDK is a lightweight framework with built-in middleware that automates threading, service discovery, and inter-node messaging, so teams can build distributed systems without boilerplate or fragile wiring. Unlike gRPC, DDS, or ZeroMQ, it provides a self-managed mesh and a unified API across threads, processes, and devices.
Result: scalable, fault-tolerant systems — faster, simpler, safer.

1. No manual threading
   Threads, components, and watchdogs are auto-created — preventing subtle concurrency bugs and saving time.

2. Unified API
   Services are called the same way locally or remotely — always async, non-blocking, and consistent.

3. Self-managed mesh
   Automatic service discovery and routing across threads, processes, and devices — no manual wiring.

4. Resilient by design
   Components can join or leave dynamically; watchdogs restart failed threads for fault-tolerant systems.

5. Built-in observability
   Integrated logging and scopes help per-method duration measurement to monitor and optimize efficiently.

💡 When to use: Linux & Windows, embedded and desktop C++ apps, scaling from prototype to multi-node.
⚠️ When not to use: RTOS (at the moment), web, or non-C++ apps — use web/RTOS-specific tools instead.

• Do threading and synchronization issues slow your progress?
• Does debugging across threads, processes, or components take excessive time?
• Is setting up communication across processes or nodes complex and error-prone?
• Do remote failures and reconnections create delays and extra work?
• Would a unified communication model across threads, processes, and devices simplify development?

💡 If you answer Yes to 3+ questions, Areg SDK is likely a good fit.

• C++17-compatible compiler: GCC, Clang/LLVM, MSVC, MinGW
• CMake ≥ 3.20
• Java ≥ 17 (required for code generation tools)

Supported OS: Linux, Windows
Supported Hardware: x86, x86_64, ARM, AArch64

See CMake Configuration Guide and README Wiki for compiler options, setup instructions, and troubleshooting.

1. Clone and build the SDK:

git clone https://GitHub.com/aregtech/areg-sdk.git
cd areg-sdk
cmake -B build
cmake --build build -j 12

2. Run the pre-built minimal RPC example:

./product/build/<compiler>/<os>-<hw>-<build-type>-<lib-type>/bin/01_minimalrpc

Message Flow:

🟢 main() → 🏗 load model → 🔗 auto-connect → 📤 Consumer requests → 🖨 Provider prints → ✅ quit

1. 01_minimalrpc – minimal RPC example between 2 components.
2. 02_minimalipc – minimal IPC example across processes, requires mtrouter.
3. 03_helloservice – multithreaded RPC + IPC using the same components, requires mtrouter.
4. More Examples – additional samples demonstrating simple and advanced Areg SDK features.

• CMake FetchContent: Integration Guide
• Demo Project: areg-sdk-demo
• Qt-based Integration: areg-sdk-tools

💡 Advanced builds (IDE setup, cross-compilation, disabling tests/examples) are documented in Wiki.

Areg implements an interface-centric Object RPC (ORPC) model. Applications expose Service Providers and interact via Service Consumers with auto-generated Stubs, Proxies & Rules, communicating through the Multitarget Router. Services (logical micro-servers) need not know physical network locations — enabling portable C++ microservices and scalable service-oriented architecture (SOA).

Supports Client-Server (Request-Reply) and Publish-Subscribe (Pub/Sub) patterns, designed for multithreading, multiprocessing, and distributed systems with low-latency requirements.

Edge devices often stream raw data to central servers, creating latency, network load, and privacy issues. With Areg, services run on devices, forming a mist network of micro-servers that process and aggregate data locally.

Benefit: Low-latency, autonomous edge mesh; sensitive data remains on-device; reduced cloud traffic.

Many small devices lack scalable infrastructure. Areg transforms embedded applications into distributed modules that scale across remote nodes and platforms, orchestrating multithreaded and multiprocess C++ services.

• Local Services – multithreaded within a device
• Public Services – accessible across processes and applications

Benefit: Seamlessly expose services to other apps and devices without modifying code.

Device drivers are often slow, complex, and platform-specific. Areg lets you expose hardware as portable, service-enabled components, making devices platform-independent.

Benefit: Accelerates prototyping, testing, and development; enables early bug detection; devices are network-accessible.

Validating distributed systems is expensive and hardware-dependent. Areg allows simulation of Data Layer services in external applications, providing realistic environments to test behavior, performance, and fault-tolerance. Services appear location-transparent to higher layers.

Benefit: Transparent service location enables testing of higher-layer logic without real hardware dependencies.

Areg SDK continues to evolve for Desktop and Embedded, focusing on automation, reliability, and performance.

Planned work:

• Multi-channel support for multiplexed communications
• RTOS support (Zephyr OS) to bring Areg into real-time environments
• Lusan app improvements: performance, stability, and usability (Areg SDK Tools)

• Installation and Build — cross-platform builds, toolchains, CMake integration for embedded and desktop targets
• Build Options and Integrations — FetchContent, packaging, and embedding Areg as a library
• Development Tools — code generation for service-oriented development
• Logging and Monitoring — logcollector and logobserver usage
• Networking and Communication — Multitarget router for IPC and low-latency messaging
• Persistence — for local data storage in a text file
• Troubleshooting — common issues and recommended solutions
• Examples and Tests — catalog of sample projects (RPC, IPC, Pub/Sub, FSM, and more)
• HOWTO Guide — practical reference.

Areg SDK is released under the Apache License 2.0 — permissive and suitable for open-source and commercial use.

Commercial licensing & services: Dedicated support, training, and tailored licensing options are available for enterprise customers. Visit Aregtech or email info[at]aregtech[dot]com for details.

🚀 Join the Areg SDK community — contribute, discuss, and help shape the future of distributed apps.

• Explore open issues and contribute
• Share ideas or request features via issues or discussions
• Submit pull requests (see project contribution guidelines)
• ⭐ Star Areg SDK to accelerate discovery of distributed C++ solutions

Follow us: