3D Print Open Source AI Robots

Bambot — $300 Open-Source Humanoid Bambot is the cheapest credible dual-arm humanoid in the DIY catalog: ~$300 in parts, two SO-ARM-derived arms mounted on a torso, sitting atop a two-wheeled self-balancing drive base. Built by Tim Qian and documented at bambot.org, with an interactive 3D URDF viewer you can drive from a browser before building anything. What you're getting Two arms — SO-ARM101 derivative with the v2 bases, matched follower and leader arms for teleop Humanoid torso — prints as a small number of large parts (, ) Two-wheel self-balancing base — balance-bot style, dramatic and compact STS3215 / Feetech bus — same ecosystem as SO-ARM101 so servos are interchangeable Web-based viewer — bambot.org renders the exact URDF directly in the browser, with URDFs for Unitree G1, Unitree Go2, and SO-ARM for comparison Why it's interesting The price/complexity curve on humanoids is steep. Bambot deliberately pushes the low-end corner of that plot — it isn't going to out-dance a Unitree H1, but it's a humanoid you can actually order and build this weekend. That makes it one of the best entry points for students, makers, and researchers who want to touch the full humanoid control stack (balance + arm IK + teleop + learning) without a five-figure robot. What you can do with it Balance + drive demos — segway-style base gives you a dramatic "robot standing up and moving" on a budget Teleop — two follower arms paired with two leader arms = the cheapest bilateral humanoid teleop rig Imitation learning — standard LeRobot pipeline; dataset the arms+base+body+head all together Browser-native demos — the bambot.org URDF viewer means you can show off the robot's kinematics to someone who doesn't have the hardware yet Printed parts (this program) Base: — main base plate with motor cutouts — humanoid torso shell — printed wheel (pair with foam tire or TPU over-mold) — drive motor bracket SO-ARM101 arms (per arm): — arm base , — links — shoulder , — wrist — gripper jaw — servo mount The full repo has ~46 STLs across the Bambot torso, arms, and base, plus reference URDFs for Unitree G1/Go2 you can compare against in the viewer. Attribution & license Designer: Tim Qian (timqian) Upstream: https://github.com/timqian/bambot Web viewer: https://bambot.org License: Apache 2.0 Built on: SO-ARM101 Links Upstream repo: https://github.com/timqian/bambot Interactive viewer: https://bambot.org Demo thread: https://x.com/Tim_Qian/status/1901952877243122014 Discord: https://discord.gg/Fq2gvSMyRJ Build Guide Hardware build documentation and assembly files: github.com/timqian/bambot/tree/main/hardware

3,406 stars on GitHub. Open Duck Mini — Bipedal BDX Droid Replica Source: https://github.com/apirrone/OpenDuckMini A miniature bipedal character robot inspired by Disney's BDX droid — the small two-legged star of the Galactic Starcruiser walkabout experience. Standing roughly 42 cm tall with its legs extended, Open Duck Mini v2 recreates the droid's expressive, duck-like gait in a fully open-source design that targets a complete bill of materials under $400. The mechanical design is authored in Onshape and simulated in MuJoCo, with locomotion trained end-to-end through reinforcement learning. The project has put heavy work into sim-to-real transfer, publishing trained ONNX walking policies that run on the robot itself. The onboard runtime executes those policies on a Raspberry Pi Zero 2 W, and the training stack is moving to MuJoCo Playground alongside a reference-motion generator for imitation learning. Planned "expression" features — LED eyes, a camera, a speaker and a microphone — extend the base walker into a fuller character robot and can be added after the build. The project is documented as it evolves (print guide, assembly guide, and a community Tnkr build guide), backed by an active Discord community, and sponsored by Hugging Face and Pollen Robotics.

