Microduck

// Overview

Microduck is the software that runs a Microduck robot — a roughly 25 cm, 800 g biped duck sold by Pollen Robotics, now part of Hugging Face, for $399. The repository is what the makers call the duck's brain: a set of Rust daemons on a Rockchip RK3566 board that close a 50 Hz control loop over fifteen servos, read the IMU and the depth sensor, stream the camera, talk to gamepads and phones, and install new software onto a robot without bricking it. The behaviours it ships — walking under gamepad control, rolling on wheels, picking an object off the floor, standing itself back up after a fall — are neural policies loaded as ONNX files, not hand-written gaits.

Those policies are trained next door in the companion repository microduck_rl, which holds the MuJoCo (mjlab) environments, the PPO recipe, the domain randomisation used to cross the sim-to-real gap, and the ONNX export step that this repository consumes. That split is the point: you can retrain a gait or add a new skill in simulation and drop the resulting file onto the robot, without touching the runtime that keeps the servos safe.

The runtime is one Rust workspace with no framework. `robotd` owns the control loop and the motor bus; `updaterd` installs signed releases and rolls them back when a robot comes up unhealthy; `configd` owns wifi and identity; `btd` is the Bluetooth path a phone uses; `padd` reads the gamepad; `mediad` streams the camera over WebRTC; `tofd` serves the depth sensor. They speak one JSON-RPC contract over Unix sockets, so the phone app, the console, the gamepad daemon and your own script all issue exactly the same calls. Everything is Apache-2.0, and the design notes explaining why each piece works the way it does ship in the repository alongside the code.

// What it does

• 50 Hz control loop over fifteen servos, driven by ONNX reinforcement-learning policies rather than scripted gaits
• Seven Rust daemons (robotd, updaterd, configd, btd, padd, mediad, tofd) behind a single JSON-RPC contract on Unix sockets
• Signed, health-gated updates that install, pin and roll back — a robot that comes up unhealthy reverts
• `robotctl` on the robot for version, health and a live monitor of commanded-vs-applied motion; `duckctl` drives the same robot from a laptop over Bluetooth with no network and no ssh
• Companion RL stack (microduck_rl) with MuJoCo/mjlab environments, PPO training, domain randomisation and ONNX export
• Camera over WebRTC, a time-of-flight depth sensor and gamepad pairing handled by dedicated daemons

// Getting started

This repository is the robot's software, so the walkthrough assumes a Microduck (or a dev board set up per docs/robot/install-dev.md). Every command below is from the project's own cheat sheet.

robotctl version

robotctl health
robotctl health --json

robotctl monitor

git clone https://github.com/pollen-robotics/microduck_rl.git

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

// When to use it

• Run and debug a Microduck: check daemon versions, gate scripts on `robotctl health`, and watch safety clamps act in real time
• Train a new gait or skill in MuJoCo with PPO and ship it to the robot as an ONNX policy
• Study a small, complete sim-to-real stack — control loop, motor bus, signed updates — written in plain Rust with the design decisions documented
• Build your own client against the robot's JSON-RPC contract instead of the shipped app

// How Microduck compares

Microduck alongside other open-source robot control stacks tools AI/TLDR tracks, ranked by GitHub stars.