This hub contains useful pre-built nodes for Dora.

The nodes maintained in this repo (under node-hub/) are published to the Dora Hub catalog, so you can pull one into a dataflow with a single line of YAML — no clone, no manual path: wiring:

nodes:
  - id: detector
    hub: dora-yolo@^0.5      # resolved, pinned, and type-checked by `dora build`
    inputs:
      image: camera/image
    outputs:
      - bbox

dora build resolves the version requirement to an exact published version, pins it to a commit, and injects the node's typed input/output contracts into validation. Discover and inspect nodes with:

dora hub search yolo                 # find by name / keyword / category
dora hub info dora-yolo              # contracts + a ready-to-paste example

See the Dora Hub guide for version requirements, reproducible builds (--locked), publishing, and offline use. (The hub: feature is currently unstable.)

Publishing a node

This repo is both the node collection (node-hub/<name>/ source) and the catalog (node-index/, the published index entries). To publish a node you maintain here:

cd node-hub/my-node
dora hub init               # scaffold a dora-node.yml manifest (if needed)
dora hub publish --dry-run  # preview the exact index entry
dora hub publish            # print the entry + PR instructions (open the PR manually)

The catalog is append-only and CI-gated. See CONTRIBUTING.md for the workflow, node-index/README.md for the entry format, and node-index/POLICY.md for namespaces and ownership.

Packages

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

Type	Title	Description	Support	Downloads	License
Camera	Kornia GST Capture	Video Capture using Gstreamer	✅
Camera	Kornia V4L Capture	Video stream for Linux Cameras	✅
Camera	PyOrbbeckSDK	Image and depth from Orbbeck Camera	📐
Camera	PyRealsense	Image and depth from Realsense	Linux🆗 Mac🛠️
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	Dora Kit Car	Open Source Chassis	🆗
Chassis	DJI - Robomaster S1	Robomaster Client	📐
Arm	Alex Koch - Low Cost Robot	Alex Koch - Low Cost Robot Client	📐
Arm	Agilex - Piper	Agilex arm client	🆗
Arm	Lebai - LM3	Lebai client	📐
Robot	Trossen - Aloha	Aloha client	📐
Robot	Pollen - Reachy 1	Reachy 1 Client	📐
Robot	Pollen - Reachy 2	Reachy 2 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	Segment Anything	Cuda✅ Metal🛠️
Large Language Model(LLM)	Qwen2.5	Large Language Model using Qwen	✅
Vision Language Model(VLM)	InternVL	InternVL is a vision language model	🆗
Vision Language Model(VLM)	Qwen2.5-vl	Vision Language Model using Qwen2.5 VL	✅
Vision Language Action(VLA)	RDT-1B	Infer policy using Robotic Diffusion Transformer	🆗
Translation	Opus MT	Translate text between language	🆗
Translation	ArgosTranslate	Open Source translation engine	🆗
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	Gymnasium	Experimental OpenAI Gymnasium bridge	📐
Simulator	Carla	Carla Simulator	📐
nan	Kornia Sobel Operator	Kornia image processing Sobel operator	✅

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

Python

Add a new python node

• To work on a new node, start by:

cd node-hub
dora new your-node-name --lang python --kind node
cd ./your-node-name
uv venv --seed -p 3.11
uv pip install -e . # Install
uv run ruff check . --fix # Format
uv run ruff check . # Lint
uv run pytest . # Test

• To add a python dependency just do:

uv add numpy # for example

The package is then added to your pyproject.toml

• Modify the code within main.py in your liking.

• Create a PR and let the CI/CD run test on it 🙋

Structure

The structure of the node hub is as follows (please use the same structure if you need to add a new node):

node-hub/
└── your-node/
    ├── README.md
    ├── your-node
    │   ├── __init__.py
    │   ├── __main__.py
    │   └── main.py
    ├── pyproject.toml
    └── tests
        └── test_<your-node>.py

The idea is to make a pyproject.toml file that will install the required dependencies for the node and attach main function of the node inside a callable script in your environment.

To do so, you will need to add a main function inside the main.py file.

def main():
    pass

And then you will need to adapt the following pyproject.toml file:

[project]
name = "[name of the node e.g. video-encoder, with '-' to replace spaces]"
version = "0.1"
authors = [{ name = "[Pseudo/Name]", email = "[email]" }]
description = "Dora Node for []"
readme = "README.md"
license = { text = "MIT" }

dependencies = [
    "dora-rs >= 0.3.8",
]

[project.scripts]
[name of the node with '-' to replace spaces] = "[name of the node with '_' to replace spaces].main:main"

[tool.ruff.lint]
extend-select = [
  "D",    # pydocstyle
  "UP",   # Ruff's UP rule
  "PERF", # Ruff's PERF rule
  "RET",  # Ruff's RET rule
  "RSE",  # Ruff's RSE rule
  "NPY",  # Ruff's NPY rule
  "N",    # Ruff's N rule
  "I",    # Ruff's I rule
]

Finally, the README.md file should explicit all inputs/outputs of the node and how to configure it in the YAML file.

Example

[project]
name = "opencv-plot"
version = "0.1"
authors = [
    "Haixuan Xavier Tao <tao.xavier@outlook.com>",
    "Enzo Le Van <dev@enzo-le-van.fr>"
]
description = "Dora Node for plotting data with OpenCV"
readme = "README.md"
license = { text = "MIT" }
requires-python = ">=3.7"

dependencies = [
    "dora-rs >= 0.3.8",
]
[dependency-groups]
dev = ["pytest >=8.1.1", "ruff >=0.9.1"]

[project.scripts]
opencv-plot = "opencv_plot.main:main"

[tool.ruff.lint]
extend-select = [
  "D",    # pydocstyle
  "UP",   # Ruff's UP rule
  "PERF", # Ruff's PERF rule
  "RET",  # Ruff's RET rule
  "RSE",  # Ruff's RSE rule
  "NPY",  # Ruff's NPY rule
  "N",    # Ruff's N rule
  "I",    # Ruff's I rule
]

Adding git dependency

• If a git repository is added as submodule. Proper path should be added in pyproject.toml inorder to make sure that linting and testing are exempted for that dependency.
• A very good example of how this can be done is as follows

Correct approach:

[tool.ruff]
exclude = ["dora_magma/Magma"]

[tool.black]
extend.exclude = "dora_magma/Magma"

Incorrect Approach:

[tool.ruff]
exclude = ["dora-magma/dora_magma/Magma"]

[tool.black]
extend.exclude = "dora_magma/Magma"

Note:

• dora-magma is root folder of the node.

Rust

Add a new rust node

cd node-hub
dora new your-node-name --lang rust --kind node
cd ./your-node-name

Steps Before Building

• Before building the node, make sure to add your node to the workspace members list in the root Cargo.toml file:

[workspace]
members = [
...
"node-hub/your-node-name"
]

• Also change the Cargo.toml file in your node to use the workspace version of dora-node-api:

[dependencies]
dora-node-api = { workspace = true }

Structure

The structure of the node hub for Rust is as follows (please use the same structure if you need to add a new node):

node-hub/
└── your-node/
    ├── Cargo.toml
    ├── README.md
    └── src/
           └── main.rs

The README.md file should explicit all inputs/outputs of the node and how to configure it in the YAML file.

License

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