Open-source project
pollen-robotics/microduck avatar
pollen-robotics/microduck

Microduck: the 800 gram duck's brain, written as Rust daemons

A Tiny biped duck robot 🦆

13,817 stars1,763 forksRustApache-2.0

At a glance

What is it?
The open source software half of a small biped duck robot, where a 50 Hz loop drives fifteen servos from ONNX policies, seven daemons share one JSON-RPC contract, and dev builds are published per branch alongside stable daemon releases.
Who is it for?
Microduck suits people who already own one of these robots, or who want to work on embedded Rust daemons with a MuJoCo stand-in for the body. It does not suit anyone looking for open hardware, because the repository holds the brain and the machine is sold through pollen-robotics.com/microduck.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • pollen-robotics/microduck13,817 ★ · +5,336
Star history
Repository2026-09-172026-11-15
pollen-robotics/microduck8.5k13.8k

5,336 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

This repo is the brain, the robot is sold separately

The front page is blunt about the division. It says this repo is the duck's brain, that everything needed to run a Microduck is here, and separately that if you want one you should get yours at pollen-robotics.com/microduck. Cloning the code does not produce a robot. What it produces is the software for a machine about 25 cm tall and 800 g, built on a Rockchip RK3566, where a 50 Hz control loop drives fifteen servos from neural policies alongside the radios and the camera. The update machinery rides along in the same package, described as what gets new software onto a robot without bricking it. The policies are not in this repository either. They are trained next door in microduck_rl, which pairs MuJoCo with PPO, works through the sim2real recipe, and exports the ONNX files that this repo loads.

Every daemon speaks one JSON-RPC contract over Unix sockets

Rust, no framework, one workspace, and a single contract between everything. The daemons split by job: 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, and tofd serves the depth sensor. They talk over one JSON-RPC contract on Unix sockets, and the design decision is worth naming because it shapes the work: every client, whether it is the app, the console, the gamepad or a script you wrote yourself, sends exactly the same calls. So there is no privileged interface and no separate admin path to keep in step. What the design does not make cheap is a change to the contract itself. Adding a client is easy, but every daemon has to answer the same calls as its siblings, so the cost of one edit lands across the set.

duckctl works with no network and no ssh, and a pad pairs once

The operator surface is split in two, and the split follows how you are connected to the bird. From a laptop with no network and no ssh, duckctl drives the robot over Bluetooth, which is the path offered when wifi is not the option in front of you. The wider command surface is robotctl, and its cheat sheet entry covers drive, configure, voice, chorale, theremin, wifi, updates and logs, with a note to start there. Pairing a gamepad is the one piece that is explicitly per device: the mapping is given in full, pairing happens once per pad, and the same page covers what to do when a pad will not bond. The developer path is separate again, since a blank board can be brought up to accept branch builds, a branch can be built on your own machine and installed over ssh in about a minute, and the dev cheat sheet continues from there with release candidates and driving from a laptop. Both paths end up sending the same calls over the same contract.

Rollback is triggered by an unhealthy boot, and nothing else

Updates carry the most explicit promises in the project, and all of them are about not being stranded. updaterd installs signed releases and rolls them back when a robot comes up unhealthy, so a failed boot resolves itself instead of leaving a bird on your desk. The operator page covers three verbs, install, roll back and pin, and states that every update is verified, health-gated and reversible. Read the trigger carefully, because it defines the edge of that safety net. The automatic rollback is conditioned on the robot coming up unhealthy, which covers a bad image and a botched migration. An update that boots cleanly and then behaves badly once it is moving sits outside what a health gate can observe. The manual roll back and pin commands cover the remainder, which means the policy has to exist before an update surprises you rather than after. The dev cheat sheet carries a matching warning about restart traps after an update.

default-members exists to keep a Bluetooth stack off the board