891 stars on GitHub. Poppy Humanoid is an open-source, 3D-printed, 25-DOF humanoid robot from the Poppy Project, originally developed at Inria's Flowers team for research in embodied cognition, human-robot interaction, and robot learning. Standing 84 cm tall and weighing about 3.5 kg, Poppy is designed with biomechanically motivated bent-thigh proportions. Source: https://github.com/poppy-project/poppy-humanoid The robot uses 25× Dynamixel smart servos on a daisy-chained TTL bus. A Raspberry Pi onboard provides high-level control via pypot (the Python Dynamixel library developed for this project), with real-time joint targets streamed from user code. Compliant mode lets you back-drive the robot by hand to teach poses and trajectories — a powerful pedagogical and research primitive. Poppy Humanoid has been used in dozens of published studies on bipedal walking, imitation learning, developmental robotics, and tutor-assisted programming education. Poppy is a modular family: the Torso variant is a desk-mountable upper body, and the Ergo Jr is a 6-DOF desk arm. Both share the Dynamixel bus stack and the pypot API. This means behaviors developed for one Poppy robot often port directly to another with configuration-level changes rather than code rewrites. Hardware interface: USB-to-Dynamixel adapter (U2D2 or USB2AX) connected to the Raspberry Pi. No Arduino required. This program exposes cloud-side endpoints for rest/sit postures, arm waving, compliant-mode toggle, dance primitive playback, and full demonstration record/replay. The Raspberry Pi onboard bridges the orobot cloud to the Dynamixel bus via pypot. Credit to the Poppy Project community and Inria Flowers team (poppy-project.org) — upstream repository at https://github.com/poppy-project/poppy-humanoid. Hardware under Creative Commons Attribution-ShareAlike 4.0 (hardware/LICENSE.md), software under GPLv3 (software/LICENSE). Share-alike requires derivative hardware designs to be published under the same CC-BY-SA-4.0 license. Build Guide Official assembly guide: docs.poppy-project.org Printing This file set contains the structural body meshes for the Poppy Humanoid (head, chest, abdomen, bust/abs/hip motor brackets, and the limb segments: shoulder, forearm, hip, thigh, shin, foot). Poppy is a left/right symmetric biped, so the limb parts are mirror pairs — each l part has a matching r part, and both must be printed (they are not alternates). Important note on completeness: the current list is the curated set of printable body meshes, but it is not yet the full humanoid. Several right-side mirror parts (rshoulder, rhip, rhipmotor, rthigh, rfoot, rshouldermotor) are not present in this list and must be printed as mirrors of their left-side counterparts. The complete, official, print-ready STL package for the full ~25-DOF Poppy Humanoid is distributed by the upstream project as the "STL3Dprintedparts.zip" asset attached to the poppy-project/poppy-humanoid GitHub releases; builders should use that archive for the definitive, complete part list and quantities. Note on file naming: these are the "visual" geometry meshes from Poppy's URDF model. The companion "_respondable" meshes that appear in the source repository are simplified collision hulls used only for physics simulation and should NOT be printed — they have been excluded from this Print All set.

467 stars on GitHub · MIT · MakerForge Tech / Aaron Mason The Modular Bipedal Robot is an open-source 3D-printable companion robot from MakerForge Tech / Aaron Mason, built around a Raspberry Pi + Arduino Pro Mini split. The repo includes the full STL set for the v2 body, head, neck, and legs, plus a modular Python/C++ software framework with drop-in modules. Source: https://github.com/makerforgetech/modular-biped Architecture: Raspberry Pi (Pi 4 or Pi 5) handles vision, speech, and orchestration Arduino Pro Mini handles real-time servo control via serial Custom PCBs for power and IO IMX500 AI camera module supported Software modules (drop-in): Vision/tracking: face/object detection, motion detection Speech/TTS: text-to-speech, Braillespeak LLM/translation: ChatGPT chat, language translation Peripherals: NeoPixel LEDs, buzzer, audio Connectivity: RTL-SDR radio, Viam integration, serial bus Build resources: Wiki & build guide: https://github.com/makerforgetech/modular-biped/wiki 3D-print files: https://github.com/makerforgetech/modular-biped/tree/main/3dprints/v2 Hardware list: https://github.com/makerforgetech/modular-biped/wiki/Hardware Software architecture: see Software Architecture.drawio.svg in repo License: MIT. Printing This is the coherent v2 print set. Modular Biped is an 8-servo bipedal robot (6 leg servos — hip/knee/ankle per side — plus 2 head servos). Print one of each part. The legs and feet are left/right mirror pairs (leftlegupper/rightlegupper, leftleglower/rightleglower, leftfoot/right_foot); both sides are required and are not alternates. The parts cover the skeleton, the front/back body case, the head (top, bottom, lid, visor), the neck/tilt mechanism, and the two legs with feet. Recommended print as drawn for the v2 design. Note: the upstream source includes a file named complete (with a matching complete preview image) — this is a full assembled model of the whole robot used for visualization, not an individual printable part. It has been removed from this Print All set so the list yields each part once rather than printing a fused copy of the entire robot.

