An EAIOS that turns the robot body into a uniform, capability-first runtime — so models, sensors, and actuators plug in once and reuse everywhere.

Robonix is the operating system between a robot's hardware and an embodied LLM/VLM/VLA/WAM brain. It standardises how device drivers, runtime services, user skills, and the planner discover and talk to each other; it owns identity, configuration, time, transport, logging, health, body model, scene model, execution, and safety as named, replaceable components.

On top of system, three open categories — provided as contracts (61 standard interfaces in capabilities/) and reference implementations alongside the system:

• primitive — one device per package (camera, lidar, chassis, arm). Lives in deployment repos and per-example folders (e.g. examples/webots/primitives/).
• service — runtime functionality (mapping, navigation, semantic map, memory, speech, voiceprint). Default reference implementations ship in services/; each can be swapped out by a deployment.
• skill — user-defined reusable execution flows (grasp, place, explore, fold-clothes …). Lives wherever the deploy/integrator wants.

"Tested" means the full Robonix pipeline runs end-to-end on that platform — in simulation or on a real robot: voice & interaction, task execution, body movement, scene & mapping (semantic map + spatial map), navigation, and skill execution. Other Linux distributions will likely work but are not regularly verified.

Relationship with ROS 2. Robonix itself does not depend on ROS 2 — it is one of the transports nexus offers, not a requirement of the system. If a capability provider needs the ROS 2 communication libraries and the host OS has no ROS 2 support, run that provider in a Docker container. Within a single Robonix deployment, all ROS 2-based capability providers must use the same ROS 2 distribution (Foxy / Humble / Jazzy); Humble is recommended.

git clone --recursive https://github.com/syswonder/robonix
cd robonix
make install   # builds the Cargo workspace and installs
               # rbnx + robonix-{atlas,pilot,executor,liaison,codegen}
               # to ~/.cargo/bin, then registers this clone via `rbnx setup`

The Webots Tiago example (examples/webots/) is the standard end-to-end demo. Two terminals — the simulator and Robonix itself.

# (1) — simulation environment (Webots GUI; not a Robonix package — just docker compose)
bash examples/webots/sim/start.sh

# (2) — Robonix: system services + Tiago primitives + Nav2 + scene
export VLM_BASE_URL=https://api.openai.com/v1   # any OpenAI-compatible endpoint
export VLM_API_KEY=sk-...
export VLM_MODEL=gpt-5.5
cd examples/webots
rbnx build       # first run pulls model weights + docker images, may take a while
rbnx boot

Once rbnx boot reports the stack is up:

# (3)
rbnx caps          # list registered capabilities + interfaces
rbnx chat          # interactive TUI chat with the pilot

Tear-down:

cd examples/webots && rbnx shutdown    # reads rbnx-boot/state.json,
                                       # SIGTERMs each component's PGID
bash examples/webots/sim/stop.sh       # then stop the Webots container

Full first-run walkthrough: docs/src/getting-started/quickstart.md.

system/         system components, one directory each
services/       default reference service implementations (memsearch, voiceprint, speech)
pylib/          Python SDK (robonix-api on PyPI)
capabilities/   contract TOMLs + ROS-style IDL tree (capabilities/lib/)
tools/          dev tooling — rbnx CLI + codegen
examples/       end-to-end deployments (webots, test_ci)
docs/           mdBook developer guide (submodule)
Cargo.toml      workspace for the Rust components (4 in system/, 2 in tools/)
Makefile        top-level orchestrate (build / install / fmt / check)

system/<name>/ and services/<name>/ and tools/<name>/ are each self-contained packages — Rust ones carry their own Cargo.toml, Python ones their own pyproject.toml. There is no top-level rust/ / python/ split; the runtime role is what determines where a component lives, not the implementation language.

Dive deeper:

• Overview — control plane, one full request end-to-end
• Namespaces & contracts — how robonix/primitive/* / robonix/service/* / robonix/skill/* / robonix/system/* work
• Interface catalog — every primitive + service contract

• Robonix Skill Toolkit — a training toolkit for VLA-based Robonix skills: collect teleop data, fine-tune an OpenVLA-OFT policy, and deploy it on a real robotic arm (AgileX Piper).

• Agilex Ranger Mini v3 Chassis Robonix Primitive Package
• Livox MID360 Lidar Robonix Primitive Package
• Livox MID360 IMU Robonix Primitive Package
• Intel Realsense Camera Robonix Primitive Package

• SLAM Mapping Robonix Service Package
  • With RTABMAP, FAST-LIO2 integration
• Nav2 Robonix Service Package

• Environment Explorer Robonix Skill Package
  • A simple room exploration skill robonix/skill/explore/*

• Deploy Manifest for AgileX Ranger Mini Robot at Syswonder Lab

Thanks goes to these wonderful people:

wheatfox 💻 🚧	Zhaobo Zhang 💻	Guowei Li 💻	wuzheng 💻	Kaile Liu 💻
Feiyang Li 💻	MuJue 💻	Zhenyu Zhang 💻	lhw2002426 💻	Zihao Zheng 🔧 🔣
qingfeng123 🔧 🔣

This project follows the all-contributors specification. Contributions of any kind welcome!

Mulan Permissive Software License, Version 2 (MulanPSL-2.0). See LICENSE.