Hardware • Installation • Development • Multi Language • ROS
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.
|
|
|
SLAM, dynamic obstacle avoidance, route planning, and autonomous exploration — via both DimOS native and ROS Watch video |
Detectors, 3d projections, VLMs, Audio processing |
|
|
|
"hey Robot, go find the kitchen" Watch video |
Spatio-temporal RAG, Dynamic memory, Object localization and permanence Watch video |
|
|
|
|
|
|
🟩 Unitree Go2 pro/air 🟥 Unitree B1 |
🟨 Unitree G1 |
🟥 Xarm 🟥 AgileX Piper |
🟥 Mavlink 🟥 DJI SDK |
🟥 Force Torque Sensor |
To set up your system dependencies, follow one of these guides:
uv venv --python "3.12"
source .venv/bin/activate
uv pip install dimos[base,unitree]
# Replay a recorded Go2 session (no hardware needed)
# NOTE: First run will show a black rerun window while ~2.4 GB downloads from LFS
dimos --replay run unitree-go2# Install with simulation support
uv pip install dimos[base,unitree,sim]
# Run Go2 in MuJoCo simulation
dimos --simulation run unitree-go2
# Run G1 humanoid in simulation
dimos --simulation run unitree-g1-sim# Control a real robot (Unitree Go2 over WebRTC)
export ROBOT_IP=<YOUR_ROBOT_IP>
dimos run unitree-go2See 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.
import threading, time, numpy as np
from dimos.core import In, Module, Out, rpc, autoconnect
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 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.
from dimos.core import autoconnect, 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()
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 dimosPython is our glue and prototyping language, but we support many languages via LCM interop.
Check our language interop examples:
For researchers, we can talk to ROS directly via ROS Transports, or host dockerized ROS deployments as first-class DimOS modules, allowing you easy installation and portability