LeRobot Humanoid - Robot to modify and learn from

A humanoid you can build, modify, and learn from 

Humanoid robots are becoming an increasingly important target for robot learning. They are general-purpose, human-scale platforms, able to interact with the same objects, tools, and environments as we do. But today, experimenting with humanoids remains difficult: the hardware is often expensive, closed, fragile, or hard to reproduce.
 

This creates a bottleneck for open robot learning. Even when models, datasets, simulators, and training code are released, the physical platforms used to generate data and validate policies often remain inaccessible. Many people can train policies in simulation, but only a small number of labs can close the loop on real humanoid hardware.
 

LeRobot Humanoid is designed for a specific niche: an open humanoid platform that is affordable enough to reproduce, simple enough to modify, and complete enough to support real robot-learning experiments.
 

If you are looking for the most advanced humanoid robot, this is not it.
If you are looking for a humanoid you can build, understand, repair, instrument, simulate, and use for learning experiments, this is the robot we are trying to make.
 

This is why the release includes more than a robot model or a controller. It includes hardware files, assembly documentation, simulation assets, runtime tools, identification pipelines, and training environments. The goal is to make the full humanoid learning loop accessible, from mechanical design to real-world control.

Source (check for updates and detailed infos):

https://github.com/Virgileboat/lerobot-humanoid 
https://huggingface.co/blog/VirgileBatto/lerobot-humanoid 

BOM:
https://github.com/Virgileboat/lerobot-humanoid-hardware/blob/main/hardware/bom/bom_buy.md 
(see also attached file bom_buy.csv)

(scroll down for price overview)
motors

torso

Comment: cheaper or better CAN-FD adapters may exist, but this one is currently the only adapter proven in this project to handle the RobStride CAN protocol.

hipx

hipz

thigh

knee_mechanism

shin

ankle_mechanism

ankle

foot

assembly_pins

tools

Price:
The actuators do most of the cost, but you sure need actuators in that price range for a working humanoid robot.

