On 2026-08-27, Hugging Face and Pollen Robotics, the French robotics company it acquired in April 2025, released Microduck: a 25 cm, sub-800 g bipedal robot shaped like a duck, priced at $399 and opened for preorder the same day. The hardware specifications are modest by design. What makes the release worth attention is the software published alongside it: the runtime and SDK, the physics simulation, and a complete reinforcement learning training stack, all under Apache-2.0 on GitHub. In the words of Hugging Face CEO Clem Delangue, it is an open-source robot you can teach new tricks with reinforcement learning.
Scope note: hardware specifications are cross-checked across Pollen Robotics launch material and multiple outlets (byteiota, PeopleAreGeek, Tbreak, EET-China, and a Toutiao report). Star counts, fork counts, licences, and languages for the two GitHub repositories were retrieved directly from the GitHub API on 2026-08-31. Sales and delivery figures are press-reported, not audited. One materially important fact is in dispute across sources (whether hardware design files ship open) and is flagged as such rather than resolved here. Information is current as of 2026-08-31; things move fast in the fortnight after a launch, so verify against the repositories and the official site.
What it is: a robot built as a duck
Microduck stands 25 cm tall, 14 cm wide, and weighs under 800 grams. It is built by Pollen Robotics, whose previous products were the research-oriented Reachy line. Microduck is the second consumer robot since the acquisition; the earlier Reachy Mini desktop robot has sold roughly 10,000 units.
Seven behaviours ship trained: walking, sitting, standing, crouching, kicking, picking things up with its beak, and getting back up after a fall. That last one deserves separate mention. The practical problem with small bipeds is not whether they walk well but what happens when they fall, and a robot that needs a human to stand it back up stops being useful within about ten minutes of unsupervised operation. Including fall recovery as a shipping behaviour reflects that the designers understood the actual use case. With the accessory rollers fitted, it can also skate.
The hardware: a Rockchip RK3566 (Radxa Zero 3W) with four Cortex-A55 cores and roughly 0.8 TOPS of INT8 NPU; 1 GB of RAM and 32 GB of storage; a front camera, two IMUs (body and head), an 8x8 ToF LiDAR, a microphone, a speaker, and two NFC antennas; Wi-Fi and Bluetooth with game controller support; and a removable 2600 mAh NP-F550 battery rated at about an hour.
The specification that matters most is that the control policy runs as ONNX on board the RK3566 at a 50 Hz control loop. Deciding where the next footfall goes does not round-trip to a server. That single line separates a research platform from a toy with an app.
Actuators: 15 servos and a 14-dimensional policy output
The robot carries 15 degrees of freedom using Dynamixel XL330 servos. The RL policy outputs 14 dimensions covering the legs, neck, and head, with the beak servo controlled independently.
Read together, those two numbers describe a deliberate split. The policy owns continuous control of locomotion and balance, while the beak is a discrete action triggered by upstream logic and stays out of the policy network. This is a common engineering split: the policy network can stay focused, but the real-world success rate of "pick something up with the beak" depends on how well upstream triggering coordinates with underlying posture, not on the policy alone.
| Item | Specification |
|---|---|
| Size and weight | 25 cm tall / 14 cm wide / under 800 g |
| Compute | Rockchip RK3566 (4x Cortex-A55, ~0.8 TOPS INT8 NPU) |
| Memory and storage | 1 GB RAM / 32 GB |
| Actuators | 15x Dynamixel XL330, 14-dim policy output, beak independent |
| Sensors | Front camera, 2x IMU, 8x8 ToF LiDAR, mic, speaker, 2x NFC antennas |
| Connectivity | Wi-Fi, Bluetooth / BLE, game controller support |
| Battery | 2600 mAh removable NP-F550, rated ~1 hour |
| On-board inference | ONNX policy, 50 Hz control loop |
| Shipping behaviours | 7, including fall recovery and beak grasping |
The actual point: two Apache-2.0 repositories
The hardware is the packaging; the stack is the product. Two public repositories went out, both Apache-2.0.
| Repository | Contents | Language | Stars / forks | Created | Last push |
|---|---|---|---|---|---|
pollen-robotics/microduck | Runtime and SDK | Rust | 4,108 / 485 | 2026-07-29 | 2026-08-31 |
pollen-robotics/microduck_rl | Simulation and RL training stack | Python | 1,037 / 179 | 2025-12-06 | 2026-08-31 |
Stars, forks, licence, and language fields above were read from the GitHub API on 2026-08-31, and both repositories had commit activity that day. Note that the training repository was created in December 2025, eight months before the hardware launch, which explains why it ships a usable training pipeline rather than a placeholder.
The training stack is built on MuJoCo Warp (mjlab) with PPO, running 4,096 parallel environments on a CUDA GPU. Pollen states that a usable locomotion gait takes roughly one to two hours to train. That number matters because it compresses the unit cost of a failed experiment from days to an hour or two, and the cost of being wrong is precisely the barrier that physical RL has never cleared cheaply.
Sim-to-real: where the training stack earns its keep
Getting RL working in simulation is routine. Watching it collapse on real hardware is also routine, because friction coefficients, motor delay, and sensor noise are never perfectly modelled, and a policy that is flawless in MuJoCo falls over on contact with a floor. What microduck_rl publishes is the recipe for closing that gap, as runnable code rather than as a paper.
Concretely: a BAM actuator model for the XL330 covering the voltage control law, back-EMF, and both Coulomb and Stribeck friction terms; per-environment domain randomization across battery voltage, voltage sag, command delay, friction coefficients, and terrain; and backlash simulation. When training finishes, policies export to ONNX via scripts/export.py, which bakes the observation normalizer into the graph. The RK3566 runtime loads that ONNX file and executes it at 50 Hz.
It works because the simulation is calibrated to this specific hardware, and that is not something most hardware startups ship on day one. It is also the part worth reading even if you never buy the robot: the recipe is the transferable artefact.
You do not have to wait for hardware to start. The simulation environment is public, there is a browser-accessible simulator Space on Hugging Face, and there is a Discord community for questions.
How open is it: a question the sources disagree on
This is the section readers should judge for themselves.
On whether hardware design files ship open alongside the software, reporting conflicts. byteiota states that hardware schematics and software are both Apache-2.0. EET-China, after listing both repositories, notes explicitly that the mechanical structure is not open, and the Toutiao report likewise states that the mechanical and electronic design files were not released.
What this piece could verify: both public repositories contain the Rust runtime, SDK, simulation, and RL training code. No mechanical drawings or circuit design files were found in them. Whether design files were published through some channel outside those repositories is beyond what was checked here, so this piece does not adjudicate between the two accounts. Anyone with commercial or derivative hardware plans should verify the repositories' current contents and Pollen Robotics' own statements directly.
Two ideas need separating here. Being able to download, run, and modify something is one thing; being free to use it commercially and redistribute it is another. Apache-2.0 settles the latter for code. Whether you can fabricate the hardware is a separate question entirely, governed by a different set of documents.
That distinction is worth elaborating, because "open" in open hardware decomposes into at least four separable layers: software stack, circuit schematics, mechanical drawings, and firmware plus bill of materials. Each layer can carry a different licence, and any subset may be published. For Microduck, the layer verified as public here is the first; the status of the rest is where reporting diverges.
This is not pedantry, because the answer determines what you can do. If you only want to train policies and treat the robot as an actuator, layer one is sufficient, and you do not even need to buy hardware, since gaits can be trained in simulation. If you want to machine your own unit, you need layers two and three, which is exactly where the disagreement sits. If you want to manufacture or build a derivative product, layer four governs parts availability and cost. So there is no single answer to "is it open"; there is an answer per layer.
One common misreading is also worth naming: Apache-2.0 is a software licence governing copying, modification, distribution, and patent grant for code. It does not by itself confer manufacturing rights over mechanical structures or circuit designs. Reading an open software licence as permission to fabricate the hardware is among the most widespread misreadings in open hardware.
It is selling fast, and shipping in four to six months
Demand exceeded expectations. Press reports put preorders above $1 million roughly six hours after launch and above $2.6 million within 24 hours, with Hugging Face co-founder Thomas Wolf citing an average of one unit sold every four seconds and a target of 20,000 units. The cost is a backlog: new orders are quoted at four to six months for delivery. Manufacturing is handled by Seeed Studio in Shenzhen.
The price structure: $399 for the unit before tax and shipping, $39 for a dual charger with two spare batteries, $119 for a Dev Pack with spare motors and NFC tags, and $39 for an accessory pack with rollers, a ball, and a laser pointer. The Dev Pack is worth it if you intend to go deep on the RL workflow.
Context makes the intent clear. Pollen's Reachy 2 is a full-size humanoid selling at $70,000 and used by labs including Cornell and Carnegie Mellon. Microduck is $399. That is not an incremental step; it moves the entry price of physical AI research from "a grant or a well-funded lab" to "a GPU and a preorder slot".
Who should buy, and who should wait
Buy now if you want to do physical RL with your hands. The bottleneck for that reader has never been algorithms. It has been the absence of a machine that can take a fall, be trained on, and ship with its training code. At $399 plus a CUDA GPU, that barrier is gone, and it was not gone a few years ago. Students, hackerspaces, and instructors building a course platform are all in range.
Wait if you want a robot that does useful work around a house. One hour of battery, 800 grams, and 25 centimetres make this an experiment platform, not a productivity tool. And if your plan depends on hardware drawings being freely replicable, verify the design file situation yourself per the section above rather than relying on this piece or any other secondhand account.
One more variable: Nvidia is reported to be in talks to acquire Hugging Face for around $12.9 billion, news that surfaced two days after the Microduck launch, and the deal has not closed. The Apache-2.0 licences are published and the code is out, so nothing changes short term. Whether the open-source commitment survives the acquisition is an open question, and anyone planning long-term research on this stack should price that in and archive the version they depend on.
Practical note to close: you do not have to wait for the hardware. The simulation and training stack run today. Train a gait in MuJoCo now, and when the unit arrives in four to six months, deploy the ONNX to it. That is likely why Pollen published the software first. The hardware takes time; the learning does not.
FAQ
Q1: Are the hardware design files actually open?
A1: The sources disagree, and this article does not settle it. byteiota reports that the schematics were published under Apache-2.0 alongside the software; EET-China and Toutiao state plainly that the mechanical and electronic design files were not released. The verifiable primary material is the two repositories themselves, pollen-robotics/microduck and pollen-robotics/microduck_rl, checked against the GitHub API on 2026-08-31 at 4108 stars / 485 forks and 1037 stars / 179 forks respectively, both with an Apache-2.0 licence field. Clone them, read the directory structure, and check each of the four layers separated out in section five (software stack, schematics, mechanical drawings, firmware and BOM) before deciding whether it meets your expectations.
Q2: What does $399 buy, and when does it ship? A2: The complete unit, built around an RK3566 with 1GB of RAM and 32GB of storage, 15 XL330 servos, an 8x8 ToF LiDAR, and a 2600mAh battery rated at roughly one hour, running on-board ONNX inference at about 50Hz with seven factory behaviours including fall recovery. Shipping is quoted at four to six months, with Seeed handling manufacturing in Shenzhen. If your plan depends on hardware arriving on a fixed date, build that lead time into the schedule.
Q3: Can I train it on a single consumer GPU?
A3: The microduck_rl stack uses MuJoCo Warp (mjlab) with PPO, and Pollen reports a deployable gait in one to two hours across 4096 parallel environments. That is a simulation figure, not a real-robot figure. Simulation training itself is not demanding, but the number of parallel environments and the number of runs you are willing to wait for scale with your patience. Deployment needs no training compute at all: export to ONNX and run it on the robot. No official VRAM baseline is published, so this article does not invent one.
Q4: How does this compare with something like Reachy 2? A4: They are three orders of magnitude apart: Reachy 2 sells for about $70,000, the Microduck for $399. If the goal is humanoid manipulation, bimanual grasping, or research close to real task settings, Reachy 2 has a far wider capability envelope. If the goal is a physical RL platform you can crash, retrain, and modify the training code of, the Microduck drops the entry fee from "secure funding or join a lab" to "own a GPU and reserve a unit". Decide what question you are researching, then work backwards to the machine.
Q5: Does the rumoured Nvidia acquisition of Hugging Face affect these repositories?
A5: Not in the short term. Both repositories are published under Apache-2.0, the code is out, and the licence on a released version cannot be revoked. The variable is medium term: the roughly $12.9 billion acquisition talks surfaced two days after the Microduck launch and the deal has not closed, so whether the open-source commitment survives is an open question. If you plan long-term research on this stack, archive the version you depend on and watch the commit cadence on microduck_rl. That tells you more than any pledge will.