Microduck

Pollen Robotics' $399 walking duck robot: open-source software, closed hardware

License

• software (pollen-robotics/microduck) and training code (microduck_rl): Apache 2.0
• 3D model files (microduck_rl STL meshes, also used by community replicas; credit Pollen Robotics): CC BY-NC-SA 4.0

Split licensing. Microduck's software and its training code are Apache-2.0. Since 9 Oct 2026 Pollen Robotics licenses the robot's 3D model files (the STL meshes in microduck_rl) under CC BY-NC-SA 4.0: non-commercial, with credit to Pollen Robotics, and shared changes keep the same licence. That also applies to replicas printed from those meshes. Pollen publishes no CAD, circuit boards or bill of materials for the robot itself. Checked 5 Nov 2026.

Overview

Microduck is a 25 cm, 800 g walking duck robot made by Pollen Robotics, part of Hugging Face, sold assembled for $399 before taxes and shipping and on pre-order from Pollen's store. Its software is open source and its hardware is not: this repository is the robot's onboard stack, a Rust workspace, Apache-2.0, that runs a 50 Hz control loop driving fifteen servos from neural network policies exported to ONNX. The repository holds everything a robot needs to run — robotd for the control loop and motor bus, updaterd for signed releases with health-gated rollback, configd for wifi and identity, btd for the Bluetooth path a phone uses, padd for the gamepad, mediad for WebRTC camera streaming and tofd for the depth sensor — all speaking one JSON-RPC contract over Unix sockets, so the app, the console, the gamepad and a user script all send the same calls. The locomotion and recovery policies are trained separately in microduck_rl with MuJoCo and PPO. The robot itself is sold by Pollen Robotics, a Hugging Face company.

The stack is deliberately plain: Rust, no framework, one Cargo workspace, and a set of small daemons that each own one thing. 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. Everything runs on a Rockchip RK3566, and every client talks to the same JSON-RPC contract on Unix sockets rather than through a private side channel. Behaviours arrive as policies rather than as code: walking, standing back up after a fall, rolling on wheels and picking an object off the floor with the beak are separate networks trained in microduck_rl under MuJoCo with PPO and domain randomisation, exported to ONNX and loaded by robotd. The design notes in docs/design are unusually candid, and docs/project records what has gone wrong and what would close it.

Why it matters

Small legged robots are usually sold with a closed firmware blob, so the interesting part — how a policy actually reaches fifteen servos at 50 Hz on a low-cost SoC, and how you ship an update to a robot without bricking it — stays hidden. Microduck publishes that whole layer under Apache-2.0, including the update machinery, the IPC contract and the sim-to-real pipeline next door in microduck_rl. For anyone building a small RL-driven biped it is a complete, working reference rather than a demo, and at $399 the hardware to run it against is within reach of a classroom.

Problem it solves

Low-cost legged robots ship with closed firmware, so the layer between a trained policy and the servos — real-time control, IPC, media, and safe over-the-air updates — is the part nobody outside the vendor gets to read. Microduck opens exactly that layer for a robot people can buy.

Key takeaways

• Complete onboard stack for a 25 cm, 800 g biped: 50 Hz control loop driving fifteen servos from ONNX policies on a Rockchip RK3566
• Rust workspace of single-purpose daemons — robotd, updaterd, configd, btd, padd, mediad, tofd — over one JSON-RPC contract on Unix sockets
• Signed, health-gated updates that roll themselves back when a robot comes up unhealthy
• Behaviours are trained policies, not scripts: walking, self-righting, wheeled rolling and beak-to-floor pickup
• Policies come from microduck_rl — MuJoCo, PPO and domain randomisation, exported to ONNX
• Apache-2.0, with design decisions and open problems written down in docs/design and docs/project

Who it is for

• Engineers building RL-driven legged robots on embedded Linux
• Sim-to-real researchers who want a cheap physical target for MuJoCo-trained policies
• Educators teaching robot software architecture with hardware students can afford
• Microduck owners writing their own behaviours against the JSON-RPC API

Limitations

• The software is open but the hardware is not: Pollen publishes no CAD or bill of materials, and the STL meshes in microduck_rl are under a non-commercial licence, so the robot is meant to be bought rather than built
• The stack targets one board and one robot — Rockchip RK3566 and the Microduck servo bus — rather than being a general framework
• The repository is the robot's brain only; the training pipeline and the sim2real recipe live separately in microduck_rl
• Young project: the repository was created in July 2026 and the daemons, IPC contract and update path are still moving
• GStreamer plugins for the Rockchip hardware encoder come from a separate prebuilt aarch64 repository rather than being built in-tree
• Since daemon version 0.18.3 the robot sends anonymous usage data to PostHog EU, on by default: daemon start, update results, a daily heartbeat and which public policies are loaded, under a random robot id. It can be turned off; upstream's telemetry page says how.