Cargo.toml holds a key that makes no sense until you know what the board is. The workspace lists every crate as a member, and default-members exists to leave one out: duckctl, the client a developer runs on their own machine. The comment on that key gives the whole argument. The board build command is cargo board --bins, used in dev-push.sh and in the release workflow, and it builds every default member for aarch64. That is correct for the robot's daemons and wrong for the client, since it would cross-compile a Bluetooth stack for a board that must never see one, on the release path, for nothing. The alternative weighed was naming the binaries explicitly at each --bins call site, and the comment rejects it because there are two such sites that would have to be kept in step by hand. The comment also records that --workspace is unaffected, so CI still lints and tests duckctl as before.

bash
cargo board --bins

ONNX Runtime is dlopened, and a test keeps two copies of the list honest

Running a policy means loading a runtime library rather than linking one. robotd dlopens ONNX Runtime to execute the exported policy, and because that library has to be present on the board, Cargo.toml treats its entries as a single source of truth: xtask package bakes them into the release's preinstall hook, and a test checks them. The practical shape of that is worth stating plainly, because it means the ONNX Runtime build a robot ends up with is chosen when the release is packaged rather than on the robot.

bash
xtask package

The simulated duck swaps the body, not the daemons

The cheapest way to work on this software needs no hardware on the desk. The README points at scripts/duck-sim, which runs the real daemons against a body in MuJoCo, either as a single duck in a window or as four you log into as if they were separate machines. That distinction is the point of it: the real daemons speaking the real JSON-RPC contract with only the body replaced, not a mock and not a reimplementation, so a change to robotd can be exercised before any board ever sees it. The simulation also shares its foundation with training, since microduck_rl works in MuJoCo with PPO and exports the ONNX this repo loads, so the same policy files are what run in the window and on the robot. What it does not replace is the production of those policies, which belongs to the separate training repository along with its sim2real recipe.

Dev builds are tagged per daemon and named after their branch

The release list is the clearest view of how this project actually ships. Three tags appeared on 3 November 2026: daemon-dev-stress-test, daemon-dev-main and daemon-v0.18.4, carrying daemon 0.18.3-dev.1544.a2e5330, daemon 0.18.4-dev.1550.d13be2c and daemon 0.18.4. Two things are encoded in those names. The dev builds are named after the branch they came from, so a stress-test branch publishes under its own tag, main publishes under its own, and a stable release gets a daemon-v tag. And each dev version number carries a base version, a build counter, and a short commit hash, which ties an installed build back to one exact commit. The dev cheat sheet is organised around branch builds, release candidates and driving from a laptop.

Editorial conclusion

Microduck suits people who already own one of these robots, or who want to work on embedded Rust daemons with a MuJoCo stand-in for the body. It does not suit anyone looking for open hardware, because the repository holds the brain and the machine is sold through pollen-robotics.com/microduck. Before you start, check that your board can take branch builds, read the restart traps the dev cheat sheet warns about after an update, and decide how you will pin a version when dev builds ship per branch alongside stable daemon releases.

Frequently asked questions

What are Microduck robots used for?

It is a tiny biped duck robot, about 25 cm and 800 g, that walks from a gamepad, rolls forward on command, picks things up, stands itself back up after being knocked over, sits, kicks a ball and quacks. The open source repository is the software half, not the hardware.

Are microbots like Microduck a real thing?

This one is sold as a product, with a get yours here link on the front page pointing to pollen-robotics.com/microduck, and the software is public under the Apache-2.0 license. You can also develop against it without hardware, since scripts/duck-sim runs the real daemons against a body in MuJoCo.

How much does a Microduck robot cost?

The repository publishes no price. Purchasing runs through the get yours here link to pollen-robotics.com/microduck on the front page, while the software you would run on it stays open source under Apache-2.0.

Official sources

  1. License: Apache-2.0
  2. pollen-robotics/microduck on GitHub
  3. Project website
  4. README
  5. Releases
Community

Where developers are discussing it

Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.

Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/pollen-robotics-microduck.svg)](https://hysenlabs.com/projects/pollen-robotics-microduck)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/pollen-robotics-microduck.svg)](https://hysenlabs.com/projects/pollen-robotics-microduck)

Was this useful?