• • Highlights
  • Latest News 🎉
  • Support Matrix
  • Node Hub
  • Examples
  • Getting Started
  • • Installation
    • With cargo
    • With Github release for macOS and Linux
    • With Github release for Windows
    • With Source
    • Run
    • Documentation
  • What is Dora? And what features does Dora offer?
  • • TCP Communication and Shared Memory
    • Arrow Message Format
    • Opentelemetry
    • ROS2 Bridge
  • Zenoh Integration for Distributed Dataflow (Experimental)
  • • What is Zenoh?
    • Enabling Zenoh Support
  • Launch DORA Daemons with Zenoh Enabled 🚀
  • Deploy Distributed Nodes via YAML 📄
  • Start the Coordinator and Dataflow 🏁
  • YAML Example for Distributed Dataflow 📘
  • Contributing
  • Discussions
  • License
  • Further Resources 📚

Website | Python API | Rust API | Guide | Discord

Highlights

• 🚀 dora-rs is a framework to run realtime multi-AI and multi-hardware applications.
• 🦀 dora-rs internals are 100% Rust making it extremely fast compared to alternative such as being ⚡️ 10-17x faster than ros2.
• ❇️ Includes a large set of pre-packaged nodes for fast prototyping which simplifies integration of hardware, algorithms, and AI models.

Latency benchmark with Python API for both framework, sending 40M of random bytes.

Latest News 🎉

2025

• [03/05] dora-rs has been accepted to GSoC 2025 🎉, with the following idea list.
• [03/04] Add support for Zenoh for distributed dataflow.
• [03/04] Add support for Meta SAM2, Kokoro(TTS), Improved Qwen2.5 Performance using llama.cpp.
• [02/25] Add support for Qwen2.5(LLM), Qwen2.5-VL(VLM), outetts(TTS)

Support Matrix

	dora-rs
