中文 · Live simulator · Roadmap (中文)
OpenDoge (OpenDog V1.1) is a fully open-source 12-DoF quadruped robot. SolidWorks structure, URDF/MJCF description, mjlab reinforcement learning, ONNX policy export, a ROS-free C++ deployment runtime, and a browser simulator — the whole chain lives in this project.
The goal is not a one-off demo, but a reproducible, replaceable, and continuously improvable path from "build one" to "train one" to "make it walk".
- 12 DoF, ~4.6 kg: 4 legs × 3 joints, 409 SolidWorks part files; suitable for both 3D printing and CNC.
- Training mainline on mjlab: MuJoCo-Warp + RSL-RL PPO with no Isaac Gym dependency; flat, rough, get-up, handstand, jump, and multi-skill tasks ship with playable baselines.
- One shared contract: a 48-D proprioceptive core, 12-D action,
Kp=12, andaction_scale=0.25; policies do not need an interface swap between simulation and hardware. - ROS-free deployment: a single C++ process owns ONNX inference, four SocketCAN buses, EL05 control frames, and safety damping; CAN/IMU/gamepad are managed by systemd.
- Runs in a browser: MuJoCo WASM + ONNX Runtime Web, zero install.
OpenDoge_hardware OpenDoge_description
CAD · STEP · 3MF ───► URDF · MJCF · STL
│
▼
OpenDoge_train (mjlab)
PPO · curriculum · domain randomization · baselines
│
opendoge-export → ONNX
│
┌────────────────┴────────────────┐
▼ ▼
OpenDoge_deploy (C++) OpenDogeRobotics.github.io
ONNX CPU · 4×CAN · damping MuJoCo WASM · ORT Web
│
▼
OpenDoge V1.1 hardware
OpenDoge_origin is the project entry point: it owns the overview, module navigation, and cross-repository contract. Implementations evolve in their own repositories.
| Repository | Role | Key contents |
|---|---|---|
| OpenDoge_origin (this repo) | Project overview and docs | README, roadmap, cross-repo contract |
| OpenDoge_hardware | Mechanical and component data | V1.1 CAD/STEP/3MF, EL05 / DM-IMU / CHIWU / Orange Pi 5 material |
| OpenDoge_description | Robot description package | URDF, STL, RViz/Gazebo launch files, MuJoCo MJCF |
| OpenDoge_train | Training, validation, export | mjlab 1.6, six OpenDoge tasks, baselines, Viser, ONNX export |
| OpenDoge_deploy | Real-robot runtime | C++17, ONNX Runtime, 4×CAN, systemd, sim2sim, web console |
| OpenDogeRobotics.github.io | Browser simulator | MuJoCo WASM, ONNX Runtime Web, terrain editor |
| Item | Value |
|---|---|
| Model | OpenDoge / OpenDog V1.1 |
| Configuration | 12 DoF: 4 legs × (hip / thigh / calf), fixed feet |
| Mass | ≈4.6 kg (V1.1 MJCF model) |
| Standing height | ≈0.16 m |
| Actuation | 12× EL05 (RobStride) 6 N·m; 1.5:1 calf reduction, 9 N·m at the joint |
| Onboard compute | Orange Pi 5 (RK3588S) |
| Attitude sensing | DM-IMU-L1 over a USB virtual serial port |
| CAN | CHIWU 4×CAN, native SocketCAN, classic CAN at 1 Mbps |
| Remote control | Xbox-compatible 2.4G gamepad |
| Structure | 3D printed (PLA/PETG/nylon) or CNC aluminum; TPU/rubber feet |
| Layer | Technology |
|---|---|
| Mechanical | SolidWorks, STEP / 3MF |
| Description | URDF, MJCF, STL, ROS 1 catkin |
| Training | mjlab 1.6.0 (MuJoCo-Warp), RSL-RL PPO, PyTorch, uv |
| Validation/playback | MuJoCo, Viser, opendoge-eval |
| Export | ONNX |
| Deployment | C++17, ONNX Runtime, SocketCAN, systemd |
| Hardware | EL05, DM-IMU-L1, CHIWU 4×CAN, Orange Pi 5 |
| Front end | MuJoCo WASM, ONNX Runtime Web, Three.js, Vite |
- Model it:
OpenDoge_descriptionprovides the general URDF/STL; the training repository ships its own V1.1 MJCF and STL assets. - Train it:
OpenDoge_trainruns PPO on mjlab, replays withplay/ Viser, and exports ONNX withopendoge-export. - Verify the loop:
OpenDoge_deploy/sim2simreproduces the C++ control loop in MuJoCo — the last gate before hardware. - Deploy it:
opendoge_deployruns ONNX at 100 Hz, holds targets at 200 Hz, and drives 12 EL05 motors over CAN. - Show it: the same ONNX file can be loaded into the browser simulator for demos or quick policy comparisons.
Cross-repository contract:
| Item | Convention |
|---|---|
| Shared observation | 48-D: base_lin_vel(3) + base_ang_vel(3) + projected_gravity(3) + joint_pos_rel(12) + joint_vel_rel(12) + last_action(12) + command(3) |
| Action | 12-D; target = default_pos + 0.25 × action, with per-joint sign mapping |
| Default pose | Firmware convention (hip 0, thigh 0.8, calf -1.6); training mirrors it through joint signs |
| PD | Kp=12; Kd=0.5 for training/simulation, 0.8 on the current robot to suppress vibration |
| Rates | Policy 100 Hz → targets 200 Hz → CAN loop at 200 Hz (current hardware setting; higher rates need CAN timing validation) |
| Policy network | MLP 48→512→256→128→12 (ELU), normalization embedded in ONNX |
| Linear velocity | No state estimator on the robot: lin_vel_source=zero / command / imu |
| Compatibility | The 48-D runtime is incompatible with legacy 49-D policies |
Observation size grows per task: Rough adds a 165-D height scan on top of the 48-D base (213-D); Skills adds a 3-D jump command, a 4-D skill one-hot, and a 2-D phase (57-D); the Jump task alone uses 51-D.
Open https://opendogerobotics.github.io/, pick a policy, and drive it with WASD / QE or the virtual joystick. The page also includes a terrain editor and drag-to-push disturbances.
cd OpenDoge_train
uv sync --extra cu128 # use --extra cpu for CPU-only config checks
uv run list-envs
# Train flat-ground velocity tracking
uv run train LainLab-OpenDoge-Flat --env.scene.num-envs 4096
# Replay a bundled baseline
uv run baseline-play opendoge flat --device cuda:0 --num-envs 1
# Export ONNX
uv run opendoge-export LainLab-OpenDoge-Flat --checkpoint <ckpt> --output policy.onnxPython 3.10–3.13 is required. Training needs an NVIDIA GPU; CPU is only for configuration checks and smoke tests.
cd OpenDoge_deploy
./scripts/setup_onnx.sh
export ONNXRUNTIME_ROOT=$(realpath build/deps/onnxruntime)
colcon build --symlink-install --packages-select opendoge_deploy
source install/setup.bash
bash scripts/install_services.sh # install CAN / IMU / gamepad systemd services
./scripts/start_robot.sh verify # check can0-3, IMU, gamepad
./scripts/start_robot.sh dry # hardware-free dry run
./scripts/start_robot.sh damping # real-robot damping / safe hold
POLICY_PATH=policy/opendoge_flat.onnx ./scripts/start_robot.sh policy
⚠️ This is real hardware, not a simulation. On the first power-up, followdry → damping → low-gain → policy, with the robot suspended or lifted off the ground; verify the E-stop, joint limits, torque limits, and CAN watchdog before any ground test. Before running on hardware, check every joint'sdirection,offset,lower, andupperindeploy/configs/opendoge_deploy.conf.
The V1.1 SolidWorks assembly, parts, and 3MF live in OpenDoge_hardware/mechanical/V1.1/. The description package provides URDF, STL, and RViz/Gazebo launch files; the model can also be imported into MuJoCo, Isaac Gym, and other simulators.
Single source of truth for the mechanical structure and purchased components. V1.1 (2026-09) is current; V1.0 is superseded and kept in git history.
- 409
.SLDPRTparts and theOpenDog.SLDASMassembly base.STEP,base.3mf, plus CHIWU PCB, Orange Pi 5, and IMU STEP/model filesdatasheets/: EL05 manual, DM-IMU-L1 manual/firmware/examples, CHIWU schematic, Orange Pi 5 material- 12-DoF layout; parts can be 3D printed or CNC machined; TPU/rubber feet recommended
ROS 1 (catkin) description package under URDF/:
Opendoge.urdf+ 17 STL meshes + a joint/link mapping CSVdisplay.launch(RViz) andgazebo.launchxml/Opendoge.xmlandscene.xml(MuJoCo MJCF)- 12 actuated joints named
FL/FR/RL/RR_{hip,thigh,calf}_joint; feet are fixed links
The training side maintains the V1.1 MJCF; the deployment repository carries its own URDF copy for hardware-parameter checks. The description package itself is BSD-licensed.
The training, validation, and export repository; default branch mjlab:
- Built on mjlab 1.6.0 (MuJoCo-Warp) + RSL-RL PPO, with no Isaac Gym dependency
- The framework version is pinned; the repo only owns OpenDoge assets, task differences, validation contracts, and deployment adapters
- The
isaacgymbranch keeps the original Isaac Gym + HIMLoco stack for reproducing historical results and comparison
| Task ID | Capability | Actor observation |
|---|---|---|
LainLab-OpenDoge-Flat |
Flat-ground velocity tracking | 48 |
LainLab-OpenDoge-Rough |
Rough-terrain velocity tracking | 213 |
LainLab-OpenDoge-Getup |
Flat-ground fall recovery | 48 |
LainLab-OpenDoge-Handstand |
Front-leg handstand | 48 |
LainLab-OpenDoge-Jump |
In-place jump | 51 |
LainLab-OpenDoge-Skills-Flat |
walk / handstand / getup / jump in one policy | 57 |
The
LainLab-prefix is historical. It is kept for compatibility with published baselines and checkpoints.
Bundled baselines live in src/baseline/opendoge/{flat,rough,getup,skills}/, each with baseline.json, model.pt, and policy.onnx. The repository also ships a standalone workbench (src-workbench: model viewer, policy selection, training, ONNX export, Viser playback) and an offline toolchain (calibration, collection, BC, DAgger, export). The mjlab branch does not include real-robot deployment code; exported ONNX goes to OpenDoge_deploy.
A ROS-free C++ real-robot runtime. The ROS / ros2_control path has been removed so that controller managers, topic queues, and executors do not add coupling to the hardware path.
opendoge_deploy (single process)
→ ONNX CPU inference @ 100 Hz
→ target position hold @ 200 Hz
→ EL05 q/dq/tau/kp/kd frames @ control rate (currently 200 Hz)
→ SocketCAN can0 / can1 / can2 / can3
→ CHIWU 4×CAN adapter
→ 12× EL05 (one leg per CAN bus)
Each CAN bus carries one leg, and the 12-D ONNX output maps 1:1 to motor IDs:
| CAN | Leg | Motor IDs (hip / thigh / calf) |
|---|---|---|
| can0 | Front-left FL | 1 / 2 / 3 |
| can1 | Front-right FR | 4 / 5 / 6 |
| can2 | Rear-left RL | 7 / 8 / 9 |
| can3 | Rear-right RR | 10 / 11 / 12 |
- Inputs:
command.statefrom the gamepad andimu.statefrom the IMU, maintained by systemd daemons; files can also be injected for dry runs - Safety: automatic damping on motor fault, over-temperature, feedback timeout, CAN error, or E-stop; position ramps, startup deviation checks, and a CAN watchdog
- Policy: defaults to
policy/opendoge_flat.onnx(48-D); the legacy 49-Dopendoge_r5.onnxis no longer compatible - Validation:
sim2sim/deploy_mujoco.pyreproduces the C++ control loop;test/contains regression and hardware-timing tests - Tooling: optional web console in
web_tools/;start_robot.shsupportsdry,damping,policy,low-gain,calibrate, andverify
An in-browser policy simulator, fully static, deployable to GitHub Pages:
- MuJoCo (WebAssembly) runs physics, ONNX Runtime Web evaluates policies, Three.js renders
- Includes flat velocity, rough terrain, get-up, and multi-skill (walk / handstand / getup) policies
- Joystick/keyboard commands, terrain editor, external push disturbances, and live monitoring
- Observation and action pipelines mirror the mjlab training configuration; a Python reference implementation ships with the repo
It is a demo and quick-comparison tool, not a training acceptance criterion; formal evaluation stays in the OpenDoge_train MuJoCo/Viser workflow.
As of November 2026:
| Module | Status |
|---|---|
| Mechanical V1.1 | ✅ 409 parts, assembly, STEP/3MF, component data |
| Robot description | ✅ URDF/STL/MJCF/ROS 1 package |
| Training mainline | ✅ mjlab 1.6, six tasks, four baselines, workbench |
| Sim2Sim | ✅ C++ control loop reproduced |
| Deployment runtime | ✅ 48-D contract, safety state machine, systemd, web console |
| Hardware bring-up | ✅ CAN / 12 motors / IMU / gamepad; zero and direction calibration |
| Real-robot walking | 🟡 PD standing works; RL walking still being tuned |
| Browser simulator | ✅ Live |
| BOM / assembly docs | ⬜ In progress |
Hardware bring-up is complete for CAN, all 12 EL05 motors, the DM-IMU-L1, and the gamepad, including zero and direction calibration; PD standing holds. RL walking is still being tuned for high-frequency oscillation, CAN feedback timing, and IMU noise. The symptoms, root causes, and fixes are recorded in the deployment repository's hardware logs.
- V1.1 mechanical structure and component data
- 12-DoF URDF/STL/MJCF with RViz/Gazebo support
- mjlab mainline: velocity, get-up, handstand, jump, multi-skill
- Four directly playable OpenDoge baselines
- MuJoCo Sim2Sim deployment-loop validation
- ROS-free C++ runtime and safety state machine
- 48-D training/deployment contract migration
- Browser MuJoCo + ONNX simulator
- Stable real-robot walking and velocity tracking
- Real-robot get-up / handstand / jump
- Gait library (trot / walk / bound / pace) with switching
- Stairs, slopes, and uneven terrain
- Vision/state estimation and autonomous navigation
- Complete BOM, assembly guide, and v1.0 release
Twelve EL05 motors can deliver 6–9 N·m at the joint, enough to break a 3D-printed structure. Treat the following as mandatory:
- Run
dry, thendamping, thenlow-gainwhile suspended or lifted, and only thenpolicy. - Before power-up, confirm the E-stop works, joint and torque limits are configured, and the CAN watchdog is enabled.
- After changing
direction,offset, or the reduction ratio, test one motor, then one leg, then the whole robot. - Never put an unvalidated policy on the ground; standing in simulation does not mean standing on hardware.
| Document | Contents |
|---|---|
| Hardware README | CAD, component data, manufacturing notes |
| Description README | URDF structure, joint naming, RViz/Gazebo usage |
| Training README | mjlab install, tasks, baselines, workbench, multi-skill |
| Deployment README | Build, run, configuration, safety |
| Bring-up and debugging guide | Bring-up sequence, calibration, troubleshooting |
| Hardware issue and change log | Real failures, root causes, itemized fixes |
| 48-D contract migration | 49→48-D, sign mapping, gains, action scale |
| Multi-skill design | Observation layout, training, acceptance |
| Workbench docs | Module boundaries and front-end development |
| Simulator README | Policy integration and reference implementation |
OpenDoge builds on a large body of open-source work:
- mjlab — MuJoCo-Warp training framework
- RSL-RL — PPO implementation foundation
- HIMLoco — training stack behind the
isaacgymbranch - unitree_rl_mjlab — project organization and task split reference
- MuJoCo, ONNX Runtime, Three.js, and the ROS / Gazebo communities
Thanks also to every open-source project that makes quadrupeds cheaper and more open.
Each sub-repository is licensed independently: OpenDoge_train, OpenDoge_deploy, and OpenDogeRobotics.github.io use Apache-2.0; OpenDoge_description uses BSD. For hardware CAD, read the corresponding repository's terms first. When reusing project content, follow the license of the source repository.