163 stars on GitHub · CC-BY-SA 4.0 · bq / JavierIH Zowi is the official open-source biped from bq (sponsored until 2016) — a compact 4-servo educational walking robot, descended from the Otto/BoB Thingiverse lineage (original concept by k120189, Thingiverse 43708). Designed entirely in FreeCAD so every part is editable and remixable. Licensed CC-BY-SA 4.0. Source: https://github.com/JavierIH/zowi Hardware: 4 Futaba S3003 (or compatible) servos BQ ZUM BT328 or Arduino-compatible board 4xAAA battery holder The repository ships the canonical body/chassis/leg/foot STLs plus a deep mods folder with remix variants: Forge, IronZowi, JIM, Kobuki, MicroRaider, Scopum, Zowarrior, Zowimanoid, Zowiquilator. Also includes Arduino code, schematics, and Spanish-language docs. Resources: Original Thingiverse concept: http://www.thingiverse.com/thing:43708 DIWO blog (Spanish): http://diwo.bq.com/zowi-introduccion-a-los-robots-bipedos/ License: CC-BY-SA 4.0. Printing Zowi is a 4-servo biped (Otto-family). The complete printed set is just five parts: body, chassis, leg, footL, and footR. Print one of each. footL and footR are a mirror pair (left and right feet) and are both required — they are not alternates. The LED-matrix mouth and ultrasonic/sensor modules are off-the-shelf electronics and are not printed. This Print All list was cleaned up to contain only the canonical Zowi parts. The upstream source repository also hosts several community remixes/mods (e.g. Forge, IronZowi, JIM) with their own arms, hands, heads, shields, and full-body redesigns; those are separate alternate builds, not part of the stock 4-servo Zowi, and have been removed along with a set of duplicate re-imported core files so the list yields exactly one buildable robot.

1,382 stars on GitHub. Stack-chan — Palm-Sized Companion Robot Stack-chan is a palm-sized, open-source companion robot driven by an M5Stack microcontroller and JavaScript firmware. Created by Shinya Ishikawa, Stack-chan sits on your desk, turns its head to watch you, expresses emotions on its built-in display, and responds through speech. Source: https://github.com/stack-chan/stack-chan Capabilities Servo-driven head gaze/tracking Emotive faces (happy, angry, sad) + fully customizable face expressions Speech synthesis Composable behaviors ("mods") — mix and layer: expressions, tracking, speech, M5Unit addon support Programmable in JavaScript on the Moddable SDK (embedded JS framework; no C/Arduino required) Servo Paths — Pick Before You Print Two mutually exclusive configurations that change both the case geometry and electronics: | Path | Servos | Notes | |------|--------|-------| | PWM | SG90 / MG90S | Simpler, cheaper, standard hobby servo wiring | | Serial TTL | RS30X series | Smoother motion, requires a buffer IC and serial-servo case geometry | Picking a path determines which STL set and which PCB you build. Build Notes Requires a custom PCB — order Gerbers from JLCPCB/PCBWay ( directory in the repo) Modular 46-part printable enclosure (shell, bracket, feet, spacer, accessories: hat, backpack variants, Lego adapter) An official commercial M5Stack version (StackChan) is available; the open-source org fork is the reference for DIY Metadata GitHub stars: 1,382 Author: Shinya Ishikawa & community License: Apache 2.0 Links Firmware () STLs () Schematics + PCB () Roadmap Demo video (YouTube, EN subs)