APIs	Python >= 3.7 ✅ Rust ✅ C/C++ 🆗 ROS2 >= Foxy 🆗
OS	Linux: Arm 32 ✅ Arm 64 ✅ x64_86 ✅ MacOS: Arm 64 ✅ x64_86 ✅ Windows: x64_86 🆗 Android: 🛠️ (Blocked by: https://github.com/elast0ny/shared_memory/issues/32) IOS: 🛠️
Message Format	Arrow ✅ Standard Specification 🛠️
Local Communication	Shared Memory ✅ Cuda IPC 📐
Remote Communication	Zenoh 📐
Metrics, Tracing, and Logging	Opentelemetry 📐
Configuration	YAML ✅
Package Manager	pip: Python Node ✅ Rust Node ✅ C/C++ Node 🛠️ cargo: Rust Node ✅

• ✅ = First Class Support
• 🆗 = Best Effort Support
• 📐 = Experimental and looking for contributions
• 🛠️ = Unsupported but hoped for through contributions

Everything is open for contributions 🙋

Node Hub

Feel free to modify this README with your own nodes so that it benefits the community.

Type	Title	Support	Description	Downloads	License
Camera	PyOrbbeckSDK	📐	Image and depth from Orbbeck Camera
Camera	PyRealsense	Linux🆗 Mac🛠️	Image and depth from Realsense
Camera	OpenCV Video Capture	✅	Image stream from OpenCV Camera
Peripheral	Keyboard	✅	Keyboard char listener
Peripheral	Microphone	✅	Audio from microphone
Peripheral	PyAudio(Speaker)	✅	Output audio from speaker
Actuator	Feetech	📐	Feetech Client
Actuator	Dynamixel	📐	Dynamixel Client
Chassis	Agilex - UGV	🆗	Robomaster Client
Chassis	DJI - Robomaster S1	📐	Robomaster Client
Chassis	Dora Kit Car	🆗	Open Source Chassis
Arm	Alex Koch - Low Cost Robot	📐	Alex Koch - Low Cost Robot Client
Arm	Lebai - LM3	📐	Lebai client
Arm	Agilex - Piper	🆗	Agilex arm client
Robot	Pollen - Reachy 1	📐	Reachy 1 Client
Robot	Pollen - Reachy 2	🆗	Reachy 2 client
Robot	Trossen - Aloha	📐	Aloha client
Voice Activity Detection(VAD)	Silero VAD	✅	Silero Voice activity detection
Speech to Text(STT)	Whisper	✅	Transcribe audio to text
Object Detection	Yolov8	✅	Object detection
Segmentation	SAM2	Cuda✅ Metal🛠️	Segment Anything
Large Language Model(LLM)	Qwen2.5	✅	Large Language Model using Qwen
Vision Language Model(VLM)	Qwen2.5-vl	✅	Vision Language Model using Qwen2.5 VL
Vision Language Model(VLM)	InternVL	🆗	InternVL is a vision language model
Vision Language Action(VLA)	RDT-1B	🆗	Infer policy using Robotic Diffusion Transformer
Translation	ArgosTranslate	🆗	Open Source translation engine
Translation	Opus MT	🆗	Translate text between language
Text to Speech(TTS)	Kokoro TTS	✅	Efficient Text to Speech
Recorder	Llama Factory Recorder	🆗	Record data to train LLM and VLM
Recorder	LeRobot Recorder	📐	LeRobot Recorder helper
Visualization	Plot	✅	Simple OpenCV plot visualization
Visualization	Rerun	✅	Visualization tool
Simulator	Mujoco	📐	Mujoco Simulator
Simulator	Carla	📐	Carla Simulator
Simulator	Gymnasium	📐	Experimental OpenAI Gymnasium bridge

Examples

Type	Title	Description	Last Commit
Audio	Speech to Text(STT)	Transform speech to text.
Audio	Translation	Translate audio in real time.
Vision	Vision Language Model(VLM)	Use a VLM to understand images.
Vision	YOLO	Use YOLO to detect object within image.
Vision	Camera	Simple webcam plot example
Model Training	Piper RDT	Piper RDT Pipeline
Model Training	LeRobot - Alexander Koch	Training Alexander Koch Low Cost Robot with LeRobot
ROS2	C++ ROS2 Example	Example using C++ ROS2
ROS2	Rust ROS2 Example	Example using Rust ROS2
ROS2	Python ROS2 Example	Example using Python ROS2
Benchmark	GPU Benchmark	GPU Benchmark of dora-rs
Benchmark	CPU Benchmark	CPU Benchmark of dora-rs
Tutorial	Rust Example	Example using Rust
Tutorial	Python Example	Example using Python
Tutorial	CMake Example	Example using CMake
Tutorial	C Example	Example with C node
Tutorial	CUDA Example	Example using CUDA Zero Copy
Tutorial	C++ Example	Example with C++ node

Getting Started

Installation

pip install dora-rs-cli

Additional installation methods

Install dora with our standalone installers, or from crates.io:

With cargo

cargo install dora-cli

With Github release for macOS and Linux

curl --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/dora-rs/dora/main/install.sh | bash

With Github release for Windows

powershell -c "irm https://raw.githubusercontent.com/dora-rs/dora/main/install.ps1 | iex"

With Source

git clone https://github.com/dora-rs/dora.git
cd dora
cargo build --release -p dora-cli
PATH=$PATH:$(pwd)/target/release

Run

• Run the yolo python example:

## Create a virtual environment
uv venv --seed -p 3.11

## Install nodes dependencies of a remote graph
dora build https://raw.githubusercontent.com/dora-rs/dora/refs/heads/main/examples/object-detection/yolo.yml --uv

## Run yolo graph
dora run yolo.yml --uv

Make sure to have a webcam

To stop your dataflow, you can use ctrl+c

• To understand what is happening, you can look at the dataflow with:

cat yolo.yml

• Resulting in:

nodes:
  - id: camera
    build: pip install opencv-video-capture
    path: opencv-video-capture
    inputs:
      tick: dora/timer/millis/20
    outputs:
      - image
    env:
      CAPTURE_PATH: 0
      IMAGE_WIDTH: 640
      IMAGE_HEIGHT: 480

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

  - id: plot
    build: pip install dora-rerun
    path: dora-rerun
    inputs:
      image: camera/image
      boxes2d: object-detection/bbox

• In the above example, we can understand that the camera is sending image to both the rerun viewer as well as a yolo model that generates bounding box that is visualized within rerun.

Documentation

The full documentation is available on our website.
A lot of guides are available on this section of our website.

What is Dora? And what features does Dora offer?

Dataflow-Oriented Robotic Architecture (dora-rs) is a framework that makes creation of robotic applications fast and simple.

dora-rs implements a declarative dataflow paradigm where tasks are split between nodes isolated as individual processes.

The dataflow paradigm has the advantage of creating an abstraction layer that makes robotic applications modular and easily configurable.

TCP Communication and Shared Memory

Communication between nodes is handled with shared memory on a same machine and TCP on distributed machines. Our shared memory implementation tracks messages across processes and discards them when obsolete. Shared memory slots are cached to avoid new memory allocation.

Arrow Message Format

Nodes communicate with Apache Arrow Data Format.

Apache Arrow is a universal memory format for flat and hierarchical data. The Arrow memory format supports zero-copy reads for lightning-fast data access without serialization overhead. It defines a C data interface without any build-time or link-time dependency requirement, that means that dora-rs has no compilation step beyond the native compiler of your favourite language.

Opentelemetry

dora-rs uses Opentelemetry to record all your logs, metrics and traces. This means that the data and telemetry can be linked using a shared abstraction.

Opentelemetry is an open source observability standard that makes dora-rs telemetry collectable by most backends such as elasticsearch, prometheus, Datadog...

Opentelemetry is language independent, backend agnostic, and easily collect distributed data, making it perfect for dora-rs applications.

ROS2 Bridge

Note: this feature is marked as unstable.

• Compilation Free Message passing to ROS 2
• Automatic conversion ROS 2 Message <-> Arrow Array

import pyarrow as pa

# Configuration Boilerplate...
turtle_twist_writer = ...

## Arrow Based ROS2 Twist Message
## which does not require ROS2 import
message = pa.array([{
            "linear": {
                "x": 1,
            },
            "angular": {
                "z": 1
            },
        }])

turtle_twist_writer.publish(message)

You might want to use ChatGPT to write the Arrow Formatting: https://chat.openai.com/share/4eec1c6d-dbd2-46dc-b6cd-310d2895ba15

Zenoh Integration for Distributed Dataflow (Experimental)

Zenoh is a high-performance pub/sub and query protocol that unifies data in motion and at rest. In dora-rs, Zenoh is used for remote communication between nodes running on different machines, enabling distributed dataflow across networks.

What is Zenoh?

• Definition:
  Zenoh is an open-source communication middleware offering pub/sub and query capabilities.
• Benefits in DORA:
  • Simplifies communication between distributed nodes.
  • Handles NAT traversal and inter-network communication.
  • Integrates with DORA to manage remote data exchange while local communication still uses efficient shared memory.

Enabling Zenoh Support

1. Run a Zenoh Router (zenohd):
   Launch a Zenoh daemon to mediate communication. For example, using Docker:

   docker run -p 7447:7447 -p 8000:8000 --name zenoh-router eclipse/zenohd:latest
   
   
   

## Create a Zenoh Configuration File 🎛️

Create a file (e.g., `zenoh.json5`) with the router endpoint details:

```json5
{
  "connect": {
    "endpoints": [ "tcp/203.0.113.10:7447" ]
  }
}

---

Launch DORA Daemons with Zenoh Enabled 🚀

On each machine, export the configuration and start the daemon:

export ZENOH_CONFIG=/path/to/zenoh.json5  
dora daemon --coordinator-addr <COORD_IP> --machine-id <MACHINE_NAME>

---

Deploy Distributed Nodes via YAML 📄

Mark nodes for remote deployment using the _unstable_deploy key:

nodes:
  - id: camera_node
    outputs: [image]

  - id: processing_node
    _unstable_deploy:
      machine: robot1
      path: /home/robot/dora-nodes/processing_node
    inputs:
      image: camera_node/image
    outputs: [result]

---

Start the Coordinator and Dataflow 🏁

Run the coordinator on a designated machine and start the dataflow:

dora coordinator
dora start dataflow.yml

---

YAML Example for Distributed Dataflow 📘

communication:
  zenoh: {}

nodes:
  - id: camera_node
    custom:
      run: ./camera_driver.py
    outputs:
      - image

  - id: processing_node
    _unstable_deploy:
      machine: robot1
      path: /home/robot/dora-nodes/processing_node
    inputs:
      image: camera_node/image
    outputs:
      - result

Contributing

We are passionate about supporting contributors of all levels of experience and would love to see
you get involved in the project. See the
contributing guide to get started.

Discussions

Our main communication channels are:

• Our Discord server
• Our Github Project Discussion

Feel free to reach out on any topic, issues or ideas.

We also have a contributing guide.

License

This project is licensed under Apache-2.0. Check out NOTICE.md for more information.

---

Further Resources 📚

• Zenoh Documentation
• DORA Zenoh Discussion (GitHub Issue #512)
• Dora Autoware Localization Demo