Get Sebyone's public key Get the SDK
The paradigm

Reachability of the device, delivered as a service.

Communication is no longer something you implement per device. A local service absorbs the complexity of managing transmission channels and offers one unified model to reach remote devices with whatever technology is most effective in the real operating context.

The vocabulary

Six primitives, one mental model

A node hosts the DaaS stack and uses locally available communication resources to reach other nodes. Everything else builds on these.

Node

Connected when a channel reaches another node; active when its timer is aligned with the already-active nodes.

DIN

DaaS IdeNtifier — identifies a single node instance within the network.

SID

System IDentifier — identifies the distributed system (segment) a node belongs to.

DDO

DaaS Data Object — the unit of information exchanged. A recognizable object in the network, not a raw packet.

Typeset

Semantic classification of a DDO — state, telemetry, command, result, notification, event — so nodes read meaning uniformly.

DME

DaaS-MEssage — encapsulates DDOs for transfer. Three variants: transfer, control, service.

The API

Event-driven push / pull

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 node
  • push(din, typeset, ts, payload) — send a DDO
  • onDDOReceived() → pull() — receive it
communication model
# sender
locate(din)
push(din, typeset, ts, payload)

# receiver
onDDOReceived()  →  pull()
Time without a server

The dATS synchronization algorithm

Nodes 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.

server-less resilient robust scalable precise
Experimental results — Case 4 · 3 heterogeneous nodes
380 ms
avg sync time
±6.3 ms
network-period error
12 pkt
avg ATS per sync

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.

Protocol efficiency

A header that stays under 32 bytes

Variable-size, variable-meaning encapsulation keeps the DME + DDO header compact — efficient even over frame-limited underlay protocols.

Parameter Underlay · IPv4 / TCP Overlay · DaaS INET4
Packet header40 bytes (max 60)32 bytes (max 32)
Traffic footprintbaselineup to ~80% less
Measurement toolstandard (TCP-level only)dsperf (layers 5–6)

Overlay overhead is measurable but negligible against the gains in self-configuration, security and scalability — validated with the University Metrology Department using dsperf.

In motion

Representative scenarios

Multi-driver failover

Ethernet or Wi-Fi drops while DaaS-IoT keeps delivering DDOs over the best available driver: ETH → WiFi → BLE.

Temporal consensus

After the first DDO-ATS exchange, nodes converge to a shared time — no central clock, no round-trip.

Autonomous discovery

A new node boots, discovers neighbors, joins the topology and synchronizes — with virtually zero configuration.

Intelligent routing

Prefers A → C → B over A → B when the longer path is faster and more reliable — best path, not shortest.

The distribution model

What you download, and how to use it

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.

1 · Core

libdaas (the runtime)

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.

2 · Drivers included

Generic transport

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.

3 · Your SDK

daas-sdk-<target>

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.

4 · The download

daasiot-<target>

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.

How it is distributed — the libdaas archive and the per-platform SDKs
DaaS-IoT distribution model One libdaas source tree is built into per-platform libdaas release tarballs, published to the daasiot.com catalog; each daasiot-target SDK fetches the matching libdaas package and is itself distributed as per-platform tarballs with canonical names. 1 · SOURCE 2 · LIBDAAS ARCHIVE (catalog) 3 · SDKs PER PLATFORM daas-api one source tree libdaas built per platform libdaas release tarballs static & dynamic, per platform libdaas-<ver>-linux-x86_64-gcc-static.tar.gz libdaas-<ver>-windows-x64-msvc-dynamic.tar.gz libdaas-<ver>-<sys>[-<arch>]-<cc>-<link>.tar.gz each carries MANIFEST.json + generic drivers; checksum alongside: <tarball>.sha256 libdaas-<ver>-docs.tar.gz (the PDFs) published to daasiot.com, grouped by libdaas version & architecture daasiot-gnu (GNU/Linux, OpenWrt, MinGW) daasiot-gnu-<ver>-<target>-<link>.tar.gz daasiot-msdn (Windows, .NET) daasiot-msdn-<ver>-win-x64-<link>.zip daasiot-esp32 daasiot-esp32-<ver>-<chip>-<link>.tar.gz daasiot-java (JVM) daasiot-java-<ver>-<link>.tar.gz each SDK fetches the matching libdaas package (tools/fetch_ld), checked against its lock & the published .sha256

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.

Same core everywhere

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.

Take only what you need

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.

One network, many media

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.

Two ways to link libdaas

Static or dynamic — how to choose

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.

Static

libdaas linked at build time

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.

  • Simplest to deploy — a single artifact, nothing to load
  • One package per ISA; publish one release per architecture
  • Best for embedded / single-target devices (ESP32, a specific gateway)
Dynamic

libdaas loaded at runtime

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.

  • One package covers multiple targets
  • Smaller to update — swap libdaas without rebuilding the app
  • Best for multi-platform fleets and desktop/server deployments

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.

Browse the packages

Integrations

It plugs into your world

ROS2

DaaS-ROS Bridge

An open-source package letting ROS2 nodes talk over a DaaS overlay mesh — opening up distributed robotics and industrial automation.

In-browser

JavaScript node

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.

Ready to build on the mesh?

Pick an SDK, run the examples, and let your devices find each other.

Get the SDK Back to overview