Module 1: What Is DimOS?
What is DimOS?
Before you touch a terminal, get the mental model right: what DimOS is, how modules and blueprints fit together, where it runs on the robot, and what the G1 can do once it's installed.
In this module
1 · An operating system for robots
DimOS is an open-source operating system for robots. In the way Linux or Windows manages a PC, DimOS manages the G1. The comparison is worth taking seriously, because the job really is the same: an operating system sits between a machine's hardware and its software, so that programs can use the hardware without caring how it works. On a PC that means handling the monitor, the keyboard, the speakers. On the G1, it's the motors, the camera, the LiDAR — everything on the robot.
One honest nuance: DimOS doesn't replace the robot's brain the way Windows replaces nothing on a bare PC. The G1's own firmware still handles low-level balance underneath, and DimOS sends it commands — you'll see exactly how in section 4. But for everything you build in this course, DimOS is the layer you talk to.
2 · Modules — the building blocks
DimOS itself is built out of modules — small programs that each do a single job: one reads the camera, one builds a map of the room, one runs an AI model. Each module runs on its own, and modules never call each other directly. Instead they pass messages: the camera module publishes frames, and any module that wants frames subscribes to them.
That separation is the whole trick. Because modules only communicate through messages, they can be mixed, swapped, and reused freely — the mapping module doesn't know or care whether its data comes from a LiDAR on a humanoid or a LiDAR on a robot dog. It just receives point clouds and builds maps.
▸ For the curious — what a module looks like in code optional
A module is a Python class that inherits from DimOS's Module base class. It declares its inputs and outputs as typed ports — and ports with matching names and types connect to each other automatically. At runtime, DimOS runs each module in its own worker process, all talking over an internal message bus.
class CrowdMeter(Module):
# input port: auto-connects to the person-detector's output
detections: In[Detection2DArray]
@skill # exposes this method as a tool the AI agent may call
def how_many_people(self) -> str:
"""Report how many people the robot can currently see."""
Two details worth noticing: a module lives in a normal .py file (the module is the class, not the file), and a method tagged @skill becomes an ability the robot's AI agent is allowed to use — that's how the agent gets its powers.
3 · Blueprints — the plans that wire them together
A single module can't do much by itself. A real task — say, mapping a room — takes several modules running at the same time and talking to each other: the LiDAR driver, the mapping engine, and a few more. Getting the right set running, configured, and connected is exactly the kind of thing you don't want to do by hand.
DimOS solves this with blueprints, and they're exactly what the name says. Like the blueprint for a house, a blueprint is a finished plan: it lists every module a task needs, how each one is configured, and how they connect to each other. When you launch DimOS, you hand it a blueprint, and it builds everything on the plan — every module started, every connection made, with one command.
DimOS ships with ready-made blueprints for everything in this course. In Unit 2 you'll launch your first one (live 3D mapping), and by Unit 3 you'll be launching the full stack — camera, detection, navigation, and the AI agent — the same way: one blueprint, one command.
▸ For the curious — what a blueprint looks like in code optional
A blueprint is a Python object, conventionally defined in a .py file under a blueprints/ folder. Every module class has a .blueprint(…) method that produces a spec — "this module with this configuration" — without starting anything. autoconnect(…) bundles the specs together and wires the ports by name and type:
g1_agentic_nav = autoconnect(
FastLio2.blueprint(lidar_ip=...), # LiDAR + localization
VoxelGridMapper.blueprint(), # 3D map
ReplanningAStarPlanner.blueprint(), # path planning
Detection2DModule.blueprint(...), # person detection
...
)
Blueprints also compose — a big blueprint can include a whole smaller blueprint as one of its ingredients. The exported object is what dimos list shows and what dimos run <name> executes: DimOS reads the plan, spawns a worker process per module, connects every port, and starts them all.
4 · Where it runs — the computer inside the G1
Inside the G1, there's a real computer running Linux — and DimOS installs onto it just like any other software. That's worth letting sink in: the robot isn't some sealed appliance. It has an ordinary (if small and powerful) Linux computer in its torso, you log into it the same way you'd log into any Linux machine, and installing DimOS on it looks exactly like installing software anywhere else. That's precisely what Unit 1 is: log in, install.
▸ Good to know — the G1 actually has two computers optional
The computer you use is the dev computer — an NVIDIA Jetson that Unitree puts in the G1 EDU specifically for people to run their own software on. That's where DimOS lives, and it's the only computer you ever log into.
Next to it sits a sealed motion-control computer that runs Unitree's own balance and walking firmware. You can't (and shouldn't) touch it — DimOS sends it commands over the robot's internal network, and it handles the thousand-times-a-second work of not falling over. This split is also why DimOS can be bold: even while your software is being built and restarted, the thing keeping the robot upright never stops.
5 · What it unlocks
Once DimOS is running, the robot gains a whole range of new capabilities. These are the big three you'll build in this course:
None of this is pre-baked demo behavior — each capability is a set of modules you'll launch, watch run, and eventually extend.
6 · The road ahead
Everything you need to unlock DimOS on your own G1 is explained step by step across five units. Each unit ends with the robot visibly doing something new:
| Unit | What you do | What you end with |
|---|---|---|
| 1 — Install | Connect to the robot and install DimOS from scratch: Python, GPU support, the framework, and its navigation engine. | DimOS fully installed and verified on the robot |
| 2 — First launch | Launch your first blueprint and set up the live viewer on your computer. | A live 3D map of your room, building in real time |
| 3 — Camera & agent | Add the camera stream, then set up and command the AI agent. | A robot that takes plain-English commands |
| 4 — Navigation | Learn how the nav stack works, then map a space and send the robot walking to goals. | Autonomous point-to-point walking |
| 5 — Control panel | Install a full web cockpit, learn to debug the stack, and write your own module as a capstone. | The whole system on one screen — plus your first custom module |
- A Unitree G1 EDU — the variant with the onboard Jetson dev computer (that's where DimOS goes).
- Your computer (Windows, macOS, or Linux) and an Ethernet cable to reach the robot.
- The G1's remote controller — the robot must be standing and controllable for the later units.
- Wi-Fi with internet for the robot — the installs in Unit 1 download several GB.
- An OpenAI account with a small amount of credit — the AI agent in Unit 3 uses it.
Checkpoint
No commands this time — just make sure these feel true before moving on: