LeRobot v0.5.0: Humanoid, VLAs and Scalable Simulation | Keryc
LeRobot v0.5.0 arrives with a massive update: more hardware, new control policies, data pipeline improvements, and a code modernization that brings it up to Python 3.12 and Transformers v5. Interested in training in simulation or deploying on real hardware? This release gives you tools for both paths and lots of pieces that make it easier to move from an experiment to a physical robot.
What's in v0.5.0 in short
The release includes more than 200 PRs and over 50 contributors since the previous version. The main changes group into hardware, control policies (VLAs and flow-matching), dataset performance, new ways to load simulation environments, and a significant stack modernization.
In practical terms: a Unitree G1 humanoid, CAN motor support, autoregressive and real-time chunking policies, video streaming during data collection, EnvHub for environments from the Hugging Face Hub, and integration with NVIDIA IsaacLab-Arena. There are also improvements to deploy and extend LeRobot with third-party policy plugins.
Hardware: from an arm to a full humanoid
The most visible addition is full support for the Unitree G1 humanoid. This isn't just walking: it includes locomotion, manipulation, teleoperation, and whole-body control (WBC) to coordinate locomotion and manipulation at the same time.
Why does that matter? Because moving from tabletop arms to a full-body robot opens up complex interaction tasks in real environments. Think about navigating, crouching, and manipulating objects all within the same policy.
There's also expanded support for arms and platforms: OpenArm and OpenArm Mini with bi-manual capability, Earth Rover for ground navigation, the OMX robot, and the consolidation of SO-100/SO-101 into a single, cleaner implementation. Plus, new CAN-bus controller support like RobStride and Damiao, letting you use higher-performance actuators outside the Dynamixel/Feetech ecosystem.
A typical use
If you have a lab or a kit with CAN actuators, you can now integrate it with LeRobot to leverage policies trained in simulation or transferred via fine-tuning.
New policies and techniques (more technical)
v0.5.0 introduces six policies and techniques that are relevant for both research and deployment.
Pi0-FAST: autoregressive Vision-Language-Action (VLA) with FAST (Frequency-space Action Sequence Tokenization). Actions get discretized into tokens and an autoregressive decoder (based on Gemma 300M) generates them. Advantages: fine-grained sampling control via temperature and max decoding steps; compatible with Real-Time Chunking (RTC) for low latency.
Real-Time Chunking (RTC): an inference technique that improves responsiveness of flow-matching-based policies. Instead of waiting for a whole chunk to finish before replanning, RTC blends new predictions with actions already executing to produce smoother, more reactive behavior. It's not an independent policy; it's an add-on you enable for flow-matching policies.
Wall-X: a VLA built on Qwen2.5-VL with a flow-matching head for cross-embodiment control.
X-VLA: a VLA based on Florence-2 as an alternative backbone to diversify model bases.
SARM (Stage-Aware Reward Modeling): tackles long-horizon tasks by modeling progress in stages. Instead of a single linear global signal, SARM predicts the stage and the progress within that stage, which helps train multi-step tasks.
PEFT/LoRA for VLAs: you can now fine-tune huge VLAs using LoRA and other PEFT techniques without touching the core pipeline. PEFT configuration lives at the policy level.
Autoregressive vs flow-matching: autoregressive (Pi0-FAST) models let you control step-by-step sampling and decoding, but they usually require tokenization and careful latency handling during decoding. Flow-matching with RTC narrows the gap by enabling faster continuous responses. In real deployments you should profile inference latency and how you use GPU/encoder hardware.
Data and performance: faster recording and training
The data pipeline got major speedups to accelerate collection and training:
Streaming video encoding: frames are encoded in real time during recording, removing wait times between episodes.
Automatic hardware encoder detection to use GPU acceleration when available.
10x faster image transforms during training and 3x faster encoding thanks to default parallelization and dynamic compression.
Better CPU utilization and more dataset editing tools: subtasks, image-to-video conversion, new inspection ops, and fine control of codecs and buffers.
This reduces time between experiments and speeds up your iterate-collect-train cycles.
Simulation: EnvHub and NVIDIA IsaacLab-Arena
EnvHub lets you load environments directly from the Hugging Face Hub. LeRobot downloads the environment code, registers it with Gymnasium, and makes it ready for training. That speeds up sharing custom environments with the community.
Integration with NVIDIA IsaacLab-Arena adds GPU-accelerated simulation and lets you run many instances in parallel for large-scale RL. IsaacLab-Arena has dedicated pre/post-processors to fit into LeRobot's pipeline.
Code and ecosystem modernization
Minimum requirement: Python 3.12
Migration to Transformers v5
Support for installable policy plugins: you can package policies as pip packages and use them without touching the core
Install a policy plugin example:
pip install lerobot_policy_mypolicy
# then
--policy.type=mypolicy
Other improvements: updated PyTorch bounds for Blackwell GPUs, remote visualization with Rerun, versioned docs, better install and CI, and refreshed visualizer and Annotation Studio.
Important: LeRobot was accepted to ICLR 2026, which validates many of the ideas and techniques appearing in this release.
Quick start (useful commands)
Install Wall-X:
pip install lerobot[wall_x]
Install X-VLA:
pip install lerobot[xvla]
Train with PEFT (LoRA) without changing the pipeline:
Practical reflection for researchers and product teams
If you work on robot control or VLA research, v0.5.0 gives you tools to experiment faster and with more varied hardware. Want to try sim2real transfer? EnvHub and the IsaacLab-Arena integration help you scale simulation. Worried about inference latency? RTC and Pi0-FAST's autoregressive option give you levers to explore.
For product teams, CAN controller compatibility and G1 teleoperation mean industrial requirements or humanoid prototypes are more accessible now from a single codebase.
