Microduck is the onboard software stack for a tiny biped duck robot: a 25 cm, 800 g machine that walks on neural network policies instead of hand written gaits. The repository, published by Pollen Robotics under Apache-2.0 and written mostly in Rust, is the duck's brain rather than its mechanical design. It is aimed at two groups: people who own (or plan to buy) the robot and want to run and modify its software, and robotics or reinforcement learning developers who would rather read a complete working simulation-to-hardware stack than another paper about one.
What it does
The README describes the robot as about 25 cm and 800 g, run by a handful of daemons on a Rockchip RK3566 board. Those daemons cover:
- a 50 Hz control loop that drives fifteen servos from neural policies
- the radios and the camera
- update machinery meant to get new software onto a robot without bricking it
On top of that sit the behaviours the project demonstrates in its own videos. The duck walks, and you drive it with a gamepad. Put wheels on it, ask for roller mode, and it loads a different policy and rolls instead of walking. Point its beak at the floor, press one button, and it picks things up. The much repeated party trick, knocking it over and watching it stand back up, is what the project's demo footage shows; there is no published benchmark of balance or walking speed in these materials, so treat all of it as the authors' demonstration rather than an independent measurement.
Two documentation entry points are worth knowing before you clone anything: a cheat sheet at docs/robot/cheatsheet.md and an architecture write-up at docs/design/architecture.md.
How it works
The policies are not trained in this repository. They come from a companion project, pollen-robotics/microduck_rl, which holds the MuJoCo simulation, the PPO training code, the sim2real recipe and the export step that turns a trained policy into an ONNX file. This repository is the consumer of those files: it loads them and runs them in the 50 Hz loop against the real servos.
That split explains the robot's mode switching. Walking and rolling are not two branches of one controller; each mode loads its own policy, which is why adding wheels changes the brain and not just the configuration. CI runs on GitHub Actions, and the project takes contributions through a CONTRIBUTING.md.
Getting started
The hard requirement comes first: you need the robot, or its simulator. The code is free under Apache-2.0, but the duck is a product that Pollen Robotics sells from its own site, and the repository does not state a price. The software budget is zero and there is no API key, no cloud account and no subscription anywhere in the loop, because the policies run on the board inside the robot. The money goes into hardware.
The target compute is the RK3566 inside the duck, plus a gamepad for driving and a set of wheels if you want roller mode. The repository does not list requirements for the machine you build on, so do not assume any particular host operating system; the cheat sheet and the architecture document are where the build and flash steps live, not a release download or an app store. The code itself is a plain clone from github.com/pollen-robotics/microduck, and training work belongs in the separate microduck_rl repository.
When to use it / when not
The catch is the one the channel's own script names: this is reinforcement learning you can hold in your hands, and you need the hands-on part to hold. Without the robot or its simulator, the repository is reading material.
Use it instead of a simulation-only MuJoCo project when you want to see what happens after the policy leaves the simulator, including the servo loop, the radios and the firmware update path that stops a bad flash from killing the robot. Those are the parts research code usually omits.
Don't use it if you have no Microduck and no intention of running the simulator, or if you are hoping to drop this stack onto a different legged robot. It is written for one specific body with fifteen servos and one specific board, so porting it is real work rather than configuration. It is also young: the repository was created in mid-2026 and is still being pushed to, so expect moving parts.
Microduck deserves attention from two kinds of reader. If you own the robot, this is simply where its software lives, and the cheat sheet plus architecture docs are the fastest route to modifying it. If you work on legged locomotion or sim2real transfer, the pairing of this repository with microduck_rl is more useful than either half alone: one side shows the MuJoCo and PPO training, the other shows the unglamorous production code that keeps a 800 g biped upright at 50 Hz. The 11,000-plus stars reflect the demo videos more than the code, but the code is the rarer thing here.