dora-rs/dora

DORA (Dataflow-Oriented Robotic Architecture) is middleware designed to streamline and simplify the creation of AI-based robotic applications. It offers low latency, composable, and distributed dataflow capabilities. Applications are modeled as directed graphs, also referred to as pipelines.

What it solves

Dora provides a high-performance framework for building real-time robotics and AI applications. It addresses the latency and throughput bottlenecks often found in traditional robotics frameworks (like ROS2 Python) by utilizing a Rust-based core and zero-copy shared memory communication, making it suitable for data-heavy AI pipelines.

How it works

Dora uses a dataflow-oriented architecture where applications are defined as directed graphs in YAML files. Nodes (standalone processes) or operators (lightweight in-process functions) are connected via typed inputs and outputs.

Technically, it employs:

  • Zenoh SHM data plane: Allows nodes to publish data directly via shared memory, bypassing the daemon for lower latency.
  • Apache Arrow: Uses a columnar memory format end-to-end to eliminate serialization overhead.
  • Distributed Orchestration: A Coordinator manages the lifecycle of dataflows across multiple Daemons (one per host), enabling seamless local and cross-machine communication.

Who it’s for

It is designed for robotics and AI engineers who need to build complex, real-time systems that require high throughput (e.g., for camera feeds or LLM outputs) and support for multiple languages (Rust, Python, C, C++).

Highlights

  • Extreme Performance: 10-17x faster than ROS2 Python with zero-copy shared memory for large payloads.
  • Multi-language Support: Native APIs for Rust, Python, C, and C++ allowing mixed-language dataflows.
  • Production-Ready Tooling: Includes fault tolerance (restart policies), distributed cluster management, and OpenTelemetry integration for tracing and metrics.
  • Observability: Built-in TUI for resource monitoring (dora top), topic inspection, and record/replay capabilities for regression testing.
  • Node Hub: A package manager for pulling reusable, versioned nodes (e.g., YOLO, LLMs) into a project.

Related

  • Project
    ldclabs/anda

    Anda is a Rust framework for building composable AI agent runtimes, offering type‑safe traits, async orchestration, model routing, scoped contexts, and optional memory/tool extensions.

  • Project
    mosaico-labs/mosaico

    A high-performance data platform for robotics and Physical AI that transforms monolithic sensor logs into structured, queryable archives for model training.

  • Project
    copper-project/copper-rs

    Copper is a Rust runtime for building static, zero‑allocation robot task graphs that run deterministically on Linux, macOS, SBCs, or bare‑metal microcontrollers. It records all messages and timing into a replayable `.copper` log, supports ROS 2 via Zenoh, and offers tooling (templates, justfile helpers, telemetry) for development, debugging, and cross‑platform deployment.

  • Project
    OpenDCAI/DataFlow

    DataFlow is an open‑source Python framework that lets you build, run, and share low‑code pipelines for generating, cleaning, and evaluating LLM training data. It provides a library of reusable operators, a visual WebUI, an AI‑assistant for auto‑creating pipelines, and a Ray‑based distributed execution layer.

  • Project
    Eventual-Inc/Daft

    A high-performance, Rust-powered data engine designed to process multimodal AI workloads, allowing users to handle images, audio, and video alongside structured data at scale.