Dora: a Rust robotics framework that runs multi-language nodes as YAML dataflows

What this is

Dora — "Agentic Dataflow-Oriented Robotic Architecture" — is a 100% Rust framework for building real-time robotics and AI applications as directed graphs of connected nodes. Version 1.0 shipped in September 2026; the repository now sits at release tag v1.1.0, Apache-2.0 licensed, about 14 MB across 1310 files.

The pitch is performance plus ergonomics: Rust internals with zero-copy shared-memory IPC for messages over 4 KB, an Arrow-native columnar message format end-to-end, and a single dora CLI that covers the whole lifecycle from local dev to distributed clusters. The README claims 10-17x faster than ROS2 Python.

It is also built with "agentic engineering": AI agents do code generation, review, refactoring and testing while humans gate every merge. That shows in the repository's unusually elaborate QA ladder — make qa-fast, qa-full, qa-deep, qa-nightly — described below.

Who it is for

Dora targets robotics and AI developers building real-time applications, or who need to mix languages in one pipeline; the README claims it is 10-17x faster than ROS2 Python. Nodes are standalone processes written with native APIs (not wrappers) in Rust, Python 3.11+, C or C++; operators are lightweight functions that run inside a shared runtime for simple transformations.

A dataflow is declared as YAML: each node declares its binary or script, its inputs and outputs. Built-in timer nodes (dora/timer/millis/<N>, dora/timer/hz/<N>) drive periodic pipelines; an input like <node-id>/<output-name> subscribes to another node's output.

nodes:
  - id: camera
    build: pip install opencv-video-capture
    path: opencv-video-capture
    inputs:
      tick: dora/timer/millis/20
    outputs:
      - image

  - id: object-detection
    build: pip install dora-yolo
    path: dora-yolo
    inputs:
      image: camera/image
    outputs:
      - bbox

Architecture

Dora separates control from data. The CLI talks to a Coordinator over WebSocket on port 6013; the Coordinator launches one Daemon per host, also over WebSocket; daemons spawn and manage nodes locally. Nodes exchange data directly through Zenoh shared memory — bypassing the daemon for large payloads — with automatic network fallback when nodes are not co-located.

| Layer | Protocol | |-------|----------| | CLI ↔ Coordinator | WebSocket (port 6013) | | Coordinator ↔ Daemon | WebSocket | | Daemon ↔ Daemon | Zenoh | | Node ↔ Node | Zenoh SHM, zero-copy for messages >4 KB |

The workspace is organized into binaries/ (cli, coordinator, daemon, runtime, bridges), libraries/ (core, message, arrow-convert, recording, extensions) and apis/ (rust, python, c, c++ node and operator APIs). The Coordinator keeps a persistent redb-backed state store by default so dataflow records survive coordinator restarts; daemons auto-reconnect with exponential backoff.

Getting started

The recommended install is two commands:

cargo install dora-cli           # CLI (dora command)
pip install dora-rs              # Python node/operator API

Note the README's warning: the PyPI package is dora-rs, and while the import name is dora (from dora import Node), plain pip install dora gets an unrelated package. Platform installers exist for macOS/Linux (a curl script) and Windows (PowerShell). Building from source uses Cargo with feature flags — tracing, metrics, python (PyO3, off by default) and redb-backend.

The quick start runs a sender → transformer → receiver pipeline locally:

pip install dora-rs numpy pyarrow
git clone https://github.com/dora-rs/dora.git && cd dora
dora run examples/python-dataflow/dataflow.yml

A Python node is just an event loop over the Node API — send outputs, poll for STOP, or iterate incoming events.

from dora import Node
import pyarrow as pa

node = Node()
for event in node:
    if event["type"] == "INPUT":
        print(f"Got {event['id']}: {event['value'].to_pylist()}")
    elif event["type"] == "STOP":
        break

How the work flows

dora run <PATH> runs a dataflow locally with no coordinator or daemon. For distributed operation you start infrastructure first — dora up brings up coordinator and daemon, then dora start dataflow.yml --attach, monitor with dora list, dora logs, dora top, and tear down with dora down. A managed cluster path uses dora cluster up cluster.yml.

Beyond lifecycle commands the CLI is wide: topic inspection (topic echo/hz/info), recording to .drec files and replaying them, live node add/remove/connect/disconnect for dynamic topology, runtime parameter get/set, trace viewing, and a Node Hub that pulls reusable nodes into a dataflow with one YAML line — hub: dora-yolo@^0.5 — resolved cargo-style with lockfiles.

The README's production claims are equally broad: per-node restart policies, circuit breakers, an optional --rt flag for mlockall plus SCHED_FIFO soft real-time, CPU affinity pinning in YAML, and built-in OpenTelemetry tracing and metrics. Communication patterns — service (request/reply), action (goal/feedback/result) and streaming (session/segment/chunk) — are implemented via well-known metadata keys without daemon or YAML changes.

Quality gates

Because much of the code is AI-authored, Dora ships a three-tier QA system that runs locally first and mirrors CI. The ladder climbs from qa-fast (~15s pre-commit sanity: fmt, clippy, audit, typos) through qa-full, qa-deep (adds mutation testing and semver), to qa-nightly — full parity with the nightly workflow at roughly 3-4 hours. Gates include an unwrap ratchet that only lets .unwrap() counts go down, diff-coverage at 70% on PR-touched lines, proptest property tests on wire protocols, Miri for UB detection, and a breaking-change gate that freezes the C header, cxx bridge, YAML schema, postcard wire format and Python floor, diffed against the last release tag.

For contributors the guidance is to discuss non-trivial work in an issue or Discord thread first, then run the QA level appropriate to the change. The repository keeps its own contributor cheat sheet and QA runbook under docs/.

Bottom line

Dora is a mature, actively maintained robotics dataflow framework that has committed hard to performance (Rust + Arrow + shared memory), language flexibility (four native node APIs) and production features (fault tolerance, clusters, recording). It is a large surface — 1310 files, dozens of workspace members, ROS2 and MAVLink bridges — so it rewards teams who want the whole platform rather than a thin layer. For anyone evaluating whether to adopt it, the README's own advice holds: start with dora run on an example dataflow before reaching for the distributed features.