The LeRobot Humanoid (Biped Platform) is a fully open-source, 3D-printed humanoid biped robot developed by Virgile Batto and the Hugging Face LeRobot team. Powered by a Raspberry Pi 5 and 12 RobStride CAN-FD actuators arranged across two legs (6 degrees of freedom per leg, 12 DOF total), it represents a serious open-hardware effort to make capable humanoid locomotion accessible to researchers and advanced builders worldwide. Every mechanical, electrical, and firmware artifact is freely available under the Apache 2.0 license, from the Onshape CAD source to the bill of materials to the motor commissioning scripts. Creator & License Author: Virgile Batto (Hugging Face LeRobot team) License: Apache 2.0 Hardware repository (CAD, BOM, assembly docs, STLs): https://github.com/Virgileboat/lerobot-humanoid-hardware Runtime repository (motor control, gait, model inference): https://github.com/Virgileboat/lerobot-humanoid-runtime Public Onshape CAD document (start here for design exploration): https://cad.onshape.com/documents/fb645318a27646d1d8840be6/w/d1cae8805fb652b4d1614997/e/804a1da43f242001a05129b4 All build assets — STL files, BOM CSVs, wiring diagrams, motor commissioning scripts — are republished here under the same Apache 2.0 terms. Printing The Print All set is complete — all 47 unique STLs for one full biped. Both legs are present as proper left/right mirror pairs ( = left, = right). There are no missing parts and no alternates to deselect. The build uses ~75 printed pieces from these 47 files because several parts repeat. Until per-file print-multiples are supported, print the quantities below: Print x4 each (bearing spacers, shared across both legs): , , , Print x2 each (repeated per leg / both u-joints): , , , , , , , , , , , Print x1: every other file (the remaining torso, hip, femur and tibia parts — each left/right mirror is its own file). Total: 47 files → ~75 physical parts (3–4 kg PLA+). Left and right parts are true mirrors and not interchangeable. Hardware Requirements This robot is BYOD (Bring Your Own Device). The orobot-firmware layer does not currently support RobStride CAN-FD actuators; all joint control runs directly on the Raspberry Pi through the lerobot-humanoid-runtime repository. The orobot program record here serves as a build reference, asset hub, and control-interface stub. Required hardware: Raspberry Pi 5 (8 GB recommended) — primary compute SAVVYCANFD 2CH CAN-FD adapter (USB, dual channel, 12 Mbps max) — connects Pi to motor bus 12 × RobStride actuators: 2 × RobStride O0 (torso/hip yaw) 2 × RobStride O2 (hip Z) 4 × RobStride O3 (thigh) 4 × RobStride O5 (shin) IMU: BNO055 or BNO085 breakout board Mechanical: ~75 custom 3D-printed PLA+ parts, plus precision bearings and fasteners per BOM Specifications | Parameter | Value | |-----------|-------| | Degrees of freedom | 12 (6 per leg) | | Actuators | 12 × RobStride (CAN-FD) | | Estimated print weight | ~3–4 kg PLA+ | | Estimated total cost | ~$2,636 USD | | Skill level | Advanced | | Build time | Multi-week (motor commissioning → print → assembly → wiring → bring-up) | | CAD source | Onshape (public, link above) | | Control protocol | RobStride CAN-FD over USB adapter | Build Start Sequence Order long-lead items (motors, bearings, shoulder screws from ) first — they can take weeks. Print STLs per (~3–4 kg PLA+; orientation matters for structural leg parts). Commission and ID every motor before any mechanical assembly — protocol or ID errors after assembly require disassembling the leg to fix. Full step-by-step at lerobot-humanoid-hardware. Safety > High-torque actuators — a physical E-stop is required and must be accessible at all times during powered operation. See for the full bring-up checklist. Attribution This program page was created by the orobot BROKER-2 index to help builders find and start this project. All design credit goes to Virgile Batto and the Hugging Face LeRobot team. Please star the source repos if this build helps your project.

