spiral@out:~/blog$ cat transmissions/microduck.md

Microduck: A Robot Duck That Learned to Walk

[2026-10-24] ::robotics, hardware, rust, reinforcement-learning, maker

Microduck is a tiny biped robot from Pollen Robotics: about 25 cm tall, 800 g, shaped like a duck, and it walks using neural network policies trained in simulation. The repo describes itself as "the duck's brain," meaning all the software that runs on the robot.

It's on GitHub Trending today with about 10,800 stars, and the software is licensed under Apache-2.0.

What it does

The README lists the tricks:

  • It walks. Pick up a gamepad and drive it around.
  • It rolls. Put wheels on, ask for roller mode, and it loads a different policy.
  • It picks things up. Beak to the floor, one button.
  • It gets back up. Knock it over and it stands itself up.

It also sits, kicks a ball, and quacks "in a voice that is its own." The command-line cheat sheet even lists "chorale" and "theremin" commands, which tells you something about the people who built it.

How it works

The movement comes from reinforcement learning. Instead of hand-coding each joint for a walking gait, Pollen trains policies in the MuJoCo physics simulator with PPO, a standard RL algorithm. It uses domain randomisation, meaning the simulated physics is varied during training so the policy holds up against the messiness of a real robot. The trained policy is then exported to ONNX and loaded onto the duck. That training pipeline lives in a sister repo, microduck_rl.

On the robot itself, a Rockchip RK3566 runs a 50 Hz control loop that drives fifteen servos from those policies. The software is written in Rust, with no framework, as a set of small daemons, each owning one job:

  • robotd owns the control loop and the motor bus.
  • updaterd installs signed releases and rolls them back if the robot comes up unhealthy.
  • configd handles wifi and identity, btd is the Bluetooth path a phone uses, and padd reads the gamepad.
  • mediad streams the camera over WebRTC, and tofd serves the depth sensor.

They all speak one JSON-RPC contract over Unix sockets. The phone app, the console, the gamepad and your own scripts all send exactly the same calls, so anything the app can do, a script can too.

The update system deserves a mention. The README says every update is "verified, health-gated and reversible," which is exactly what you want from a small robot that would otherwise be one bad firmware flash away from a paperweight.

Trying it

The robot itself is sold through Pollen's Microduck page. If you have one, robotctl is the main tool, and the cheat sheet in the repo covers driving, configuration, voice, wifi, updates and logs. There's also duckctl, which drives the robot from a laptop over Bluetooth, with no network or ssh needed.

You don't need a duck to start, though. The repo includes a simulated duck that runs the real robot daemons against a body in MuJoCo:

scripts/duck-sim

It runs either one duck in a window or four as separate machines you can log into. That's a neat way to hack on the software, or just to see how a real robot stack is put together. The docs also cover setting up a dev board from scratch and pushing your own branch builds to a robot in about a minute.

The fine print

  • This repo is the software. It's the brain, not a parts list, and the hardware comes from Pollen. The simulator lets you work on the code without buying anything.
  • Training lives elsewhere. If you want to teach the duck new moves, you'll be working in microduck_rl with MuJoCo and PPO. That means real compute and some reinforcement learning background.
  • It's honest about its rough edges. The repo keeps a docs/project/ folder of "what has gone wrong and what would close it," alongside design notes explaining why things are the way they are. That's rare and useful.

Who it's for

Microduck is for robotics tinkerers, anyone curious how sim-to-real reinforcement learning works in practice, Rust developers who want to see a clean embedded daemon architecture, and frankly anyone who has wanted a small robot duck that gets back up when you knock it over. Even if you never buy one, the design docs and the simulator make it one of the more approachable real robot codebases out there.

The GitHub repo and the Microduck page are the places to start, and it's in the resource index now.

End of transmission.

<- BACK TO LOG