Microduck is an open-source biped from Pollen Robotics, part of Hugging Face. It walks, sits, crouches, kicks a ball, picks things up with its beak, roller-skates, and gets back up after a fall using reinforcement learning policies. The entire software stack — runtime, SDK, simulation environment and RL training scripts — ships under Apache-2.0.
Microduck is built for action, not conversation. Its predecessor Reachy Mini is a desktop robot that sees, hears and talks; Microduck starts from the other end of physical AI — moving through the world, falling over, getting back up, carrying things away in its beak.
It is built by Pollen Robotics in Bordeaux, France — a team founded in 2016 by former Inria researchers and acquired by Hugging Face in April 2025. Reachy Mini has sold more than 10,000 units. Microduck is the first time the team has sold a walking, self-contained robot as a pre-order consumer product.
The positioning comes with a deliberate omission: Microduck does not speak. It communicates in small, odd sounds, and every unit generates its own voice the first time it boots, which stays bound to that robot for life. That is a design decision, not a missing feature — it keeps the feedback loop tied to what the machine is physically doing instead of turning it into a chatbot that happens to have legs.
These five clips come from the official Microduck product page and press kit. Videos are not preloaded — they only start streaming after you press play. If you just want a quick look, each poster frame already shows the pose.
Getting back on its feet from several common fall positions. This is one of the seven trained moves that ship in the box — and the most under-appreciated skill for a small biped.
Several Microducks playing together with no conductor and no shared clock. The project docs clock the drift at about ±20 ms over ~25 beats. This clip has audio.
Picking up objects with the articulated beak. The beak can lift roughly 100 g — a number that is often confused with the 800 g total robot weight.
Rolling on small skate wheels. The wheels are not in the $399 base box — they are part of the separate $39 accessory pack.
A longer multi-robot shot showing several Microducks moving in the same space. At 33 seconds, this is the longest of the five reels.
Video copyright belongs to Pollen Robotics / Hugging Face. See the official press kit.
These photos also come from the official press kit and were shot with the launch hardware. The yellow-and-cream shell in the images is the Cream colourway; the other three launch colours are Graphite, Lavender and Sky.
Photos by Pollen Robotics. Full-resolution originals are available in the official press kit.
For the price, the sensor list is dense. The brain is a Rockchip RK3566 (in Radxa Zero 3W form) — quad Cortex-A55 up to 1.8 GHz with roughly 0.8 TOPS INT8 of NPU — paired with 1 GB of RAM and 32 GB of storage. The point of that compute is not to run a large model. It is to finish one policy forward pass inside a 20 ms hard real-time budget.
| Item | Specification |
|---|---|
| Main SoC | Rockchip RK3566 (Radxa Zero 3W), quad Cortex-A55 @ 1.8 GHz, Mali-G52, ~0.8 TOPS INT8 NPU |
| Memory / storage | 1 GB RAM · 32 GB eMMC |
| Actuation | 15 Dynamixel servos: left leg id 20–24, right leg id 10–14, neck/head/beak id 30–34. The RL policy outputs 14 dimensions; the beak servo is driven independently |
| Bus | /dev/ttyS2 · 1 Mbps · Dynamixel protocol v2. Servos and the IMU board share one UART |
| Vision | Front camera behind a dedicated camera-active indicator light |
| Depth | 8×8 time-of-flight LiDAR matrix (VL53L8CX class, 15 Hz, on the HAT I²C bus) |
| Motion sensing | Two IMUs — one in the body, one in the head. The imu_to_dxl board (id 200) serves an on-chip SFLP quaternion |
| Audio | Microphone and speaker. Each robot generates its own voice from its SoC serial |
| Interaction | Articulated grasping beak; two NFC antennas, one in the head and one in the beak |
| Wireless | Wi-Fi and Bluetooth / BLE; pairs with a gamepad |
| Battery | Removable NP-F550, 2600 mAh, roughly one hour per charge |
| Size / weight | About 25 cm tall · 14 cm wide · under 800 g |
| Colourways | Cream #f7e6cb / Graphite #6c6a68 / Lavender #bfa9cf / Sky #a9dbe8 |
| In the box | The robot, a battery, a USB-C cable and a game controller |
| Pack | Price | What is in the box |
|---|---|---|
| Microduck base kit | $399 | The robot, one battery, a USB-C cable and a game controller |
| Charger pack | +$39 | Dual charger plus two spare batteries |
| Dev pack | +$119 | 3 spare servos, 5 motor cables, 2 batteries, dual charger, 10 NFC tags, Hugging Face credit, screwdriver and screw pack |
| Accessory pack | +$39 | Laser pointer, NFC Polaroid, two roller wheels, small ball, 10 NFC tags |
A 22 nm quad A55 drawing 2.5 W typical and 5.25 W peak, friendly to a 7.4 V cell stepped down to 5 V. It does not chase peak compute — it packages adequate CPU, low power, a long supply commitment (board vendors promise availability past 2030) and a full Linux ecosystem.
The main control loop today runs ONNX Runtime on the CPU, which is sufficient. The NPU is reserved for perception: the project is bringing a duck detector up on the RK3566 NPU, with the runtime pinned to rknn-toolkit2 v2.3.2.
Fifteen servos and the IMU board share a single UART. The robotd control thread is its only owner; serialport sets TIOCEXCL for exclusion, and anything else that wants the bus has to ask robotd over IPC.
0% is BATTERY_EMPTY_V, the point at which robotd sits the robot down and cuts servo power. The readout goes yellow at 30% and red at 15%; until a reading exists it says "batt not read yet" rather than 0.00 V.
It works out of the box with no code: pick up the bundled gamepad and drive. The seven pre-trained behaviors are the output of reinforcement learning policies, not canned animations — and Pollen defines them explicitly as "a starting point" rather than the limit of what the robot will ever do.
Waddle forward and turn. Left stick drives; release the sticks and it stands.
D-pad down toggles between sitting and standing.
In body-pose mode the sticks lean and crouch the standing robot.
LB and RB are the left and right kick; both work on wheels too.
A triggers a ground pick: beak to the floor, grip, lift. Official demos pick up socks and markers.
Clip the wheels on, hold D-pad up for three seconds, and it loads the other brain.
Recover to standing from several common fallen postures — one of the hardest things to learn on a small biped, and one of the fastest ways for a robot to become unusable if it is missing.
Beyond those it can do a forward roll (X, hold to chain rolls), follow a laser pointer, fire movements from NFC tags, and sing together with other Microducks in a chorale.
The duck's brain is one Rust workspace, no framework, one crate per service. They talk over JSON-RPC 2.0 on Unix sockets — NDJSON, one object per line — and every client, whether it is the phone app, the console, the gamepad or your own script, sends exactly the same calls.
| Service | Owns | Listens on | Reaches out to |
|---|---|---|---|
| robotd | Motor control, kinematics, odometry, gait policies, safety, robot.health | /run/robotd.sock | The Dynamixel bus (/dev/ttyS2) |
| configd | Wi-Fi, robot identity and name, pairing PIN, gamepad bonding, reboot | /run/configd.sock | BlueZ and NetworkManager over D-Bus |
| updaterd | Releases: verify, install, swap, health-gate, roll back | /run/updaterd.sock | GitHub Releases, systemctl, robotd |
| btd | A BLE GATT transport adapter — owns no state | A BLE GATT service | robotd / configd / updaterd |
| padd | Gamepad → intents, plus a raw input tap | /run/padd/pad.sock | /run/robotd.sock |
| mediad | Camera and audio pipeline, WebRTC gateway, remote console | :8080 console · :8443 signalling | robotd / configd / updaterd |
| tofd | The head's 8×8 ToF depth matrix, published at 15 Hz | /run/tofd/tof.sock | The HAT I²C bus |
| robotctl | The operator CLI — must work on a broken robot | — | Every socket above |
Control plane and data plane are kept strictly apart: commands, config and status travel as RPC over Unix sockets, while 640×480 RGB at 30 fps is about 27 MB/s and never crosses a socket — mediad's GStreamer pipeline encodes it in hardware H.264 through Rockchip MPP (mpph264enc) and pushes it out over WebRTC.
One process, one serial bus, one 50 Hz loop. The loop reads all sixteen devices on the bus in a single transaction, decides fifteen joint targets, and writes them back. Everything else — clients, health, telemetry — hangs off that loop without ever being able to block it.
sync_read as the servos, because that is what the hardware does: the v2 imu_to_dxl board sits on the Dynamixel bus and serves an on-chip SFLP quaternion out of the same register block..onnx file exported by training, with observation normalisation baked directly into the graph.The safety layer shares the only write handle to the bus with the loop, so no policy and no client can command a motor around it: joint clamps, fall → limp, and an intent deadman. robotctl monitor shows what a client asked for beside what was actually applied, naming the reason when they differ — safety clamps values constantly, and without that pairing, "the stick is forward and the robot is still" is unreadable.
This is the most valuable part of the project. Pollen did not publish sim-to-real as a paper — they published it as code that runs. Reward functions, domain randomisation configuration and actuator modelling all live in the microduck_rl repository.
| Dimension | Training | Deployment |
|---|---|---|
| Hardware | NVIDIA CUDA GPU / DGX Spark / Jetson / HF Jobs | RK3566 board (quad A55 @1.8 GHz) |
| Compute shape | Multi-GPU, 4,096 parallel environments | 4× Cortex-A55 + ~0.8 TOPS NPU |
| Stack | mjlab / MuJoCo Warp / PPO | ONNX Runtime + daemons |
| Input | Robot URDF + task + physics parameters | IMU / ToF / camera / gamepad commands |
| Output | A trained policy network | Fifteen servo target positions |
| Latency budget | 1–2 hours to a policy | 50 Hz, 20 ms per tick |
scripts/export.py writes the observation normaliser into the ONNX file, so the device needs no separate preprocessing parameters.microduck_rl repository registers 13 task families, six of them built around the passive wheels that go under the feet, plus tasks such as a forward roll. Only seven policies are delivered with the robot and validated on real hardware. The rest you train yourself.# Training side (microduck_rl, Python)
# 4,096 parallel MuJoCo environments + PPO. A usable gait converges in ~1–2 hours.
# Export to ONNX with observation normalisation baked into the graph
python scripts/export.py --checkpoint <run> --out my_walking.onnx
# Deployment side: copy it to the board and point at it in /etc/robot/robotd.toml
# [policy]
# walk = "/home/radxa/my_walking.onnx"
sudo systemctl restart robotdFor a robot shipping to ordinary users, the update system carries the same weight as the gait. The rule is simple: releases are swapped, not patched, and every step is verifiable and reversible.
/opt/robot/daemon/releases/<version>/ and updaterd checks its signature.current symlink and restart the units.robot.health pass? This is a real socket probe, not a liveness check.golden symlink and robot-rescue, is the last net.The governing invariant: everything outside releases/<ver>/ survives both an update and a rollback. That is why per-board configuration is never shipped inside the release. Developer branch builds are fenced off by two hard rules: a dev build cannot become latest (its version is a semver prerelease and version_under refuses to read a dev tag as a release version) and cannot install on a customer robot (where allow_dev_keys is false, and a trusted key only counts as a dev key if its filename ends in .dev.pub).
The voice bank is generated from the SoC serial (sounds ensure-bank, run by every release install), so the robot that answers — in a voice that is only its own — is the one you are SSH'd into. Silence always means the wrong duck. It greets when robotd comes up, pecks goodbye before powering off, and if you enable audio.pet_detect it coos when the mic hears its head being scratched. That last one is off by default: the always-on version cooed at every incidental brush and wore thin.
Two ducks in a room sing a four-part piece together; more join what they find already going. Nobody is in charge: both see the same beacons and the lower id conducts, so there is no election to lose and no message that has to arrive. There is no shared clock: the boards have no NTP and no RTC agreement, so the conductor's beat counter is the timebase — it bumps a byte in a BLE advertisement once per beat and the arrival of a new value is the downbeat. Followers average the phase over about 25 beats, pulling radio jitter inside the ±20 ms an ensemble needs. Parts are worked out rather than assigned: the lowest duck sings bass, the conductor broadcasts the roster, and everyone replays the same seating over it — which is what stops two ducks singing the same line.
The head's depth sensor becomes an instrument: a hand in front of the beak is the pitch, closer is higher, and the mouth opens with the note, widest at the top of the range. It plays sitting, standing or walking — the mouth is not part of any policy. The readout's last column is what the sensor said about that frame, which is the answer to every "why did it stop playing": ST documents status 5 and 9 as range valid, and a build believing only those stops seeing a hand at about 30 cm — beyond that a moving hand returns 4 or 13 (consistency failed, sigma too high) carrying a distance perfectly good for a pitch.
duckctl reaches the robot from a laptop over Bluetooth, with no network and no ssh. mediad serves WebRTC straight off the board, so a browser on the LAN sees the camera and drives it through a control data channel riding alongside the video track. Quality is switchable between 1080p30 / 720p30 / 720p15 / 360p30; turning media.camera off streams a test pattern instead, because the WebRTC control channel rides on the video track and a pipeline that cannot start costs you both.
robotctl runs on the robot. Read-only commands need no privilege; anything that changes the robot needs sudo.
# Run this first: what every daemon is running vs what is installed, with warnings when they disagree
robotctl version
# Hardware and software in one report. Exits non-zero when unhealthy or unreachable, so it can gate a script
robotctl health # --json for a support bundle
# What a client asked for beside what was applied, naming the reason when they differ
robotctl monitor # d toggles the duck view · [ ] orbit it · t opens the ToF matrix · p raw gamepad input
# Interactive config editor: schema, defaults and validation come from the crate robotd parses the file with
sudo robotctl configure
# Gamepad pairing (once per pad)
robotctl pad status
sudo robotctl pad pair
# Speak, in a voice that is only its own
robotctl quack
# Chorale / theremin (Ctrl-C to stop)
robotctl chorale
robotctl theremin
# Updates: install, roll back, pin
sudo robotctl update apply
# The robot from a laptop over BLE — no network, no ssh
duckctl ...Verified Chinese-language reporting and community discussion, with links to every original source. Each entry leads with an English rendering of the quoted passage and then gives the original Chinese, so you can check it against the source yourself. Summaries are compiled by this site; copyright stays with the original authors.
25 cm tall, 14 cm wide, under 800 g. $2.6m of orders in the first 24 hours. Rockchip RK3566 (Radxa Zero 3W), four Cortex-A55 cores with roughly 0.8 TOPS INT8 NPU. 15 servos in total; the RL policy outputs a 14-dimensional vector. — 原文：「身高 25 厘米，宽 14 厘米，重量不足 800 克。24 小时，卖出 260 万美元。主控 Rockchip RK3566（Radxa Zero 3W），4 核 Cortex-A55，带约 0.8 TOPS INT8 NPU。整机 15 个舵机；RL 策略输出 14 维。」
Rockchip RK3566 SoC, quad Cortex-A55 up to 1.8 GHz, 0.8 TOPS NPU, 1 GB RAM + 32 GB eMMC. One NFC antenna in the head and another in the beak, two IMUs, an 8×8 ToF LiDAR. The onboard system runs as daemons, with a 50 Hz control loop driving 15 servos. — 原文：「SoC 瑞芯微 RK3566，四核 Cortex-A55 最高 1.8 GHz，0.8 TOPS NPU，1GB RAM + 32GB eMMC。头部与鸭嘴各设一组 NFC 天线，2 个 IMU，8×8 ToF LiDAR。机载系统以守护进程形式运行，一个 50 Hz 的控制回路负责驱动 15 个舵机。」
Microduck is a one-eyed biped under 25.4 cm tall. It picks up socks and markers, kicks a ball, and can scoot around on small roller skates. Pollen Robotics: it communicates with odd little sounds, closer to a creature than to an assistant. — 原文：「Microduck 是一款独眼双足机器人，身高不到 25.4cm，可以捡袜子和记号笔、踢球，还能踩着小型轮滑鞋快速移动。Pollen Robotics 表示：它用古怪的小声音交流，听起来更像一种生物，而不是助理。」
About 25 cm tall and roughly 770 g, with 15 degrees of freedom across the legs, head and neck. Rockchip RK3566, 1 GB RAM and 32 GB storage. A removable 2600 mAh NP-F550 battery gives about an hour of runtime. The bundled open-source SDK ships a validated sim-to-real workflow. — 原文：「机身高约 25cm，体重约 770g，包含腿部、头部、颈部共 15 个自由度。搭载 Rockchip RK3566，1GB 运行内存与 32GB 存储。电池采用可拆卸的 2600mAh NP-F550，续航约 1 小时。配套开源 SDK 提供经过验证的仿真迁移实机工作流。」
On a local machine with a CUDA GPU, 4096 parallel environments produce a usable gait in about one to two hours. CEO Clem Delangue says the team deliberately designed Microduck to be built for movement and ready to fall — a robot failing and making mistakes is itself part of the education. — 原文：「有 CUDA 显卡的本地环境，用 4096 并行环境训练，一个能用的步态大约 1 到 2 小时就能训出来。Hugging Face CEO Clem Delangue 说，团队特意把 Microduck 设计成「为运动而生，也准备好摔倒」—— 机器人失败和犯错本身也是教育的一部分。」
About 25 cm tall and 800 g, built on an RK3566 and driven by 15 motors, with a camera, a depth sensor and dual IMUs, adjusting its motion in real time at 50 Hz. The SDK, the MuJoCo simulator and the full RL training stack are all open source. — 原文：「高约 25 厘米、重 800 克，搭载 RK3566 芯片，由 15 个电机驱动，配备摄像头、深度传感器和双 IMU，以 50Hz 频率实时调整动作。配套的 SDK、MuJoCo 仿真器和强化学习训练栈已全部开源。」
The software is written in Rust, with separate service modules handling motor control, sensors, Bluetooth, camera streaming and secure updates. Very high playability. — 原文：「软件采用 Rust 语言编写，由独立服务模块分别处理电机控制、传感器、蓝牙、摄像头流媒体传输及安全更新。可玩性很高呀。」
The passive wheels used for roller skating are not in the $399 base kit — they come in a separate $39 accessory pack, which also bundles a ball, a laser pointer and several NFC props. In other words, the duck cannot actually skate out of the box. The official press material states plainly that Microduck is "not open source hardware" today, and neither the mechanical nor the electronic design files were published alongside it. The badge says open; the drawings stay locked. — 原文：「那对轮滑用的被动滚轮不在 399 美元的基础套装里，要单独买 39 美元的配件包才有……官方新闻资料自己写得很清楚：Microduck『目前并非开源硬件』，机械结构和电子设计文件没有跟着一起公开。招牌是开源，锁住的是图纸。」
The code is Apache 2.0 while the hardware design files carry a non-commercial licence, so nobody can build and sell a clone. The repo registers 13 task families in total, including a forward roll and six built around a set of passive wheels that go under the feet. The simulator runs on MuJoCo Warp, built on NVIDIA's Warp framework; the mjlab training framework reimplements the API of NVIDIA's own Isaac Lab. — 原文：「代码采用 Apache 2.0 协议，硬件设计文件则采用非商业许可，因此没有人能制造并销售克隆品。仓库共登记 13 个任务族，包括前滚翻，以及围绕脚下一组被动轮设计的 6 项任务。模拟器运行在 MuJoCo Warp 上，底层基于 NVIDIA 的 Warp 框架；训练框架 mjlab 则重新实现了 NVIDIA 自家 Isaac Lab 的 API。」
Clem Delangue calls Microduck "an open-source robot you can teach new tricks with reinforcement learning." The SDK, the simulation and the full RL training stack are available on GitHub. On the privacy worry of putting a camera-bearing robot in your bedroom, Delangue told TechCrunch that bots run by open-source models are much better than "a black box system" controlled by a few organisations.
Reachy Mini is AI that interacts — it stays on a desk, sees, hears and talks with you. Microduck starts from the other side of physical AI: moving through the world, falling and getting back up, chirping with no words. Pollen flags several numbers, including camera resolution, LiDAR range and radio versions, as not final yet.
The mechanical and electronic design files are not published. That makes it an open software robot rather than open source hardware. Reachy Mini was open on both sides, so this is a narrowing rather than an expansion. Seven policies ship pre-trained, covering walking, sitting, crouching, kicking, roller-skating and getting back up after a fall. All seven are retrainable.
The hardware is the packaging. The stack is the product. Pollen published the recipe that makes sim-to-real work — not as a paper, but as runnable code. The repo includes a BAM actuator model for the XL330: voltage control law, back-EMF, Coulomb and Stribeck friction terms, with domain randomisation across battery voltage, voltage sag, command delay, friction and terrain, plus backlash simulation.
Hugging Face wants to do for robot skills what GitHub did for code: crowdsource voice recognition, SLAM navigation and grasping behaviors into a shared community library. Ambitious, and entirely dependent on community participation that does not yet exist. The beak picks up socks and markers — practical lifting capacity around 100 g. Do not expect it to fetch your coffee.
The behaviors shipping with Microduck are not meant to define what the robot can do forever. They are a starting point. Developers can train behaviours in a physics simulation, transfer them to the physical robot, then adjust the simulation, retrain and deploy again — without repeatedly sending their very real $399 duck tumbling across the room.
Out of the box the robot comes with seven trained behaviors: walking with a waddle, sitting and standing, crouching, kicking a ball, picking up objects, roller-skating and recovering from several common positions after falling over. It can also be controlled with a game controller and follow a laser pointer.
The most useful open hardware is rarely the most capable hardware; it is the cheapest thing whose failure you can afford to learn from. Microduck does not speak. It communicates through non-verbal sound, and each unit receives a permanent audio identity fixed at setup. That is a real decision, and a good one.
On-device runtime and SDK (Rust, Apache-2.0)
Simulation environment and physics model (MuJoCo / mjlab)
RL training stack, reward functions and the sim-to-real recipe (Python)
Policy weights for all seven shipping behaviors — all retrainable
CLI toolchain and the OTA update engine
Mechanical and electronic design files
In practice this means you can train a new policy on your own machine and deploy it to the robot with no vendor SDK gate and no cloud service in the middle. Community-contributed gait policies can live on the Hugging Face Hub alongside the model weights and datasets already there — and that flywheel is the reason Hugging Face acquired Pollen in the first place. As the Pollen blog puts it: models are valuable because people can build on each other's work, and they want physical behaviours to be shared the same way.
The introductory pre-order price is $399 before tax and shipping, in four colourways: Cream, Graphite, Lavender and Sky. The original target was delivery before Christmas 2026, but Pollen's own store now says it cannot promise Christmas delivery for new orders and quotes an estimated four-to-six month wait while production ramps. Launch regions are the US, Canada, the EU, the UK, Norway, Switzerland, Japan and South Korea.
The software is: the SDK, the MuJoCo-based simulation environment, and the reinforcement learning training pipeline that produced the shipping behaviours, all under Apache-2.0. The hardware is a product you buy at $399 rather than a set of files you fabricate. Treat it as an open software platform on closed hardware, not an open hardware project.
No. One gigabyte of RAM on an RK3566 is nowhere near enough, and Pollen does not claim otherwise. The on-board compute exists to run small exported control policies at 50 Hz. If you want an LLM in the loop, it runs off the robot and talks to it over Wi-Fi.
No — and that is a design choice rather than something they ran out of time to build. Microduck communicates through non-verbal sound, and each unit gets its own audio identity permanently fixed at setup. Avoiding speech sidesteps the whole assistant framing and keeps the interaction loop tied to what the robot is physically doing.
A CUDA GPU. microduck_rl runs mjlab / MuJoCo Warp across 4,096 parallel environments with PPO; a usable gait converges in roughly one to two hours and exports to ONNX for deployment. The repository also documents ARM options such as NVIDIA DGX Spark, GB10 and Jetson, and you can hand the training job to Hugging Face Jobs if you have no suitable GPU locally.
Official demos show it picking up socks and markers. Third-party reporting puts practical lifting capacity around 100 g; some coverage quotes "up to 800 g", but that figure is easily confused with the robot's own weight. Treat the official final specification as authoritative and do not expect it to fetch your coffee.
The system is designed so that it cannot. Releases are whole-directory swaps rather than patches: verify the signature, move the current symlink atomically, then pass a real health gate — a socket probe of robot.health — and roll back automatically if it fails. If a crash loop gets past the gate, a boot counter and the golden symlink are the last net. One honest caveat: the boot-recovery net ships enabled but is documented as never having been exercised on a board.
They are complementary rather than sequential. Reachy Mini is a desktop robot aimed at AI that interacts — it sees, hears and talks, and has sold more than 10,000 units. Microduck is aimed at AI that acts: moving through physical space, carrying things, recovering from a fall. In Pollen's own framing, one is AI that interacts and the other is AI that acts.