Build Your Own Humanoid Robot Under $5000 with Berkeley Humanoid Lite

Want to own a humanoid robot but can't justify the six-figure price tag of platforms like Unitree H1 or Figure 02? Researchers at UC Berkeley's Hybrid Robotics Lab have just open-sourced Berkeley Humanoid Lite — a fully 3D-printed humanoid robot platform costing under $5,000, capable of walking via zero-shot sim-to-real reinforcement learning policy transfer.

This article walks you through everything: understanding the paper, sourcing components, 3D printing, assembly, RL training, and deploying on real hardware.

Project Overview

Berkeley Humanoid Lite was presented at RSS 2025 (Robotics: Science and Systems) in the paper Demonstrating Berkeley Humanoid Lite: An Open-source, Accessible, and Customizable 3D-printed Humanoid Robot by Yufeng Chi, Qiayuan Liao, Junfeng Long, Xiaoyu Huang, Sophia Shao, Borivoje Nikolic, Zhongyu Li, and Koushil Sreenath.

Why This Project Matters

Most research humanoid robots cost $50,000 to hundreds of thousands of dollars. Berkeley Humanoid Lite breaks this barrier:

• Ultra-low cost: ~$4,312 (US sourcing) or ~$3,236 (China sourcing)
• Fully 3D-printable: All custom mechanical parts printable on consumer FDM printers (200×200×200 mm build volume)
• 100% open-source: Hardware designs, embedded code, and training frameworks — all publicly available
• Zero-shot sim-to-real: Train a policy in Isaac Gym, deploy directly to real hardware without fine-tuning

Key Specifications

System Architecture

Mechanical Design: 3D-Printed Cycloidal Gearbox

The most innovative aspect is the 3D-printed cycloidal gearbox made from PLA. Why cycloidal over planetary gears?

• Planetary gears require tight manufacturing tolerances — 3D-printed PLA versions suffer from excessive backlash and rapid wear
• Cycloidal gears distribute loads across multiple teeth simultaneously, tolerating FDM printing resolution much better
• Test results: transmission stiffness of 319.49 Nm/rad, backlash of only 0.0229 rad (max), ~90% mechanical efficiency

The team also embeds brass hex stands into printed parts to prevent layer-boundary failures and merges sub-components into single prints to reduce stress concentration points.

Two Actuator Types

6512 Actuator (legs — high torque):

• Motor: MAD Components M6C12 150KV BLDC
• Driver: B-G431B-ESC1
• Encoder: AS5600
• Max torque: ~20 Nm
• Cost: ~$188/unit

5010 Actuator (arms — lighter):

• Motor: 5010 BLDC
• Driver: B-G431B-ESC1
• Encoder: AS5600
• Cost: ~$136/unit

Electronics & Communication

Intel N95 Mini PC (onboard)
    ├── USB-CAN adapter #1 → CAN bus → Left leg (3 hip + 1 knee + 2 ankle)
    ├── USB-CAN adapter #2 → CAN bus → Right leg
    ├── USB-CAN adapter #3 → CAN bus → Left arm (5 DOF)
    ├── USB-CAN adapter #4 → CAN bus → Right arm (5 DOF)
    └── USB → Arduino → BNO085 IMU

Each CAN bus runs at 1 Mbps, supporting up to 64 devices. The modular design means each actuator needs only power and CAN connection to function independently.

Bill of Materials — Detailed Cost Breakdown

6512 Actuator (×10 for legs)

5010 Actuator (×12 for arms)

Complete Robot Assembly

Tip: Sourcing from Taobao/AliExpress can save ~25% compared to US pricing. Motors and bearings show the biggest price difference.

3D Printing Requirements

Printer Specifications

• Minimum build volume: 200 × 200 × 200 mm — most consumer FDM printers qualify (Ender 3, Bambu Lab A1, Prusa MK4...)
• Material: Standard PLA filament (no need for carbon fiber or nylon)
• Print time: All custom parts printable within approximately one week
• Assembly time: ~3 days for the complete robot

Critical Printing Tips

1. Check tolerances: Cycloidal gears need reasonable accuracy. Print one test gear set first, verify meshing, then batch print
2. Brass inserts: Screw holes need heat-set brass inserts — provides strong threads and prevents layer delamination
3. Print orientation: Follow the original documentation's recommended orientations — directly affects load-bearing strength
4. Infill: Use 40-60% infill for load-bearing parts (hip joints, knees), 20% is fine for cosmetic shells

RL Policy Training with Isaac Gym

This is the most exciting part — teaching the robot to walk using Reinforcement Learning.

Environment Setup

Berkeley Humanoid Lite uses Isaac Lab (the successor to Isaac Gym) as the simulation environment. Main repository:

# Clone the repo
git clone https://github.com/HybridRobotics/Berkeley-Humanoid-Lite.git
cd Berkeley-Humanoid-Lite

# Directory structure
# source/berkeley_humanoid_lite/        → IsaacLab environment & task definitions
# source/berkeley_humanoid_lite_assets/  → Robot descriptions (URDF, MJCF, USD)
# source/berkeley_humanoid_lite_lowlevel/ → Code for the real robot