ToddlerBot is a low-cost, open-source humanoid robot platform designed for scalable policy learning and research in robotics and AI. Standing approximately 50cm tall and weighing around 2.5kg, it features 23 Dynamixel servo motors (XC330 or XM430 series), a Jetson Orin NX compute module, custom TTL power PCB, stereo depth camera, and 6-axis IMU. The codebase covers low-level control, reinforcement learning training with MuJoCo/MJX, diffusion policy training, and real-world deployment. Two variants are available: (budget-friendly, XC330 motors) and (stronger, XM430 motors). Supported capabilities include bipedal walking, whole-body locomotion over obstacles, keyframe animation playback, VR teleoperation, and loco-manipulation. Attribution Author: Haochen Shi, Weizhuo Wang, Shuran Song, C. Karen Liu (Stanford) License: Code: MIT · Hardware design (STL/CAD): CC BY-NC-SA 4.0 Source: https://github.com/hshi74/toddlerbot Papers: ToddlerBot (2025) · Locomotion Beyond Feet (2026) CAD: Onshape · MakerWorld --- Printing ⚠️ This Print All set is incomplete and not yet build-ready. ToddlerBot is a 23-DOF humanoid that needs roughly 50 printed structural parts, but this list currently holds only 12 — and those 12 are meshes auto-imported from the robot’s URDF/simulation description, not the official print files. The set is also left/right asymmetric (e.g. , , , are present with no right-side counterparts), so it cannot build a complete robot as-is. Where the real print files live: the ToddlerBot authors distribute the printable parts as a ready-to-slice 3MF release on MakerWorld () and as editable CAD on Onshape — both linked in the Attribution section above. The upstream GitHub repo () contains only MuJoCo / simulation meshes organized by servo/config variant (, , gripper/palm options), not a clean printable STL set, so a faithful set can’t simply be pulled from git. To build one: download the MakerWorld 3MF release for your chosen variant — (budget XC330 motors) or (stronger XM430 motors) — and print on a BambuLab-class printer using the included orientations/profiles (part strength depends on correct orientation). Most limb/link parts come in mirrored left/right pairs. The 12 meshes here are kept as a structural reference/preview only. (Catalog note: this is a known gap — the importer pulled sim meshes instead of the MakerWorld print set; see the related platform issue about importer mesh filtering.)

