Contents
Figure 1: GitHub Repos for Robot Learning — you want to teach a robot to do something useful. Maybe you own a $200 arm, maybe you have a GPU and a dream of a walking humanoid. Three repos keep showing up.
You want to teach a robot to do something useful. Maybe you own a $200 arm, maybe you have a GPU and a dream of a walking humanoid. Three repos keep showing up: LeRobot, Genesis, and Unitree RL Lab. They sound like competitors, but they are not. They sit at different layers of the robot learning stack, and picking the wrong one means weeks of setup for the wrong problem.
I cannot claim I have trained robots with all three, so I will give you my honest analysis from their READMEs, docs, and announcements. My search also surfaced many forks and mirrors, so verify everything on the official repos. IMO, the first question is not "Which is best?" but "Which layer do I need?" Ready to sort it out?
The Three Layers of Robot Learning
Here is the mental model I use:
- Data and policies: you collect demonstrations, then train a model that outputs actions (LeRobot lives here)
- Simulation: you build a virtual world where robots practice safely and fast (Genesis lives here)
- Robot-specific RL training: you train locomotion or control policies in simulation and deploy them to a particular robot (Unitree RL Lab lives here)
Ever tried to learn robotics by installing everything at once? Layer by layer works better.
LeRobot: End-to-End Learning on Affordable Hardware
LeRobot, from Hugging Face, provides models, datasets, and tools for real-world robotics in PyTorch, with the goal of lowering the barrier to entry so everyone can contribute to shared datasets and pretrained models. The docs describe a hardware-agnostic, Python-native interface for controlling real robots, from affordable arms like the SO-101 to full humanoids. GitHub Hugging Face
The Workflow
The docs summarize it as teleoperate, record, train, deploy. You control the robot yourself with a leader arm, keyboard, or phone. Each demonstration becomes a dataset of synchronized camera video plus your actions. Then you train a policy on that data and run it on the robot. Hugging Face
What's Inside
- Standardized dataset format: LeRobotDataset uses Parquet plus MP4 or images, hosted on the Hugging Face Hub for efficient storage, streaming, and visualization. One Hub blog says the format already serves over 90,000 datasets and models from more than 8,000 publishers. GitHub Hugging Face
- Policy zoo: the README lists imitation learning policies including ACT, Diffusion, VQ-BeT, and Multitask DiT, plus reinforcement learning with HIL-SERL, with TDMPC and QC-FQL coming soon. The docs also mention vision-language-action models like π₀ and SmolVLA. GitHub Hugging Face
- A friendly first policy: the docs call ACT their recommended first policy. Hugging Face
- Hardware support: the docs name the SO-101 as the flagship low-cost arm, LeKiwi as a mobile base with an arm, and Koch v1.1 as a community favorite. Hugging Face
- No robot required to start: the docs say you can train on existing Hub datasets, evaluate in simulation against benchmarks like LIBERO or Meta-World, and use free Colab notebooks. Hugging Face
- Browser GUI: LeLab offers teleoperating, calibrating, recording, replaying, and training from the browser, with no CLI required. GitHub
The v0.5.0 release notes describe more robots including a first humanoid, more policies, simulation environments loadable from the Hub, and a modernized codebase on Python 3.12 and Transformers v5. Hugging Face
What to Watch
- Mostly imitation learning: the README's RL list is short, and some entries are marked as coming soon. If you want PPO-style locomotion training, look elsewhere.
- Fast version changes: a release this size means API shifts, so pin your version.
- Hardware reality: real arms need calibration, assembly, and patience. One integration post notes that both leader and follower devices need calibration files before recording. Hugging Face
I would pick LeRobot if I want to teach a real arm manipulation tasks from demonstrations, or if I want to learn modern robot policies like ACT and VLAs.
Genesis: A Fast, Unified Physics Simulator
Genesis describes itself as a physics platform for general-purpose robotics, embodied AI, and physical AI applications. Its key idea is a universal physics engine that integrates various solvers and their coupling in one framework. Those solvers cover rigid body, MPM, SPH, FEM, PBD, and stable fluid. In plain language: it can simulate robots, liquids, soft objects, and granular materials in one place. GitHub
What I Like
- Speed claims: the README advertises over 43 million FPS simulating a Franka arm on a single RTX 4090, about 430,000 times faster than real time. That is the project's own benchmark, so check conditions before you plan around it. GitHub
- Cross-platform: it runs on Linux, macOS, and Windows, with CPU, Nvidia GPU, AMD GPU, and Apple Metal backends. That is a big deal if you do not own an Nvidia machine. GitHub
- Differentiable physics: the README says it is designed to work with differentiable simulation, with the MPM and tool solvers differentiable so far and others to follow. GitHub
- Rendering: it includes native ray-tracing based rendering. GitHub
- Open license: the code uses the Apache 2.0 license. GitHub
What to Watch
- Partial open-sourcing: the README says the team is currently open-sourcing the underlying physics engine and simulation platform, while the generative agent layer sits above it. Do not assume every headline feature is available. GitHub
- Install details shift: it installs through PyPI as genesis-world after you install PyTorch, with Python version requirements that changed between README versions I saw. Check the current requirement before you build an environment. GitHub
- Maturity: it is a younger simulator than MuJoCo or Isaac, so expect rougher edges and faster change.
- Feature roadmap: some items, like tactile sensing, appeared as upcoming in one README, so verify current status.
I would pick Genesis if I want a fast, flexible simulator for experiments, especially with soft or fluid physics, or if I lack an Nvidia GPU.
Unitree RL Lab: Train Locomotion, Deploy to a Real Robot
Unitree RL Lab is narrower and more practical. The README says it provides reinforcement learning environments for Unitree robots, built on IsaacLab, and it currently supports the Unitree Go2, H1, and G1-29dof robots. GitHub
How It Works
The repo follows the standard sim-to-real pipeline:
- Install Isaac Lab and then install the Unitree package in editable mode
- Download robot models, which the README says come from a Hugging Face dataset repo
- Train with a command like
python scripts/rsl_rl/train.py --headless --task Unitree-G1-29dof-Velocity - Play the trained policy in simulation
- Deploy, where the README shows a C++ controller you build against unitree_sdk2, tested first against unitree_mujoco before a real robot
That sim-to-sim step in MuJoCo catches problems before hardware does. I like that the repo bakes it into the workflow.
The Family of Related Repos
Unitree publishes several sibling projects, and the names confuse people:
- unitree_rl_gym: the earlier framework, described as a reinforcement learning framework for Go2, H1, H1_2, and G1, with an older Python 3.8 setup
- unitree_rl_lab: the Isaac Lab version discussed here
- unitree_rl_mjlab: a project built on mjlab with MuJoCo as the physics backend, supporting robots including Go2, A2, As2, G1, R1, H1_2, and H2, and exporting ONNX policies for deployment onto physical robots
- unitree_lerobot: one inventory lists it as a LeRobot fork for G1 dual-arm imitation learning
- unitree_mujoco and unitree_sim_isaaclab: simulation environments
Notice the trend: Unitree's own repos now connect to LeRobot, Isaac Lab, and MuJoCo. The layers overlap more every month.
What to Watch
- Hardware requirements: Isaac Lab needs a capable Nvidia GPU and a heavy install
- Robot specificity: the repo targets Unitree robots, so it will not help with other hardware
- Real-robot safety: a falling humanoid can injure people and break expensive parts, so test in simulation, then with a harness, then carefully
- Maintenance signals: one snapshot of the org page showed the repo with 239 stars and an August 2025 update date, so check recent commits yourself GitHub
- Task coverage: the supported robot list differs across repos and README versions, so check the current list
I would pick Unitree RL Lab if I own a Go2 or G1 and want a proven path from training to deployment.
Quick Comparison
Here is my fast take on who fits where:
- LeRobot: best for learning manipulation from demonstrations on low-cost arms
- Genesis: best for fast, flexible simulation, including soft and fluid physics
- Unitree RL Lab: best for sim-to-real locomotion on Unitree robots
And a rougher split by goal:
- I have a cheap arm and want it to pick things up: LeRobot
- I want to prototype in simulation without an Nvidia GPU: Genesis
- I own a Unitree quadruped or humanoid: Unitree RL Lab
- I want PPO-style locomotion from scratch: Unitree RL Lab or similar Isaac Lab and MuJoCo stacks
- I want vision-language-action models: LeRobot
How These Fit Together
They can combine. For example, you could train manipulation policies with LeRobot on real demonstrations, use a simulator like Genesis for experiments and data generation, and use a Unitree stack for locomotion. One integration post even describes sim-to-real datasets in the same on-disk format, so a MuJoCo recording and a physical SO-101 recording match. Standard formats make that possible. Hugging Face
A Practical Starting Plan
Want a path instead of a pile? Try this:
- Learn the basics first: the Hugging Face Deep RL Course covers PPO and the vocabulary
- Start with LeRobot in Colab: train ACT on an existing Hub dataset, no robot needed
- Evaluate in simulation: run a benchmark like LIBERO before you touch hardware
- Try Genesis: reproduce a simple manipulation scene and time the simulation
- Read a locomotion stack: study Unitree RL Lab's reward and observation definitions
- Only then buy or touch hardware: start with an SO-101 or a simulated Unitree robot
- Test sim-to-sim: move policies between simulators before any real deployment
Common Mistakes to Avoid
- Skipping simulation. Real robots break, and breaking costs money and time.
- Trusting speed claims. Benchmark FPS numbers rarely match your scene.
- Ignoring calibration. Bad calibration ruins imitation data silently.
- Using unofficial forks. My searches returned many, so clone from the official organizations.
- Underestimating sim-to-real. Policies that work in simulation often fail on hardware, so randomize physics and test carefully.
- Neglecting safety. Use harnesses, kill switches, and clear space around humanoids and arms.
- Mixing up RL and imitation learning. LeRobot leans toward imitation, while Unitree RL Lab trains with RL.
Did you notice that most mistakes involve skipping a step, not choosing the wrong repo?
Final Thoughts
LeRobot gives you data and policies, Genesis gives you a fast simulator, and Unitree RL Lab gives you a locomotion pipeline for specific robots. Pick by layer, start in simulation, and respect the hardware. The field changes monthly, so verify versions and maintenance before you commit.
So pick one layer this week and finish one small project: train ACT on a public dataset, run a Genesis scene, or train a Go2 to walk in simulation. If it works, you have momentum. If your robot face-plants in simulation, congratulations: it is cheaper than doing it in your living room.
Frequently Asked Questions
Which repo should I start with if I own a cheap robot arm?
LeRobot. It supports affordable arms like the SO-101 and Koch v1.1, works with demonstrations, and does not require a robot to start training on existing datasets.
Which simulator should I use if I don't have an NVIDIA GPU?
Genesis. It runs on CPU, AMD GPU, Apple Metal, and NVIDIA, making it the only fast simulator that does not require an NVIDIA GPU.
Can I use LeRobot policies with Genesis simulation?
Yes, with some engineering. LeRobot uses its own dataset format (LeRobotDataset), while Genesis outputs its own formats. You would need to convert or write an adapter, but the sim-to-real pipeline can connect them.
Which repo should I use if I own a Unitree Go2 or G1?
Unitree RL Lab. It is built on Isaac Lab, provides environments for Go2, H1, and G1, and includes a sim-to-real pipeline with MuJoCo verification and C++ deployment code.
Can I train locomotion policies with LeRobot?
Not yet. LeRobot's RL section is short and most locomotion entries are marked "coming soon." For locomotion, use Unitree RL Lab, Isaac Lab, or MuJoCo-based frameworks.
Sources
[1]Hugging Face, LeRobot Documentation — models, datasets, and tools for real-world robotics: huggingface.co/docs/lerobot[2]Genesis Documentation, Genesis: A Physics Platform for Robotics — fast unified physics simulator: github.com/pkpkpk/Genesis[3]Unitree Robotics, Unitree RL Lab — RL environments for Unitree robots on Isaac Lab: github.com/UnitreeRobotics/unitree_rl_lab[4]Hugging Face Blog, LeRobot v0.5.0 Release — new robots, policies, and simulation: huggingface.co/blog/lerobot-release-v050[5]Unitree Robotics, Unitree RL Lab Documentation — Isaac Lab based RL environments: github.com/UnitreeRobotics/unitree_rl_lab