(see detailed list here: https://github.com/Virgileboat/lerobot-humanoid-hardware/tree/main)
 

-------------

Motor Commissioning

https://github.com/Virgileboat/lerobot-humanoid-hardware/blob/ae8abe99f3677b85f41f0dda122d504d5debfd9f/docs/electronics/motor_commissioning.md 

• RobStride official product information: https://github.com/RobStride/Product_Information
• RobStride official site (motors): https://www.robstride.com/

The mostors are the key for this project, they are actually cheap compared with other brands.
Commission every motor before mechanical assembly. 

Preconditions

• Connect only one motor on the CAN bus during commissioning.
• Adapter: SAVVYCANFD 2CH CANFD adapter (currently the only proven one in this project).
• Linux CAN interface is up (example: can0).

Recommended Command

https://github.com/Virgileboat/lerobot-humanoid-hardware/blob/ae8abe99f3677b85f41f0dda122d504d5debfd9f/hardware/config/commission_motor.py 

python commission_motor.py wizard --channel can0

What the Wizard Does

1. Detects motor ID and active protocol (CANopen, private, or MIT).
2. Switches motor to MIT protocol (with required reboot checkpoints).
3. Applies final motor ID according to motor model mapping.
4. Reboots and verifies final ID and protocol (MIT).
5. Runs motion check: set zero, enable, move to 90 deg for 1 s, then back to 0 deg, then disable motor.

Final ID Map

• RobStride O0: IDs 1, 7
• RobStride O2: IDs 2, 8
• RobStride O3: IDs 3, 4, 9, 10
• RobStride O5: IDs 5, 6, 11, 12

Use one motor at a time and assign one of the allowed IDs for its model.

Batch Policy for This Robot

• Repeat the same process for each motor individually.
• Keep a log table: serial, final_id, final_protocol, commissioning_date.

-----------

Assembly Guide

https://github.com/Virgileboat/lerobot-humanoid-hardware/blob/ae8abe99f3677b85f41f0dda122d504d5debfd9f/docs/assembly/assembly_guide.md 

Assembly order:

1. Configure all motors (see commissioning).
2. Print all STL parts (all parts are sorted in the mf3.file).
3. Build torso first.
4. Build upper legs in order: hipx -> hipy (hipz in repo naming) -> thigh (left and right).
5. In parallel, build lower legs in order: foot -> ankle -> knee_mechanism -> shin -> ankle_mechanism (left and right).
6. Assemble upper and lower leg modules.
7. Integrate both legs to torso and run wiring checks.

Common assembly rules:

• For each subassembly, insert bearings first (press or gentle hammer).
• Place motor goupille/pin during the same phase as bearing insertion.
• Exception: in knee_mechanism and ankle, one interface should stay slightly loose but still movable.
• For subassembly goupilles: place them during assembly except on thigh (keep thigh demountable).
• Motor orientation is critical: follow the Onshape assembly orientation relative to each motor connector, otherwise cable length can become insufficient.
• Default thread strategy is direct screw in plastic; use around 5 Nm for non-structural plastic threads.
• For motor threaded holes and structural insert zones, use higher torque appropriate to the thread/material.
• Some fits are intentionally tight; if required, gently ream/drill with a metal bit at low speed.
• Pins are not a standalone assembly stage: install them inside each motor/subassembly during build.
• Tools are prerequisites only (not assemblies).

Leg cabling note:

• Left and right legs use the same sub-cable design and routing logic.
• Cable legend: red = power, green = CAN, blue = CAN + power.

Leg cabling integration order (both legs):

1. Prepare three sub-cables using hardware/electronics/cabling/README.md: shin, thigh, hip pass-through.
2. Install the shin sub-cable during shin assembly, before final closure.
3. Install the thigh sub-cable during thigh assembly, before final tightening.
4. Route the hip pass-through sub-cable during hipz integration.
5. Join leg cables to torso harness during final leg-to-torso integration.

torso
 

Components:

STL To Print:

Comment: cheaper or better CAN-FD adapters may exist, but this one is currently the only adapter proven in this project to handle the RobStride CAN protocol.

Assembly steps:

1. Assemble each torso motor on its motor support and screw it.
2. Place each motor-support subassembly on top of the bearing stack and screw it.
3. Verify both torso motor outputs rotate freely after tightening.

hipx

Components:

Comment: the hipx M3 screw line is optional and can be removed without issue.

STL To Print:

Assembly steps:

1. Start by inserting the hip axis and fixing it to the motor.
2. Align hipx parts on the previous subassembly and screw the full assembly.
3. Verify hipx motion is free with no hard point.

hipz

Components:

STL To Print:

Assembly steps:

1. Insert hipz bearings.
2. Start by inserting the axis and fixing it to the motor (hipz naming in this repo corresponds to the hipy joint).
3. Place and screw the motor.
4. Route the hip pass-through sub-cable through hipz according to hardware/electronics/cabling/README.md.
5. Assemble the bearing to the hipz assembly and verify free motion.

thigh

Components:

STL To Print:

Assembly steps:

1. Insert the exterior thigh shell (femur_22) into the hipy joint side first (hipz naming in this repo).
2. Fix femur_12 to the hipy/hipz side.
3. Install and route the thigh sub-cable before final closing (hardware/electronics/cabling/README.md).
4. Screw femur_12 and femur_22 together once joint alignment is correct.
5. Do not lock thigh with permanent goupilles if you want it demountable.

foot

Components:

STL To Print:

Assembly steps:

1. Insert foot bearings and pins/goupilles.
2. Assemble and screw foot parts.
3. Check foot alignment before full tightening.

ankle

Components:

STL To Print:

Assembly steps:

1. Assemble U-joint parts and install pins/goupilles.
2. Insert the assembled U-joint into shin bearings (bearings are installed in the shin subassembly, not in ankle STL parts).
3. Keep one ankle interface slightly loose but still movable.
4. Verify free ankle motion after tightening.

knee_mechanism

Components:

STL To Print:

Assembly steps:

1. Pre-assemble the knee mechanism with its motor and rods.
2. Keep the knee interface slightly loose but still movable.
3. Integrate this knee mechanism inside the shin assembly first.
4. Fix the knee motor to the thigh at the end of leg integration.
5. Check that knee motion is smooth and not binding.

shin

Components:

STL To Print:

Assembly steps:

1. Install M3 inserts first (4 per shin).
2. Insert bearings and pins/goupilles.
3. Mandatory: place the full knee mechanism (including motor) inside before final shin closure.
4. For re-assembly in tight fit conditions: gently shift the bearing with light hammer taps to create spacer clearance, insert spacer, then re-seat bearing.
5. Install and route the shin sub-cable before closure (hardware/electronics/cabling/README.md).
6. Preferable: place ankle module now (recommended, not mandatory).
7. Close and screw shin structure, then verify internal parts still move.

ankle_mechanism

Components:

STL To Print:

Assembly steps:

1. Install spherical joints on rods (2 per rod, 4 per leg, 8 per robot).
2. Assemble rods, spacers, and ankle actuation parts, then screw.
3. Verify mechanism moves freely through its range.
    

--------

Code / Training

Now the real work begins, programming and training this robot.
But sadly we hit the maximal post size, so for more visit the GitHub pages.
The project is from May 2026, so its brand new and the work is still progressing.
And yes, we still need the upper half of the robot, all this will follow hopefully.
https://github.com/Virgileboat/lerobot-humanoid 
https://github.com/Virgileboat/lerobot-humanoid-runtime 

https://github.com/Virgileboat/lerobot-legged-zoo