pib is a fully open-source, 3D-printable humanoid robot developed by pib-rocks. Designed to be built at home or in a classroom, pib features articulated arms with five-fingered hands, a rotating head with camera, and a Raspberry Pi brain running ROS2 (Robot Operating System). The robot ships with a web-based control interface called Cerebra, which lets you program behaviors with visual Blockly blocks or Python, stream video from the head camera, and control individual finger and arm joints in real time. All mechanical parts are printable — the body, arms, forearms, hands with individual finger bones, shoulder joints, and head — making pib one of the most accessible humanoid robot projects available. The backend uses Docker containers for easy deployment on a Raspberry Pi 4 or 5. Attribution Author: pib-rocks (https://github.com/pib-rocks) License: MIT Source: https://github.com/pib-rocks/pib-backend Website: https://pib.rocks

Asimov v0 is an open-source bipedal leg assembly for humanoid robots, built by Menlo Research (Asimov Inc). The design features 12 degrees of freedom total (6 DOF per leg) with an articulated toe and a novel RSU (Revolute Spherical Universal) ankle mechanism. All parts are MJF 3D printing compatible and use off-the-shelf actuators from Encos. The robot uses brushless DC motors across hip pitch/roll/yaw, knee pitch, and dual-motor ankle A/B joints — with peak torques ranging from 36 Nm at the ankle to 120 Nm at the hip pitch. A complete URDF/MuJoCo simulation model and STEP files for the lower body are included in the repository. Attribution Designed by Menlo Research / Asimov Inc. Source: github.com/asimovinc/asimov-v0. License: see LICENSE.txt in repository. Community: discord.gg/HzDfGN7kUw.

RoboPrime is a full-featured 21-DOF, 3D-printed bipedal humanoid built around a $10-class Arduino Pro Micro (ATmega328p). Every joint is an MG90S 9g micro servo, driven through a pair of 74HC4017 Johnson decade counters that let a single microcontroller address up to 20 servos over one interrupt-driven serial-servo channel — a clever hack that avoids needing a dedicated servo driver board. An HC-05 Bluetooth module gives wireless serial control from a phone or PC, and an onboard MPU-6050 IMU is present in hardware for future balance work (unused in the shipped firmware). Two full physical builds (v1 and v2) exist with photos, plus a soldered custom carrier board, hand-wired point-to-point on protoboard. The firmware implements a small command language (S0-S3, Q0, C0) for single-servo moves, timed sweeps, queued/synchronized movement planning, and calibration, plus three working hardcoded animations: Hello (wave), Sit Down, and a cheeky third gesture. Walking gaits are stubbed in the animation table but marked work-in-progress by the original author. Built by Simone Primarosa (simonepri) and shown at Maker Faire Rome. Originally documented as a high-school capstone project (write-up in Italian, linked from the source README). This orobot.io program is a control-interface port — it re-expresses the original robot's home/hello/sit-down/stand-up choreography using orobot's motor/pose/sequence model so you can drive RoboPrime from the browser Operator panel. The original ATmega328p + HC-05 firmware is not orobot-firmware-compatible out of the box; see Required Hardware below. Full source (firmware, wiring, 3D models) is on GitHub. Source: https://github.com/simonepri/roboprime License: GPL-3.0 (project) / MIT (firmware files) Original author: Simone Primarosa — https://github.com/simonepri

Berkeley Humanoid Lite is an open-source, sub-$5,000 humanoid robot from UC Berkeley's Hybrid Robotics lab — a full 22-DOF biped (12 leg joints + 10 arm joints) built around modular, fully 3D-printed cycloidal gearboxes and widely available off-the-shelf parts. It was created to democratize humanoid-robotics research: every actuator is printed and hand-assembled, the electronics are commodity, and the entire software stack — RL policy training, sim-to-sim/sim-to-real, teleoperation, and low-level control — is open. The robot walks (bipedal locomotion via a learned RL policy), and with its two 5-DOF arms and grippers it performs bimanual manipulation: solving a Rubik's cube, writing with a marker, and stacking blocks. Perception and control run on an onboard x86 mini-PC; joints connect over CAN bus through custom STM32 (B-G431B-ESC1) motor controllers running the open "recoil" firmware, with a BNO085 IMU for balance. What this orobot program is This is a browser-based learning interface and entry point. The in-page 3D viewer shows the robot's per-link meshes, and the Robot Operator panel drives the 22 joints through poses and demo sequences (stand, wave, squat, march) so you can understand the kinematic layout. It is not the balancing locomotion controller — that lives in the low-level repo below. Use this to learn the layout, then dive into the source to build and deploy the real thing. Build it for real Paper (arXiv 2504.17249): https://arxiv.org/abs/2504.17249 Project site: http://lite.berkeley-humanoid.org/ Build docs (GitBook): https://berkeley-humanoid-lite.gitbook.io/docs Video: https://youtu.be/dIdJGkMDFl4 Main repo (training + deploy): https://github.com/HybridRobotics/Berkeley-Humanoid-Lite Low-level control (CAN + RL runtime): https://github.com/HybridRobotics/Berkeley-Humanoid-Lite-Lowlevel CAD / URDF / MJCF / STL assets: https://github.com/HybridRobotics/Berkeley-Humanoid-Lite-Assets Highlights 22 DOF — two 6-DOF legs + two 5-DOF arms, built from two modular actuator types (10× M6C12, 12× 5010) Fully 3D-printed actuators — cycloidal gearboxes in PLA around MAD M6C12 (150KV) and 5010 (110KV) BLDC motors Commodity BOM — ~$205 per M6C12 actuator, ~$154 per 5010; $4,794 for the whole robot at verified September 2026 prices (filament excluded) URDF / MJCF / USD descriptions included — sim-ready in Isaac Lab & MuJoCo RL locomotion + bimanual manipulation — trained policies (ONNX) ship in the repo Attribution Created by Yufeng Chi, Qiayuan Liao, Junfeng Long, Xiaoyu Huang, Sophia Shao, Borivoje Nikolic, Zhongyu Li, and Koushil Sreenath (UC Berkeley Hybrid Robotics). Code licensed MIT; hardware/CAD assets licensed CC BY-SA 4.0. This program mirrors their open-source project as a learning entry point — all credit to the original authors.