dora-rs

dora-rs (Dataflow-Oriented Robotic Architecture) is a modern robotics middleware built from the ground up in Rust. It implements a declarative dataflow paradigm where robotic applications are modeled as directed graphs of isolated processes communicating through zero-copy shared memory.

The framework addresses a critical gap in robotics infrastructure: while ROS2 has become the de facto standard, its performance limitations become apparent in AI-driven applications requiring high-frequency data exchange between multiple sensors, ML models, and actuators. dora-rs achieves 10-17x lower latency than ROS2 by using Apache Arrow for memory-efficient message passing and a custom shared memory daemon that eliminates serialization overhead.

What it does

At its core, dora-rs orchestrates communication between robotic components called "nodes." Each node runs as an isolated process, communicating through well-defined inputs and outputs specified in a YAML dataflow configuration. This architecture provides several advantages:

• Language flexibility: Nodes can be written in Python, Rust, C, or C++
• Fault isolation: A crashing node doesn't bring down the entire system
• Hot reloading: Python nodes can be modified and reloaded without stopping the dataflow
• Observability: Built-in OpenTelemetry integration for distributed tracing

The framework includes a growing ecosystem of pre-built nodes in the dora-hub repository, covering common robotics tasks like camera capture, object detection (YOLO), LLM inference, and visualization.

Architecture

Communication happens through two mechanisms:

• Shared memory for local communication on the same machine
• TCP/Zenoh for distributed communication across machines

The use of Apache Arrow as the message format is particularly significant for AI workloads. Arrow's columnar memory format allows zero-copy data sharing between processes, meaning a camera node can pass image data to a YOLO detection node without copying the pixel buffer.

ROS2 interoperability

dora-rs includes a ROS2 bridge that enables interoperability with existing ROS2 ecosystems. This allows gradual migration paths where dora-rs nodes can communicate with ROS2 topics, and ROS2 message types can be converted to/from Arrow arrays.

Limitations

• Ecosystem maturity: Smaller package ecosystem compared to ROS2's extensive package repository
• Learning curve: Rust-based internals may present challenges for teams without Rust expertise
• Hardware support: Android and iOS support is experimental or incomplete
• Documentation gaps: Some advanced features lack comprehensive documentation
• Community size: Smaller community than ROS2, meaning fewer third-party tutorials and examples
• Windows support: Marked as "best effort" rather than first-class support