dimos 0.0.10

Powering agentive generalist robotics

The Agentive Operating System for Generalist Robotics

Hardware • Installation • Development • Multi Language • ROS

⚠️ Alpha Pre-Release: Expect Breaking Changes ⚠️

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 SDK	🟥 Force Torque Sensor

🟩 stable 🟨 beta 🟧 alpha 🟥 experimental

Installation

System Install

To set up your system dependencies, follow one of these guides:

• 🟩 Ubuntu 22.04 / 24.04
• 🟩 NixOS / General Linux
• 🟧 macOS

Python Installs

Quickstart

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-go2

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.

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

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()

Library API

• Modules
• LCM
• Blueprints
• Transports
• Data Streams
• Configuration
• Visualization

Develop on DimOS

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

Demos

Development

Multi Language Support

Python is our glue and prototyping language, but we support many languages via LCM interop.

Check our language interop examples:

• C++
• Lua
• TypeScript

ROS interop

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