Get the SDK

Overview/SDK reference

Overview

SDK reference: bringing DaaS-IoT into every platform

How each SDK keeps one common core at the centre while fitting the conventions of its host platform.

The same DaaS-IoT network can include a microcontroller, an industrial gateway, an Android application, and a Python service. All of them must speak the same protocol, but it is not reasonable to expect their developers to manage memory, threads, callbacks, and configuration in the same way.

SDKs solve this problem. They keep libdaas, the common network core, at the center and integrate it with the conventions and services of the host platform.

the same DaaS-IoT network
the same libdaas core
platform-adapted SDK
mobile · embedded · desktop · cloud application
Read from the bottom up: every platform reaches the same network.

The result is not merely the availability of the same functions in different languages. An SDK makes it possible to use DaaS-IoT as a natural component of the development environment.

One common core, different experiences

libdaas implements what must remain identical across the network: identities, DDOs, drivers, discovery, routing, internal queues, and dATS synchronization. This consistency allows devices built with different technologies to participate in the same segment.

The SDK instead handles local integration. It translates types, protects the lifetime of native resources, connects events to the runtime, and presents errors in a form that is understandable in the target language.

In one environment, events may become listeners; in another, they may become signals, callbacks, or asynchronous streams. The form changes, but the meaning of a received DDO or a completed join remains the same.

This allows teams to use familiar tools without creating incompatible variants of the protocol.

From a single function to a complete operation

The layer closest to libdaas directly exposes the core primitives. It is useful when precise control is required or when immediate access to a new feature is needed.

The high-level layer instead combines multiple primitives into complete operations. It can load the configuration, initialize the node, activate drivers, apply policies, create mappings, and start the core in the correct order.

high-level API“start this node with this configuration”
native bridgetype, event, and resource conversion
libdaasprotocol execution

The benefit is twofold: common cases require less code, while the native layer remains available for advanced cases. Simplicity and control do not become mutually exclusive choices.

A configuration that describes intent

A DaaS-IoT configuration can describe identities, drivers, mappings, policies, queues, discovery, features, and the network-entry mode.

The SDK can receive this information from a language object, a readable file, or standard deployment tools. The same logical configuration can therefore be used during development, distributed across multiple devices, and adapted to the environment without scattering addresses and parameters throughout application code.

This simplifies concrete operations such as:

Configuration is not merely a convenience. It is the point where deployment intent becomes repeatable and verifiable.

The lifecycle follows the platform

A node uses drivers, threads, callbacks, buffers, and native handles. If these resources are closed in the wrong order, the application may lose data or leave part of the runtime active.

The SDK ties the node to the platform's natural lifecycle. Startup applies the configuration and starts the core; shutdown stops autosave and listeners, terminates the core, and releases native resources.

Context managers, destructors, closeable objects, and shutdown hooks are different forms of the same benefit: they preserve correct behavior even when the application terminates because of an error or receives a shutdown request.

The developer can focus on the service being built instead of rewriting defensive native-infrastructure management in every project.

Events that become application services

The core produces events when it receives a DDO, discovers a network, completes a join, synchronizes time, or observes a change in peer state.

The SDK can distribute the same event to multiple components. A received DDO can simultaneously:

a receivedDDO
notify application logic
be recorded in an inbox
update telemetry
activate a user interface
contribute to state persistence
One event, several independent consumers.

These components remain independent. A logging error must not stop the core thread; slow processing can be moved to a queue appropriate for the platform.

The network thus becomes part of an event-driven architecture instead of forcing the application to continuously poll the state of every node.

Queues and inboxes: absorbing different speeds

The physical world and software do not always progress at the same speed. A sensor may produce data at regular intervals while the application is busy; a connection may slow down; the destination may process messages in batches.

Core queues absorb temporary differences during transfer. The SDK makes it possible to configure their sizes, retries, and policies. On the receiving side, it can also provide an in-memory or persistent inbox.

The inbox separates DDO arrival from its processing. The core continues to keep the network active, while the application reads messages at its own pace. Local storage makes it possible to preserve DDOs that have already been received even when the process must restart.

This feature must not be confused with a promise of absolute delivery. Internal transmission queues belong to libdaas and cannot be treated as application storage. When a service requires deduplication or stronger guarantees, message IDs and idempotency must be part of the data design.

The distinction is important: the SDK provides useful tools without hiding the limits of a distributed system.

Multiple forms of persistence for different needs

“Saving the node” can mean different things. SDKs separate these needs instead of concentrating everything in a single opaque file.

FormWhat it stores
Profilethe readable configuration: identities, drivers, mappings, and policies — editable, distributable, and enough to recreate the node
Native configurationthe state produced directly by libdaas, through storage suitable for the platform
Topology snapshotwhat the node knows at a given time: effective identity, peers, and mappings
Persistent inboxreceived DDOs that have not yet been processed

The topology snapshot is useful for analyzing network behavior and accelerating reconstruction after a restart.

This separation makes recovery clearer: configuration describes what the node should do, runtime state describes what it has observed, and the inbox protects pending application work.

Observing the network without entering the core

An SDK is not used only to send data. It can expose the version, available interfaces, local and remote state, synchronized timestamp, queue occupancy, and diagnostic results.

This information helps determine whether a problem originates in configuration, connectivity, synchronization, or routing. It can feed logs, dashboards, and monitoring systems using tools already available on the platform.

Diagnostics become part of the application without requiring every team to understand the internal details of the DME protocol.

The potential lies in model continuity

SDKs make it possible to develop different parts of the same system with the most suitable tools: embedded software close to sensors, mobile applications for interaction, servers for processing, and gateways for connecting different transports.

All of these components continue to share the same node, identity, and DDO model. Platform differences are absorbed at the appropriate layer without fragmenting the network.

This is the main benefit: DaaS-IoT does not impose a single technology environment in order to achieve a coherent network. It provides a common core and SDKs capable of making it a natural component on each platform, simplifying the construction of distributed systems that can grow, change links, and restart without losing their operational model.

Pick your platform in the SDK hub.

Get the SDK