Prerequisites

• GPU: NVIDIA GPU with CUDA support (RTX 3060+ recommended)
• Isaac Lab: Install following NVIDIA's official guide
• Python: 3.8+

Two Training Tasks

1. Velocity-Berkeley-Humanoid-Lite-v0: Trains a policy controlling all 22 DOF (including arms)
2. Velocity-Berkeley-Humanoid-Lite-Biped-v0: Controls only the 12 leg DOF — recommended starting point

Observation Space

The policy receives at each timestep:

• Angular velocity of the robot base (from IMU)
• Projected gravity vector — indicates robot tilt
• Joint positions and joint velocities — state of all 12 leg joints
• Commanded velocity — user-desired velocity
• Previous action — last timestep's action (helps smooth behavior)

Action Space

Policy output: desired joint positions for each joint. The actuator controller tracks these via PD control.

Running Training

# Train biped locomotion (12 DOF legs)
# Default: 6000 iterations
# Time: ~2 hours on RTX 3090

python train.py --task Velocity-Berkeley-Humanoid-Lite-Biped-v0

The algorithm is PPO (Proximal Policy Optimization) — the most widely used RL algorithm for locomotion. If you're new to PPO, check out our RL fundamentals article first.

Domain Randomization

To enable zero-shot sim-to-real transfer, training includes domain randomization on:

• Link masses and inertias
• Ground friction
• Actuator delays and noise
• Sensor noise (IMU, encoders)

This is standard practice in sim-to-real transfer for humanoids — by training across many environment variations, the policy learns to adapt rather than overfit to a specific simulation.

Deploying to Real Hardware

Sim-to-Real Pipeline

1. Export policy: After training, export the model as ONNX or TorchScript
2. Flash firmware: Upload embedded code to motor drivers (B-G431B-ESC1) via CAN bus
3. Run inference: Mini PC (Intel N95) runs the policy at 25 Hz, sending desired joint positions via CAN bus to each actuator

# Deploy policy to real robot
# Connect Mini PC to CAN bus
# Run inference script

python deploy.py --model path/to/trained_policy.pt

Real-World Results

• Zero-shot transfer success: Simulation-trained policy works directly on real hardware
• Torque utilization: Only ~30% of max actuator torque used during walking — significant headroom remaining
• Teleoperation: Supports remote control via SteamVR controllers, both third-person and VR first-person modes
• End-effector accuracy: Position error of only 3.433 mm (std) when tracking spatial targets

Demonstrated Tasks

• Bipedal walking with velocity tracking
• Handwriting
• Packing/unpacking objects
• Rubik's Cube solving
• Remote teleoperation

Durability — Can PLA Actually Handle This?

This is the biggest question when you hear "3D-printed humanoid robot." The researchers tested extensively:

60-Hour Continuous Test

• Actuator repeatedly lifting 0.5 kg pendulum, swinging from -45° to +90° at 0.5 Hz
• Efficiency initially declined then recovered to near baseline levels
• Backlash growth was negligible

Cross-Unit Consistency

• 6 actuators tested from 2 different printers
• Torque tracking error: only ±0.5 Nm across the full operating range
• Conclusion: cycloidal gear design is robust enough for FDM manufacturing

Comparison with Other Platforms

Berkeley Humanoid Lite introduces a Performance-per-Dollar (φ) metric for fair comparison:

$$\hat{\rho} = \frac{1}{N \cdot h \cdot m \cdot g} \sum |τ_i^{max}|$$

Where N = DOF count, h = height, m = mass, τ = max torque. Result: Berkeley Humanoid Lite achieves significantly higher φ compared to commercial platforms costing 10-20× more.

Resources and Community

Suggested Build Timeline

If you want to get started, here's a realistic schedule:

1. Week 1: Read the paper, study docs, create BOM list and order components
2. Weeks 2-3: Print all custom parts (printer running ~1 week continuously)
3. Weeks 3-4: Assemble actuators, test each unit individually before mounting
4. Weeks 4-5: Complete robot assembly, wire CAN buses, flash firmware
5. In parallel: Set up Isaac Lab, train RL policy (~2 hours GPU time)
6. Weeks 5-6: Deploy policy, calibrate, and take those first steps!

If you're exploring humanoid control architectures or MPC vs RL for locomotion, that knowledge will deepen your understanding of why Berkeley Humanoid Lite chose RL over model-based control.

Conclusion

Berkeley Humanoid Lite isn't just a cool project — it's a turning point in democratizing humanoid robotics research. For the cost of a high-end gaming laptop, you can own and experiment with a real humanoid robot platform, complete with a full sim-to-real pipeline.

The most important takeaway: this project proves that 3D-printed cycloidal gearboxes are durable and precise enough for humanoid locomotion — opening the door for countless community-driven variations and improvements.

Related Posts

• Reinforcement Learning for Robotics — From Basics to Applications
• Humanoid Robot Control Architectures
• The Chinese Humanoid Robot Race 2026