A node hosts the DaaS stack and uses locally available communication resources to reach other nodes. Everything else builds on these.
Connected when a channel reaches another node; active when its timer is aligned with the already-active nodes.
DaaS IdeNtifier — identifies a single node instance within the network.
System IDentifier — identifies the distributed system (segment) a node belongs to.
DaaS Data Object — the unit of information exchanged. A recognizable object in the network, not a raw packet.
Semantic classification of a DDO — state, telemetry, command, result, notification, event — so nodes read meaning uniformly.
DaaS-MEssage — encapsulates DDOs for transfer. Three variants: transfer, control, service.
Total decoupling between application logic and transport. The sender locates a node and pushes a DDO; the receiver reacts to a callback and pulls it. The stack handles channel choice, bridging and synchronization.
locate(din) — find the destination nodepush(din, typeset, ts, payload) — send a DDOonDDOReceived() → pull() — receive itNodes exchange data to compute drift and offset compensation, aligning local time to the network time set by the oldest active node — the time-master — within a user-defined network period. A node exists only if it is temporally synchronized.
A remote node desynced by up to a full day converges to network time in hundreds of ms, with error narrowing to ±1 ms — unaffected by transfer times and network latency.
Variable-size, variable-meaning encapsulation keeps the DME + DDO header compact — efficient even over frame-limited underlay protocols.
Overlay overhead is measurable but negligible against the gains in self-configuration, security and scalability — validated with the University Metrology Department using dsperf.
Ethernet or Wi-Fi drops while DaaS-IoT keeps delivering DDOs over the best available driver: ETH → WiFi → BLE.
After the first DDO-ATS exchange, nodes converge to a shared time — no central clock, no round-trip.
A new node boots, discovers neighbors, joins the topology and synchronizes — with virtually zero configuration.
Prefers A → C → B over A → B when the longer path is faster and more reliable — best path, not shortest.
You don't build the core yourself. From the downloads you pick the
SDK for your platform and link it into your project. Each download is a signed, self-contained tarball that already
bundles the libdaas core, the generic transport drivers, ready-to-run examples and the docs — the
four pieces below are what you find inside, from the runtime you depend on to the package you actually install.
The overlay engine — identity, discovery, routing, shared time, channel choice. It's already compiled for your platform and shipped inside the package; you never build it.
Every package carries the generic drivers (IPv4 / IPv6, tunnel). Radios specific to a target — BLE, LoRa, Zigbee — come with that target's SDK, so you add them only where you need them.
libdaas wrapped for your language and platform — its idioms, event and memory model — with persistence and the hardware drivers of that target. This is the API you call.
The tarball you install: the compiled wrapper, the included drivers, ready-to-run examples that bring a node up at once, and a checksum to verify it. Extract, link, run.
Canonical tarballs & attachments. A libdaas release is a set of per-platform tarballs named
libdaas-<version>-<system>[-<arch>]-<compiler>-<linkage>.tar.gz (plus a
libdaas-<version>-docs.tar.gz), each with a sibling <file>.sha256; the tarballs are not signed, only dynamic driver modules carry a detached
.sig. Each daasiot-<target> SDK is distributed the same way — one binary package
per <target>/<linkage> (.tar.gz on Unix, .zip on Windows), plus a
…-src source package and, where it applies, a …-drivers-sdk-<platform>-<linkage> drivers kit — each again with its
.sha256. On the downloads page the primary tarball of a (SDK, version, variant) is the box; the
source and drivers-sdk packages and the PDF docs ride along as its attachments.
The libdaas inside your package is identical on every platform and verified once — your nodes behave the same across targets, and there's nothing to port.
A static package links only the driver archives you use; a dynamic one ships only the modules it needs, each loaded the first time its link is used.
Apps built with different daas-sdk packages are nodes of the same network — a Java service, a C++ gateway and an ESP32 sensor in one segment.
Every SDK release ships in one of two variants. They differ in how libdaas is bound to your build, not in what the mesh can do — the overlay behaves identically either way. Pick by how you deploy and which targets you ship.
The native embeds libdaas directly — one self-contained package per architecture (e.g. one for x86_64, one for aarch64). No runtime dependency to resolve; the box carries exactly the target it was built for.
The package loads libdaas when it runs and can serve several architectures from one release — the right native is selected on the target. One box, many ISAs.
On the downloads page each SDK box shows a Static or Dynamic badge with its architecture, so you can pick the build that matches your target.
An open-source package letting ROS2 nodes talk over a DaaS overlay mesh — opening up distributed robotics and industrial automation.
A browser tab can act as a full DaaS node, exchanging DDOs in real time with a Node.js peer — the site's live "try it in-browser" lab.