A two-legged walking robot used to be something only research labs could afford.
Hugging Face just launched one for $399. 🦆
It's called Microduck, built by Pollen Robotics, the robotics team at Hugging Face. It's 25 cm tall, and it's made for one thing: helping people learn how robots are trained in a simulator and then work in the real world.
What caught my attention isn't the robot itself. It's how you teach it. You train a new move on an Nvidia GPU, even a regular GeForce RTX card at home, load it onto the duck, and publish it on Hugging Face so anyone can install it.
I went through Pollen's launch post, the official GitHub repo, and Nvidia's updates. Here's the full breakdown.
What is Microduck?
Microduck is Pollen Robotics' second robot. Their first, Reachy Mini, has sold over 10,000 units. The two are built for different jobs:
| Reachy Mini | Microduck | |
|---|---|---|
| Type | AI that interacts | AI that acts |
| What it does | Stays on the desk, sees, listens, and talks | Walks, falls, and gets back up |
Out of the box, Microduck can walk, sit, crouch, kick, grab small objects, roller-skate (with the optional wheeled feet), and get back up after a fall.
What's inside the duck
| Part | Spec |
|---|---|
| 🧠 Brain | Rockchip RK3566 with AI support, 1 GB RAM, 32 GB storage |
| ⚙️ Motors | 15, across the legs, head, neck, and beak |
| 👁️ Sensors | Camera + depth sensor, plus two balance sensors (body and head) |
| 🦆 Beak | Lifts about 100 g, enough for a sock or a pen |
| 🔋 Battery | About 1 hour, removable so you can swap and keep going |
| 📏 Size | 25 cm tall, under 800 g |
It comes in four colours: Cream, Sky, Lavender, and Graphite.
How it learns: by falling. A lot.
Microduck learns through reinforcement learning. The robot tries a move, gets a score for how well it did, and improves over thousands of attempts.
The trick is that it doesn't do this in the real world. It practises in a simulator:
- 4,096 virtual ducks train at the same time on a single GPU
- A walk that works on the real robot takes about 1 to 2 hours to train
- Training runs in MuJoCo Warp, a physics simulator built on Nvidia's Warp
The simulator also models the messy parts of real hardware, like motor behaviour, battery voltage drops, and small gear wobble. That's why moves trained in simulation still hold up when they reach the real robot. This is called sim-to-real, and it's one of the hardest problems in robotics.
Where Nvidia RTX fits in
The duck runs on its own small chip. The training runs on Nvidia.
- Training needs an Nvidia GPU. It uses CUDA, so a regular GeForce RTX card in your PC can do the job.
- Why Nvidia? The simulator runs on Nvidia's Warp, which uses the GPU to run thousands of simulations side by side.
- Built with RTX Spark. At GTC Berlin, Jensen Huang brought Microducks on stage. RTX Spark ran the AI agents that set up the simulation and tested the moves before they reached the real robots.
- No Nvidia GPU? One command sends the training to Hugging Face's cloud instead.
How it runs on the robot
Once a move is trained, the duck runs it on its own. No PC needed.
It runs a simple loop 50 times every second:
Sensors (camera, depth, balance) → Trained move (decides what's next) → Motors (legs, head, beak move)
A few details I liked:
- Each trained move is saved as a small ONNX model file
- The robot's software is written in Rust
- Every move reads the same sensor inputs, so the duck can switch from walking to a trick to getting up at any moment
The workflow: Train. Share. Install.
This is the part that makes Microduck different:
- Train: teach a new move in the simulator on your GPU
- Test: try it on the real robot and fix what doesn't match
- Publish: share it on the Hugging Face Hub with one command
- Install: anyone with a Microduck adds it with one command
It's like sharing AI models on Hugging Face, but for robot moves.
What's open, and what isn't
"Open source" here has a clear scope:
- ✅ Open (Apache 2.0): robot software, simulator setup, and all training tools, free on GitHub
- ⚠️ Shared with limits: 3D model files, for non-commercial use only
- ❌ Not open: the full mechanical and electronic design files
In short: open software on closed hardware. The training repo already has 2,500+ stars on GitHub.
This connects to something I wrote about recently: "open" can mean very different things depending on what's actually shared.
Why this little duck matters
- 💰 Price: $399, compared with around $13,500 for a full-size Unitree G1 humanoid. That makes it one of the cheapest walking two-legged robots you can order.
- 🛡️ Safe to fail: it's small, light, and gets back up on its own. A failed attempt costs nothing, which is exactly what reinforcement learning needs.
- ⚽ Group projects: several ducks can race or play football, so you can run multi-robot experiments without a lab full of hardware.
- 🔁 Shared progress: one person's trained move becomes everyone's. The library of moves grows with the community.
Good to know before you order
- About 1 hour per battery
- Only 1 GB RAM on board
- Lifts only ~100 g, so it's for learning, not chores
- Navigation, mapping, and voice commands are left to the community
- Some specs, like camera quality and sensor range, aren't final yet
- New orders currently show a wait of 4–6 months
The takeaway
Robot training is moving from labs to regular desks.
If you have an RTX card, you already have the hardware to train one. And because every trained move can be shared on Hugging Face, the duck gets smarter as the community grows.
Would you train a robot on your own PC if it cost less than a phone? Tell me in the comments 👇
I write about how tech actually works at Compiled Thoughts on Substack. If this was useful, follow me here or subscribe there for more breakdowns like this.
Sources and further reading:
Top comments (0)