Get the SDK
Overlay Mesh · v0.22.0

Every device,
reachable as a
service.

The Device-as-a-Service overlay mesh — a portable software stack, not another broker.

DaaS-IoT turns isolated hardware into nodes of a distributed, self-organizing network layered over your existing Wi-Fi, Ethernet and Bluetooth. Nodes discover, synchronize and route on their own — no central gateway, no single point of failure.

Download the SDK How it works
~80%
less traffic
≤32 B
header size
380 ms
avg sync
7+
platforms
Overlay Mesh — live ● synced
Nodes
14 active
Path
ETH→WiFi→BLE
Drift
±6.3 ms
Ports to
GNU / C++ESP32PythonJavaAndroidNode.js.NETQtSwiftROS2
The shift

Stop wiring endpoints. Start growing a network.

Traditional IoT

Centralized & brittle

  • Every device leans on a gateway or cloud broker
  • The broker is a single point of failure
  • Manual discovery, IPs and bootstrap per device
  • Protocol-specific glue for each transport
  • Scaling hits vertical bottlenecks
With DaaS-IoT

Distributed & self-healing

  • Nodes discover & provision themselves — no hardcoded IPs
  • No central point: the mesh reroutes around failures
  • Shared time reference via dATS, server-less
  • One unified model over Wi-Fi, Ethernet & BLE
  • Add a node — scale horizontally, natively
One core, every target

Built on libdaas, ported everywhere

A single native runtime carries the paradigm. Language SDKs wrap it; transport drivers connect it to the physical world.

Language SDKs
Python C++ Qt Java Android Node.js .NET Swift
libdaas core runtime
Discovery & Self-ProvisioningdATS Self-SyncChannellingData-relayingDDO / Typeset
Transport drivers
INET4 · IPv4 BLE / Bluetooth Multi-driver failover Custom drivers
Deployment targets
Embedded
ESP32 · dsPIC · Raspberry Pi · aarch64 MCUs
Cloud & server
Linux x86_64 · JVM · Node.js · containers
Standalone
Windows · macOS · desktop & mobile apps
The paradigm

Six ideas doing the heavy lifting

Overlay Network

A network on the network

A logical layer over the physical media — independent of protocol and transport, addressing devices, not sockets.

Mesh Topology

Best path, not shortest

Direct and indirect links, packets rotated across routes for continuity and redundancy — A→C→B when it's faster.

Protocol Channelling

Every radio at once

Wi-Fi for one hop, Bluetooth for the next — links chosen live by availability, performance and security.

Self-Provisioning

Zero-touch onboarding

First nodes define the network; newcomers discover peers and align automatically — no manual bootstrap.

Self-Synchronize

Time without a server

The dATS algorithm keeps a shared time reference — data carries its own timestamp, no round-trips.

Data-relaying

Hold, fragment, forward

Nodes buffer data until a channel opens, fragmenting and recomposing transparently — no broker required.

Why it's different

Not just another MQTT broker

Aspect Traditional IoT DaaS-IoT
ArchitectureCentralizedDistributed mesh
Gateway roleCritical (SPOF)Optional / interchangeable
Network layerIsolated protocolsUnified overlay abstraction
Node onboardingManual discovery & bootstrapAutomatic discovery & provisioning
ScalingVertical, bottleneckedHorizontal, native
CouplingTightEvent-driven decoupling
Where it runs

Built for mission-critical edges

Healthcare

Distributed monitoring where measurement demands precision and reliability.

Industry 4.0

Automation, distributed robotics and smart-factory floors.

Energy

Renewables, distributed metering and energy monitoring.

Smart environment

Sensor networks for smart buildings and smart cities.

Metrology & distributed measurement Unstable / intermittent connectivity Distributed robotics (ROS2) Edge & fog computing
Developer-first

A node in a dozen lines

Event-driven push/pull with total decoupling between application logic and transport. Locate a node, push a DDO, react to onDDOReceived. That's the API.

Browse the SDKs Read the quickstart
sender.py 
from daasiot import Node, LINK_INET4

node = Node(sid=1000, din=1001)
node.add_link(LINK_INET4, host="127.0.0.1")
node.start()

node.locate(1002)
node.push(din=1002, typeset=101,
          payload={"temp": 21.4})

Bootstrap your first node today

Grab an SDK for your platform, run the telemetry pair example, and watch two devices find each other on their own.

Download the SDK Talk to us