If you have ever watched a humanoid robot take its first careful steps and wondered what it would take to build one yourself, the open source biped robot duck called Microduck is the most honest answer the open-source world has produced so far. It is 25 centimetres tall, weighs about 800 grams, and it does not walk because someone hand-coded a gait for it. It walks because neural policies trained in a physics simulator were exported and loaded onto a small board inside its body. This post is a deep dive into the Microduck repository from Pollen Robotics: what it is, what it can actually do, how it works under the shell, and what it means for teams that build with AI rather than just reading about it.
What Microduck is, and why it is not a toy
Microduck comes from Pollen Robotics, the Bordeaux robotics team that sits inside Hugging Face after its acquisition in 2025. The project describes its repository in one line: this repo is the duck’s brain. That framing matters, because the repository does not contain a toy remote-control script. It contains the full software stack that runs on the robot: a 50 Hz control loop driving fifteen servos from neural policies, the radios and the camera, and the update machinery that gets new software onto a robot without bricking it.
The hardware is deliberately modest. A Rockchip RK3566 board runs the show, which is a useful reality check for anyone who assumes embodied AI needs a data-centre GPU on board. The robot is about 25 cm tall and 800 g, with fifteen servos across its legs, neck and head, plus an articulated beak. Reported specifications add a front camera, an 8×8 time-of-flight depth matrix, inertial sensors, microphones, a speaker, Wi-Fi and Bluetooth, and a removable battery rated for roughly an hour of operation. None of that is exotic hardware. The interesting part is the software that makes cheap hardware move like it understands its own body.
The project also has a commercial side that explains why it is trending. Pre-orders opened in late August 2026 at a $399 introductory price, with first units targeted to ship before Christmas 2026 in North America, Europe and the UK. Coverage in late October 2026 put the repository at roughly 11,000 GitHub stars with more than 1,400 forks, and reported pre-orders of around 20,000 units, a figure that comes from an executive social post rather than audited sales, so treat it as a signal of demand, not a verified sales number. The $399 figure is likewise labelled introductory, which means later buyers may pay more.
What the open source biped robot duck can actually do
The repository’s own demo list reads like a toy catalogue and a robotics benchmark at the same time. Pick up a gamepad and drive it. Put wheels on, ask for roller mode, and it loads a different policy and rolls. Press one button and it lowers its beak to the floor and picks something up. Knock it over and it stands itself back up. It also sits, kicks a ball, rolls forward on command, and quacks in a voice that the project says is generated on first wake and kept permanently for that unit.
Two of those behaviours deserve more attention than the rest. The first is self-righting. Getting back up after a fall is a learned skill here, not a scripted animation, which means the policy has to cope with the messy reality of a body on the floor at an arbitrary angle. The second is the roller mode. Switching from legs to wheels is not a cosmetic change: the robot loads a different trained policy, which shows that the architecture treats behaviours as swappable brains rather than one monolithic controller. That is exactly the design that makes a platform worth building on, because a new behaviour is a new policy, not a rewrite of the robot.
- Walk: gamepad-driven locomotion from a trained reinforcement learning policy.
- Roll: a separate roller-mode policy when wheels are fitted.
- Grab: beak-to-floor pickup on a single button press.
- Recover: learned self-righting after a fall.
- Play: sit, kick a ball, roll forward, and quack in its own generated voice.
How it works: policies trained in simulation, run on a small board
The walking skills are not programmed joint by joint. They are trained next door, in the companion microduck_rl repository, using the MuJoCo physics simulator and PPO, a widely used reinforcement learning algorithm. Training uses domain randomisation, which means the simulator deliberately varies physical properties so the learned policy does not overfit to one perfect virtual world. The trained policies are exported to ONNX, and the robot’s control stack loads those ONNX models at run time. This is the sim2real pipeline in its most concrete form: learn in simulation, then run the same policy on real servos.
On the robot itself, the stack is written in Rust, with no heavy framework, as a single workspace of cooperating daemons. The split is worth studying, because it is the kind of architecture that survives contact with real hardware. 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 Wi-Fi and identity. btd is the Bluetooth path a phone uses, padd reads the gamepad, mediad streams the camera over WebRTC, and tofd serves the depth sensor. They talk over one JSON-RPC contract on Unix sockets, and every client, whether it is the app, the console, the gamepad or your script, sends exactly the same calls.
Two design decisions stand out for anyone who has shipped software to devices. First, updates are verified, health-gated and reversible: if a new release leaves the robot unhealthy, the updater rolls back instead of leaving a bricked duck on a customer’s desk. Second, there is a simulator path for developers who do not own the hardware. The scripts/duck-sim tool runs the real daemons against a simulated body in MuJoCo, so you can develop against the same software that ships, with one duck in a window or several as machines you log into. That is a far stronger development story than a toy SDK with a fake API.
Why it is trending now
Microduck arrived at the exact moment three trends collided. Reinforcement learning for locomotion stopped being a research demo and started being a shippable technique. Hugging Face’s acquisition of Pollen Robotics gave a small French robotics team a distribution channel that reaches millions of developers. And the price, $399, put a trainable biped within reach of university labs, maker spaces, schools and curious engineering teams that could never justify a five-figure humanoid.
There is also a timing story. Pollen’s previous robot, the stationary Reachy Mini, shipped more than 10,000 units as a desk companion. Microduck reverses that premise: it is built to leave the desk, fall over, and get back up. Add a high-profile showcase at GTC Berlin in October 2026, where the robots were presented as an example of training on accessible hardware, and you get a project that is simultaneously a product launch, a teaching platform and a reference design. The star count reflects all three audiences at once, which is why it climbed so fast from its July 2026 debut.
From our experience: what this stack teaches builders
At MTD Technologies, we have spent 9+ years and 300+ projects learning that the difference between a demo and a product is almost never the model. It is the plumbing around the model: updates, rollback, observability, and a development loop that does not require the physical device. Microduck gets this right in ways most open-source robotics projects do not. The daemon split means a broken camera streamer cannot take down the control loop. The signed, health-gated updater means a bad release is a bad afternoon, not a recall. The JSON-RPC contract means every client speaks the same language, so adding a new control surface is a client, not a fork.
That said, honest limitations matter, and this project has them. Bipedal walking is inherently fragile, and a sim2real gap always remains, however good the domain randomisation is. A 25 cm robot with roughly an hour of battery is a teaching and prototyping platform, not a household worker, and anyone pitching it as the latter is selling a story, not a specification. The software is also a moving target: architecture documents in the repository are marked as drafts describing a first shipped version, not a finished system, so teams building on it should pin versions and expect breaking changes. And the camera and microphone on a robot that roams a home deserve real scrutiny. Open code lets developers audit what the duck does with what it sees, but most buyers will never read that code, which puts the burden on the vendor’s defaults, not the licence.
For business teams, the practical takeaway is narrower and more useful than the hype. If you are exploring embodied AI, robot-assisted training, or agent-controlled hardware, Microduck is the cheapest credible way to put a sim2real loop in your team’s hands. If you need a reliable machine for a production job today, it is not that, and no honest review should pretend otherwise. The right question is not whether a duck robot will replace your workforce. It is whether your team can learn the sim2real pipeline on a $399 platform before your competitors learn it on a $50,000 one.
A responsible-use note
Microduck is a general-purpose robotics platform, and general-purpose platforms can be pointed at purposes their creators never intended. The repository itself is a control stack, not a weapon, but the same ingredients, cheap biped hardware, open training code, camera and depth sensing, and gamepad or scripted control, could be adapted for surveillance or for pranks that cross into harassment if a camera-equipped robot is driven where it has no business being. Keep it in your own space, get consent before recording people, and do not deploy a modified duck in public or workplace settings without checking the rules that apply there. The open licence gives you freedom. It does not remove responsibility.
Getting started with Microduck
- Read the brain first. Start with the Microduck repository README, then the architecture document under
docs/design/, which explains the daemon split and the update system before you touch any code. - Try the simulator. Use
scripts/duck-simto run the real daemons against a simulated body in MuJoCo. No hardware on the desk is needed, and you learn the same control surface the physical robot uses. - Learn the control commands. The robot cheat sheet documents every
robotctlcommand: drive, configure, voice, Wi-Fi, updates and logs. Theduckctltool covers control from a laptop over Bluetooth with no network and no SSH. - Study the training repo. In
microduck_rl, work through the MuJoCo environments, the PPO setup, the domain randomisation settings and the ONNX export, because that is where new behaviours actually come from. - Train one small behaviour. Modify a reward or a randomisation range, retrain, export to ONNX, and load the policy. A small, verifiable change teaches more about sim2real than reading ten blog posts.
- Decide on hardware. If the simulator convinces you, check the official Microduck page for current pricing, colours and shipping regions before ordering, since the introductory price and regional availability are both subject to change.
Frequently asked questions
What is Microduck?
Microduck is a 25 cm, 800 g open-source biped robot duck from Pollen Robotics. Its GitHub repository contains the Rust control stack that runs on the robot, including the 50 Hz control loop, the daemon architecture and the update system, while a companion repository holds the reinforcement learning training code.
How does Microduck learn to walk?
It does not use a hand-written gait. Behaviours are neural policies trained with reinforcement learning in the MuJoCo simulator, using PPO and domain randomisation, then exported to ONNX and loaded onto the robot. The same pipeline produces the walking, rolling, grabbing and self-righting behaviours.
How much does Microduck cost?
Pre-orders opened in August 2026 at a $399 introductory price, with first units targeted to ship before Christmas 2026 in North America, Europe and the UK. The price is labelled introductory, so later pricing may differ, and availability in other regions has not been dated.
Do I need the physical robot to develop for Microduck?
No. The repository includes a simulator that runs the real daemons against a simulated body in MuJoCo, so you can build and test against the same software that ships on the hardware, with no robot on your desk.
What licence is Microduck released under?
The repository is released under the Apache 2.0 licence, which allows use, modification and commercial building on the code, subject to the licence terms. Check the LICENCE file in the repository for the exact conditions before shipping a product based on it.
Microduck is a small robot with an outsized lesson: embodied AI stopped being a research luxury the moment a $399 duck could learn to walk in simulation and then actually walk. Whether you buy one, simulate one, or simply study the repository, the architecture, the sim2real pipeline and the update discipline are worth your team’s time. If you are exploring AI-powered products, robotics prototypes, or agent-controlled hardware, talk to MTD Technologies about AI integration, browse our AI Tools Directory for more tools we have reviewed, or contact us to scope a prototype. The duck falls over. The point is that it gets back up, and so should your next experiment.