https://github.com/dimensionalOS/dimos
Dimensional is the agentic operating system for physical space. Vibecode humanoids, quadrupeds, drones, and other hardware platforms in natural language and build multi-agent systems that work seamlessly with physical input (cameras, lidar, actuators).
https://github.com/dimensionalOS/dimos
Last synced: 12 days ago
JSON representation
Dimensional is the agentic operating system for physical space. Vibecode humanoids, quadrupeds, drones, and other hardware platforms in natural language and build multi-agent systems that work seamlessly with physical input (cameras, lidar, actuators).
- Host: GitHub
- URL: https://github.com/dimensionalOS/dimos
- Owner: dimensionalOS
- License: other
- Created: 2024-10-19T20:13:16.000Z (over 1 year ago)
- Default Branch: main
- Last Pushed: 2026-04-18T21:47:19.000Z (12 days ago)
- Last Synced: 2026-04-18T22:27:27.575Z (12 days ago)
- Language: Python
- Homepage: https://dimensionalos.com/
- Size: 79.8 MB
- Stars: 3,002
- Watchers: 31
- Forks: 495
- Open Issues: 342
-
Metadata Files:
- Readme: README.md
- License: LICENSE
- Agents: AGENTS.md
- Cla: CLA.md
Awesome Lists containing this project
- awesome-github-projects - dimos - Dimensional is the agentic operating system for physical space. Vibecode humanoids, quadrupeds, drones, and other hardware platforms in natural language and build multi-agent systems that work seamlessly with physical input (cameras, lidar, actuators). ⭐3,167 `Python` 🔥 (🌐 Web Development - Frontend)
- awesome-ai-agents - dimos - agent systems that control humanoids, quadrupeds, drones, and other hardware via natural language. (Frameworks & Libraries / Multi-Agent Orchestration)
README
The Agentive Operating System for Physical Space
[](https://discord.gg/dimos)
[](https://github.com/dimensionalOS/dimos/stargazers)
[](https://github.com/dimensionalOS/dimos/fork)
[](https://github.com/dimensionalOS/dimos/graphs/contributors)
[](https://www.docker.com/)
[Hardware](#hardware) •
[Installation](#installation) •
[Agent CLI & MCP](#agent-cli-and-mcp) •
[Blueprints](#blueprints) •
[Development](#development)
⚠️ **Pre-Release Beta** ⚠️
# Intro
Dimensional is the modern operating system for generalist robotics. We are setting the next-generation SDK standard, integrating with the majority of robot manufacturers.
With a simple install and no ROS required, build physical applications entirely in python that run on any humanoid, quadruped, or drone.
Dimensional is agent native -- "vibecode" your robots in natural language and build (local & hosted) multi-agent systems that work seamlessly with your hardware. Agents run as native modules — subscribing to any embedded stream, from perception (lidar, camera) and spatial memory down to control loops and motor drivers.
Navigation and Mapping
SLAM, dynamic obstacle avoidance, route planning, and autonomous exploration — via both DimOS native and ROS
Watch video
Perception
Detectors, 3d projections, VLMs, Audio processing
Agentive Control, MCP
"hey Robot, go find the kitchen"
Watch video
Spatial Memory
Spatio-temporal RAG, Dynamic memory, Object localization and permanence
Watch video
# Hardware
Quadruped
Humanoid
Arm
Drone
Misc
🟩 Unitree Go2 pro/air
🟥 Unitree B1
🟨 Unitree G1
🟨 Xarm
🟨 AgileX Piper
🟧 MAVLink
🟧 DJI Mavic
🟥 Force Torque Sensor
🟩 stable 🟨 beta 🟧 alpha 🟥 experimental
> [!IMPORTANT]
> 🤖 Direct your favorite Agent (OpenClaw, Claude Code, etc.) to [AGENTS.md](AGENTS.md) and our [CLI and MCP](#agent-cli-and-mcp) interfaces to start building powerful Dimensional applications.
# Installation
## Interactive Install
```sh
curl -fsSL https://raw.githubusercontent.com/dimensionalOS/dimos/main/scripts/install.sh | bash
```
> See [`scripts/install.sh --help`](scripts/install.sh) for non-interactive and advanced options.
## Manual System Install
To set up your system dependencies, follow one of these guides:
- 🟩 [Ubuntu 22.04 / 24.04](docs/installation/ubuntu.md)
- 🟩 [NixOS / General Linux](docs/installation/nix.md)
- 🟧 [macOS](docs/installation/osx.md)
> Full system requirements, tested configs, and dependency tiers: [docs/requirements.md](docs/requirements.md)
## Python Install
### Quickstart
```bash
uv venv --python "3.12"
source .venv/bin/activate
uv pip install 'dimos[base,unitree]'
# Replay a recorded quadruped session (no hardware needed)
# NOTE: First run will show a black rerun window while ~75 MB downloads from LFS
dimos --replay run unitree-go2
```
```bash
# Install with simulation support
uv pip install 'dimos[base,unitree,sim]'
# Run quadruped in MuJoCo simulation
dimos --simulation run unitree-go2
# Run humanoid in simulation
dimos --simulation run unitree-g1-sim
```
```bash
# Control a real robot (Unitree quadruped over WebRTC)
export ROBOT_IP=
dimos run unitree-go2
```
# Featured Runfiles
| Run command | What it does |
|-------------|-------------|
| `dimos --replay run unitree-go2` | Quadruped navigation replay — SLAM, costmap, A* planning |
| `dimos --replay --replay-dir unitree_go2_office_walk2 run unitree-go2-temporal-memory` | Quadruped temporal memory replay |
| `dimos --simulation run unitree-go2-agentic-mcp` | Quadruped agentic + MCP server in simulation |
| `dimos --simulation run unitree-g1` | Humanoid in MuJoCo simulation |
| `dimos --replay run drone-basic` | Drone video + telemetry replay |
| `dimos --replay run drone-agentic` | Drone + LLM agent with flight skills (replay) |
| `dimos run demo-camera` | Webcam demo — no hardware needed |
| `dimos run keyboard-teleop-xarm7` | Keyboard teleop with mock xArm7 (requires `dimos[manipulation]` extra) |
| `dimos --simulation run unitree-go2-agentic-ollama` | Quadruped agentic with local LLM (requires [Ollama](https://ollama.com) + `ollama serve`) |
> Full blueprint docs: [docs/usage/blueprints.md](docs/usage/blueprints.md)
# Agent CLI and MCP
The `dimos` CLI manages the full lifecycle — run blueprints, inspect state, interact with agents, and call skills via MCP.
```bash
dimos run unitree-go2-agentic-mcp --daemon # Start in background
dimos status # Check what's running
dimos log -f # Follow logs
dimos agent-send "explore the room" # Send agent a command
dimos mcp list-tools # List available MCP skills
dimos mcp call relative_move --arg forward=0.5 # Call a skill directly
dimos stop # Shut down
```
> Full CLI reference: [docs/usage/cli.md](docs/usage/cli.md)
# Usage
## Use DimOS as a Library
See below a simple robot connection module that sends streams of continuous `cmd_vel` to the robot and receives `color_image` to a simple `Listener` module. DimOS Modules are subsystems on a robot that communicate with other modules using standardized messages.
```py
import threading, time, numpy as np
from dimos.core.blueprints import autoconnect
from dimos.core.core import rpc
from dimos.core.module import Module
from dimos.core.stream import In, Out
from dimos.msgs.geometry_msgs import Twist
from dimos.msgs.sensor_msgs import Image, ImageFormat
class RobotConnection(Module):
cmd_vel: In[Twist]
color_image: Out[Image]
@rpc
def start(self):
threading.Thread(target=self._image_loop, daemon=True).start()
def _image_loop(self):
while True:
img = Image.from_numpy(
np.zeros((120, 160, 3), np.uint8),
format=ImageFormat.RGB,
frame_id="camera_optical",
)
self.color_image.publish(img)
time.sleep(0.2)
class Listener(Module):
color_image: In[Image]
@rpc
def start(self):
self.color_image.subscribe(lambda img: print(f"image {img.width}x{img.height}"))
if __name__ == "__main__":
autoconnect(
RobotConnection.blueprint(),
Listener.blueprint(),
).build().loop()
```
## Blueprints
Blueprints are instructions for how to construct and wire modules. We compose them with
`autoconnect(...)`, which connects streams by `(name, type)` and returns a `Blueprint`.
Blueprints can be composed, remapped, and have transports overridden if `autoconnect()` fails due to conflicting variable names or `In[]` and `Out[]` message types.
A blueprint example that connects the image stream from a robot to an LLM Agent for reasoning and action execution.
```py
from dimos.core.blueprints import autoconnect
from dimos.core.transport import LCMTransport
from dimos.msgs.sensor_msgs import Image
from dimos.robot.unitree.go2.connection import go2_connection
from dimos.agents.agent import agent
blueprint = autoconnect(
go2_connection(),
agent(),
).transports({("color_image", Image): LCMTransport("/color_image", Image)})
# Run the blueprint
if __name__ == "__main__":
blueprint.build().loop()
```
## Library API
- [Modules](docs/usage/modules.md)
- [LCM](docs/usage/lcm.md)
- [Blueprints](docs/usage/blueprints.md)
- [Transports](docs/usage/transports/index.md) — LCM, SHM, DDS, ROS 2
- [Data Streams](docs/usage/data_streams/README.md)
- [Configuration](docs/usage/configuration.md)
- [Visualization](docs/usage/visualization.md)
## Demos
# Development
## Develop on DimOS
```sh
export GIT_LFS_SKIP_SMUDGE=1
git clone -b dev https://github.com/dimensionalOS/dimos.git
cd dimos
uv sync --all-extras --no-extra dds
# Run fast test suite
uv run pytest dimos
```
## Multi Language Support
Python is our glue and prototyping language, but we support many languages via LCM interop.
Check our language interop examples:
- [C++](examples/language-interop/cpp/)
- [Lua](examples/language-interop/lua/)
- [TypeScript](examples/language-interop/ts/)