huggingface/lerobot

LeRobot is an open-source robotics framework that provides a unified infrastructure for training, evaluating, and deploying robot learning policies. It supports a wide variety of hardware platforms and teleoperation devices, enabling users to collect demonstration data and manage datasets with advanced annotation and transformation tools. The system integrates numerous state-of-the-art policies, including diffusion models, vision-language-action models, and reinforcement learning algorithms, facilitating both offline training and real-time asynchronous inference.

87 changes.

The project underwent a significant structural overhaul, introducing a modular package layout, standardized configuration systems, and a unified processor pipeline to support diverse hardware and simulation environments. This foundation enabled the integration of numerous new robot drivers, teleoperators, and camera backends, while simultaneously expanding the policy library with advanced models like ACT, Diffusion, PI0, and Wall-X. Comprehensive test suites and artifact generation tools were developed to ensure reliability across these new components and the upgraded dataset storage format.

57 changes.

This period focused on significantly expanding hardware support by adding drivers for new robot arms, teleoperators, motors, and bimanual configurations. It also introduced a wide variety of new AI policies, including diffusion transformers, vision-language-action models, and reinforcement learning algorithms, alongside a unified framework for reward modeling and language-based dataset annotation.

Users can now control a bimanual setup using two SO Follower arms by instantiating the new \BiSOFollower\ class. This implementation wraps two individual \SOFollower\ instances (left and right), allowing separate configuration for each arm via \BiSOFollowerConfig\. Observations and actions are automatically prefixed with \left\\ or \right\\ to distinguish the arms, while top-level cameras remain unprefixed. The robot also handles camera key collision detection to ensure unique observation keys.

_src/lerobot/robots/bi\_so\follower · high confidence

Users can now control two SO Leader arms simultaneously via the new BiSOLeader teleoperator. This component wraps two individual SOLeader instances (left and right), exposing combined action and feedback features with left/right prefixes. It includes logic to route bimanual feedback for smooth DAgger handover and enforces connection state checks on get\_action and send\_feedback to prevent errors when the hardware is disconnected.

_src/lerobot/teleoperators/bi\_so\leader · high confidence

Users can now control bimanual OpenArm setups using the new BiOpenArmFollower class. This implementation manages two OpenArmFollower instances (left and right arms) and a shared set of top-level cameras. It automatically prefixes observation and action keys with 'left\' or 'right\' to distinguish between arms, while keeping top-level camera keys unprefixed to avoid collisions. Configuration is handled via BiOpenArmFollowerConfig, which allows specifying separate configurations for each arm and any shared cameras.

_src/lerobot/robots/bi\_openarm\follower · high confidence

Users can now control and record data from the EarthRover Mini Plus robot via the Frodobots SDK HTTP API. This change introduces the \EarthRoverMiniPlus\ robot class and its configuration, enabling cloud-based control through HTTP POST requests and camera access via SDK endpoints. The robot supports dual cameras (front and rear), linear and angular velocity control, and telemetry including battery level, orientation, GPS, and IMU sensors.

_src/lerobot/robots/earthrover\_mini\_plus, src/lerobot/robots/koch\_follower, src/lerobot/robots/openarm\follower · high confidence

LeRobot now supports the NVIDIA GR00T N1.7 policy, including the model configuration, processor pipeline, and action head components. This update introduces the N1.7 model version while explicitly removing support for the legacy N1.5 version, which will now raise an error with guidance to migrate to N1.7. The implementation includes specific handling for N1.7 checkpoint assets, such as modality statistics and action decoding transforms, ensuring compatibility with the new model architecture.

src/lerobot/policies/groot · high confidence

This change introduces the Homunculus teleoperator implementation, adding the \HomunculusArm\ and \HomunculusGlove\ classes along with their configuration classes (\HomunculusArmConfig\, \HomunculusGloveConfig\) and a \joints\_translation\ module. Users can now control the Homunculus Arm and Glove hardware via serial ports, with built-in calibration workflows and connection state checks. The translation module also provides mapping logic to convert glove actions to the Hope Jr hand format.

src/lerobot/teleoperators/homunculus · high confidence

Users can now capture video and depth maps from Intel RealSense cameras using the new RealSenseCamera class. This implementation supports identifying devices by serial number or name, enables depth map recording alongside color frames, and allows manual control over exposure, gain, and white balance settings. The camera also handles connection stability with automatic warmup and hardware reset recovery for unresponsive devices.

src/lerobot/cameras/realsense · high confidence

Introduces the LaWAM (Latent World Action Model) policy, providing a new in-tree implementation for robot control. This change adds the core model architecture (including DINOv3 vision encoding, latent action modeling, and VAE quantization), a configuration class (\LaWAMConfig\) with specific hyperparameters for the Qwen3-VL-2B base model, and runtime utilities for batch preparation and processor configuration, enabling users to train and evaluate this specific policy within the LeRobot framework.

src/lerobot/policies/lawam · high confidence

Users can now control the OpenArm Mini (a 7-DOF arm with gripper using Feetech STS3215 motors) via a new teleoperator module. This adds the \OpenArmMini\ class and its configuration (\OpenArmMiniConfig\), enabling connection to the device via a serial port, interactive calibration of joint zero positions and gripper range, and data collection of joint positions and gripper state. The implementation handles side-specific motor direction flipping and joint remapping for bimanual setups.

(repo-wide) · high confidence

Introduces a new teleoperator implementation for the Reachy 2 robot, allowing users to control or monitor the robot via the \reachy2\_sdk\. The module exposes configuration options to selectively enable specific robot parts (mobile base, left/right arms, neck, antennas) and to choose between using present or goal joint positions for actions. It handles connection management, joint mapping, and velocity feedback specific to the Reachy 2 hardware.

_src/lerobot/teleoperators/reachy2\teleoperator · high confidence

Users can now control RobStride motors via a CAN bus interface. This change introduces the \RobstrideMotorsBus\ class, which handles communication using the \python-can\ library, supports CAN FD, and implements the MIT control protocol. It includes configuration tables for motor types, limits, and CAN commands, allowing integration with RobStride hardware on Linux (socketcan) and macOS (slcan).

src/lerobot/motors/robstride · high confidence

Introduces the Robometer reward model (based on Qwen3-VL-4B) to the LeRobot rewards module, providing configuration, model implementation, and preprocessing steps. This enables users to compute per-frame progress and success metrics for robotic trajectories using the Robometer-4B checkpoint, with utilities to generate progress parquet files compatible with existing RABC weight consumers.

src/lerobot/rewards/robometer · high confidence

Users can now operate the Unitree G1 humanoid robot through LeRobot. This change introduces the \UnitreeG1\ robot class and its configuration, enabling both simulation and real-world deployment via a DDS-to-ZMQ bridge server. It includes support for teleoperation using a wireless remote and integrates three advanced control policies: GR00T and Holosoma for lower-body locomotion, and SONIC for whole-body control, all of which can be selected via the robot's configuration.

_src/lerobot/robots/unitree\g1 · high confidence

Users can now control the Unitree G1 robot using either a bimanual exoskeleton or the Unitree wireless remote controller. This change introduces the \UnitreeG1Teleoperator\ class and supporting modules for serial communication, sensor calibration, and inverse kinematics mapping. The system allows users to configure serial ports for left and right exoskeleton arms, perform interactive calibration of hall-effect sensors, and map exoskeleton joint angles to G1 end-effector poses via Pinocchio-based IK. A visualization mode using Meshcat is available to monitor the mapping in real-time. The teleoperator also supports a remote-only mode using the Unitree wireless remote, parsing joystick and button states for direct control.

_src/lerobot/teleoperators/unitree\g1 · high confidence

Users can now connect to remote cameras via ZeroMQ by using the new ZMQCamera class and ZMQCameraConfig. This backend receives base64-encoded JPEG frames over a TCP socket, supporting synchronous, asynchronous, and latest-frame read patterns. A companion ImageServer utility is included to stream local OpenCV camera feeds over ZMQ for testing or integration.

src/lerobot/cameras/zmq · high confidence

Users can now control two OpenArm leader arms simultaneously through a new \BiOpenArmLeader\ teleoperator. This component wraps two individual \OpenArmLeader\ instances (left and right), exposing combined action features prefixed with \left\\ and \right\\ to allow synchronized bimanual input.

_src/lerobot/teleoperators/bi\_openarm\leader · high confidence

Users can now control robots and end-effectors using keyboard inputs via the new \lerobot.teleoperators.keyboard\ module. This adds \KeyboardTeleop\ for basic key capture, \KeyboardEndEffectorTeleop\ for controlling robot end-effectors (with optional gripper control), and \KeyboardRoverTeleop\ for mobile robots like the EarthRover Mini Plus using WASD controls with configurable speed and turning parameters. The implementation relies on the \pynput\ library and includes configuration classes for each teleoperator type.

src/lerobot/teleoperators/keyboard · high confidence

The model module now includes a new RobotKinematics class that leverages the placo library to provide forward and inverse kinematics for robots defined by URDF files. Users can initialize the solver with a URDF path and target frame, then compute end-effector poses from joint positions or solve for joint positions given a desired end-effector pose, with configurable iteration counts and position/orientation weights for the inverse kinematics solver.

src/lerobot/model · high confidence

Users can now control Damiao series motors using a CAN bus interface. This change introduces the \DamiaoMotorsBus\ class, which handles communication with motors over CAN (including CAN FD), supports auto-detection of interfaces (socketcan or slcan), and includes configuration tables for various Damiao motor models (e.g., DM3507, DM8009) and their specific parameters like limits and resolutions. This enables integration with hardware like the OpenArm robot that utilizes these motors.

src/lerobot/motors/damiao · high confidence

Users can now control the Hope Jr robotic arm and hand through LeRobot. This change introduces the \HopeJrArm\ and \HopeJrHand\ classes, along with their respective configuration classes (\HopeJrArmConfig\, \HopeJrHandConfig\), enabling integration with Feetech motors and cameras. The implementation supports RGB and depth camera inputs, motor calibration via a GUI, and safety features such as capping relative target positions for the arm.

_src/lerobot/robots/hope\jr · high confidence

Users can now capture frames from Reachy 2 robot cameras (teleop and depth) using the new Reachy2Camera class. This change introduces a configuration class (Reachy2CameraConfig) to specify camera parameters such as IP address, port, resolution, and color mode (RGB/BGR). The implementation handles connection to the Reachy 2 CameraManager, frame retrieval, and color space conversion, with specific handling for Windows compatibility via OpenCV environment variables.

_src/lerobot/cameras/reachy2\camera · high confidence

Users can now control the Seeed Studio reBot Arm 102 (StarArm102) as a leader arm in teleoperation setups. This change introduces the \RebotArm102Leader\ class and its configuration, enabling connection via UART smart servos (using the \motorbridge-smart-servo\ package), automatic calibration, and joint position reading for the 7-joint arm including the gripper.

_src/lerobot/teleoperators/rebot\_102\leader · high confidence

Users can now control the Seeed Studio reBot B601-DM 6-DOF arm with gripper via the LeRobot framework. This change introduces the \RebotB601Follower\ robot class and its configuration, supporting both MIT and position/velocity control modes for the arm joints, and MIT or force-position modes for the gripper. The implementation relies on the \motorbridge\ package for CAN bus communication, accessible through either a Damiao serial bridge or SocketCAN adapters, and includes built-in calibration workflows and configurable joint limits for safe operation.

_src/lerobot/robots/rebot\_b601\follower · high confidence

Users can now control two Seeed Studio reBot B601-DM arms simultaneously using the new \BiRebotB601Follower\ robot class. This implementation composes two single-arm followers, automatically namespacing observation and action keys with \left\\ and \right\\ prefixes to distinguish between the two sides, while allowing for shared top-level cameras that remain unprefixed in the data stream.

_src/lerobot/robots/bi\_rebot\_b601\follower · high confidence

Users can now control the ROBOTIS OMX robot arm through LeRobot. This change introduces the OmxFollower class and its configuration, enabling connection via Dynamixel motors (with specific PID tuning for the elbow and current-limited gripper control), camera integration (supporting both RGB and depth streams), and safety features like torque disabling on disconnect and relative target limits.

_src/lerobot/robots/omx\follower · high confidence

This change introduces a new robot driver for the Reachy 2 platform by Pollen Robotics. It adds the \Reachy2Robot\ class and its configuration (\Reachy2RobotConfig\), enabling users to control the robot's joints (neck, arms, antennas, mobile base) and access its cameras (left/right teleop, torso). The implementation maps LeRobot's internal joint and velocity keys to the Reachy 2 SDK's API, supports optional external command systems, and configures camera observations with default dimensions of 640x480 at 30fps.

src/lerobot/robots/reachy2 · high confidence

The \examples/omx\ directory now includes a complete reference implementation for the OMX Follower robot arm, featuring a README with end-to-end instructions for data collection, training, and rollout. New Python scripts \record\_grab.py\ and \reset\_environment.py\ provide automated utilities for collecting pick-and-place datasets and resetting the physical workspace, respectively.

examples/omx · high confidence

The CI evaluation pipeline for benchmark smoke tests (LIBERO, MetaWorld, RoboTwin, RoboMME, VLABench, and RoboCasa) now embeds human-readable task instructions into the generated \metrics.json\ artifact. A new \extract\_task\_descriptions.py\ script runs inside the benchmark Docker containers to map task IDs to their natural-language instructions (handling specific formatting for each environment, such as stripping perturbation metadata for LIBERO-plus), and \parse\_eval\_metrics.py\ merges these descriptions into the final metrics output. This allows the health dashboard and downstream consumers to display clear task labels alongside success rates and rewards without needing to query the environment libraries directly.

scripts · high confidence

Users can now control Dynamixel servos via the \DynamixelMotorsBus\ interface, which handles protocol 2.0 communication, calibration, and multiple operating modes (current, velocity, position, extended position, current-position, and PWM). The module includes built-in configuration tables for specific X-Series models (xl330, xl430, xm430, xm540, xc430, xh540, xc330), defining their model numbers, supported baudrates, control table addresses, and encoding sizes to ensure correct hardware interaction.

src/lerobot/motors/dynamixel · high confidence

This change introduces the \src/lerobot/motors/feetech\ module, providing the \FeetechMotorsBus\ class and associated hardware tables to control Feetech STS, SCS, and SMS series servo motors. The implementation includes support for multiple operating modes (position, velocity, PWM, step), drive direction inversion, and protocol version handling (0 and 1). It also addresses a known timeout bug in the underlying \scservo\_sdk\ by patching the \setPacketTimeout\ method, ensuring reliable communication with the motors.

src/lerobot/motors/feetech · high confidence

Adds the Action Chunking Transformer (ACT) policy to the library, including its configuration (ACTConfig), model implementation (ACTPolicy), and preprocessing pipelines. This policy supports action chunking for bimanual manipulation tasks, featuring a ResNet vision backbone, transformer encoder/decoder layers, and optional VAE-based latent modeling. It also includes temporal ensembling capabilities and handles padded actions during loss computation.

src/lerobot/policies/act · high confidence

This change adds two new policy implementations to the library: DiffusionPolicy and TDMPCPolicy. The Diffusion policy brings a visuomotor policy learning approach based on action diffusion, featuring configurable noise schedulers (DDPM/DDIM), gradient checkpointing for memory optimization, and support for offline batch inference. The TD-MPC policy implements Temporal Difference Learning for Model Predictive Control, supporting both MPC planning and direct policy sampling with cross-entropy method optimization. Both policies include configuration classes, model implementations, and processor pipelines for data normalization and feature handling.

src/lerobot/policies/diffusion · high confidence

Adds the EO-1 policy to LeRobot, a vision-language-action model built on the Qwen2.5-VL-3B-Instruct backbone. This policy enables robot training and inference that jointly optimizes for action prediction (via flow matching) and text generation (language supervision), allowing the model to output natural language responses alongside robot actions. The implementation includes the configuration, model architecture, and processor pipeline specific to EO-1, integrating with LeRobot's existing training and evaluation infrastructure.

src/lerobot/policies/eo1 · high confidence

Adds the EVO1 policy to the library, a vision-language model-based controller that uses the InternVL3-1B foundation model to process multi-camera images and text prompts. The policy implements a flow-matching action head to predict action horizons and supports Real-Time Chunking (RTC) for asynchronous inference. It includes a two-stage training configuration (stage1 for action-head-only fine-tuning, stage2 for full VLM fine-tuning), automatic mixed precision management via bfloat16 autocast, and configurable flash attention usage. The implementation provides dedicated preprocessing and postprocessing steps to handle state/action padding, gripper binarization, and transition conversion.

src/lerobot/policies/evo1 · high confidence

Adds the FastWAM policy, a new LeRobot policy that combines a frozen Wan2.2 video diffusion backbone with a lightweight action expert to predict robot actions from video and text. The policy supports language-conditioned tasks, proprioceptive state inputs, and cross-embodiment fine-tuning via shape-aware weight loading. It includes a configurable action toggle processor for specific dimension semantics, uses SDPA for attention to support complex MoT routing masks, and offers a compiled inference path for reduced overhead on repeated calls.

src/lerobot/policies/fastwam · high confidence

Added the GaussianActor policy, a new capability for maximum-entropy continuous-control algorithms like SAC. This release includes the policy model, its configuration (GaussianActorConfig), and processor pipelines. Users can now train policies that output a tanh-squashed diagonal Gaussian distribution, with support for shared or separate observation encoders, discrete action dimensions (e.g., grippers), and configurable concurrency settings for actor-learner multiprocessing.

_src/lerobot/policies/gaussian\actor · high confidence

Adds the LeKiwi robot implementation, including a local driver (LeKiwi) that manages Feetech motors and cameras, and a remote client (LeKiwiClient) that communicates with a host via ZMQ. The host component (LeKiwiHost) streams observations as multipart ZMQ messages (JSON header + raw JPEG frames) to reduce bandwidth, while the client parses and displays these frames. Configuration classes define camera settings (MJPG, specific resolutions/rotations), motor ports, and network parameters. The local driver includes calibration workflows and safety clamping for relative targets.

src/lerobot/robots/lekiwi · high confidence

Adds the LingBot-VA policy to LeRobot, an autoregressive video-action world model built on the Wan2.2 diffusion stack. This policy interleaves prediction of future video latents and robot actions in a single dual-stream transformer, supporting LIBERO-style environments with two camera inputs. The implementation includes the policy configuration, model wrapper, and pre/post-processor pipelines, while keeping the large frozen VAE and text encoder components separate to minimize checkpoint size.

_src/lerobot/policies/lingbot\va · high confidence

Adds the MolmoAct2 policy, a vision-language model (VLM) based robotics policy from Allen AI that combines a Molmo backbone with a per-layer flow-matching action expert for continuous action generation. This location provides the policy implementation, configuration, and pre/post-processing pipeline, including a custom AdamW optimizer that clips gradients per component and uses low-memory BF16 update compensation to match the official training recipe.

src/lerobot/policies/molmoact2 · high confidence

Adds a new Multi-Task Diffusion Transformer policy that supports both diffusion and flow matching objectives for multi-task robot learning with text and vision conditioning. The implementation includes the \MultiTaskDiTPolicy\ model, \MultiTaskDiTConfig\ for configuring transformer architecture, diffusion/flow matching parameters, and CLIP-based vision/text encoders, and a processor pipeline for normalizing inputs and unnormalizing actions.

_src/lerobot/policies/multi\_task\dit · high confidence

Users can now access cameras via a new OpenCV backend, exposed through the \lerobot.cameras.opencv\ module. This backend supports configurable image rotation (including 180-degree fixes), FOURCC codec selection (e.g., MJPG) for format control, and explicit backend selection. It also includes a Windows-specific fix that disables hardware transforms to ensure compatibility with MSMF, and adds validation for the FOURCC code length.

src/lerobot/cameras/opencv · high confidence

The PI0 policy is now available in the library, providing a new model for robotic control. This implementation supports relative action prediction (converting absolute actions to relative to state) and allows users to configure the text tokenizer, including its maximum length and source name. The policy also includes a dedicated processor pipeline that handles task description formatting, such as ensuring newline characters for tokenizer compatibility.

src/lerobot/policies/pi0 · high confidence

The PI0.5 policy is now available, featuring short-horizon visual and proprioceptive memory (MEM) to fuse historical observations, optional real-time chunking (RTC) for dynamic action prefixing, and support for relative actions. The policy includes a dedicated configuration class, a processor pipeline for state tokenization and normalization, and a modeling implementation that integrates these capabilities with the underlying PaliGemma backbone.

src/lerobot/policies/pi05 · high confidence

This change adds the PI0Fast policy module, providing a new autoregressive vision-language action model that supports relative actions (converting absolute actions to deltas relative to the current state) and optimized decoding that stops at an end-of-action marker. The implementation includes the policy configuration, model definition, and a processor pipeline that handles state tokenization, action tokenization, and relative/absolute action conversion.

_src/lerobot/policies/pi0\fast · high confidence

This change adds the Real-Time Chunking (RTC) module to the policy system, providing the infrastructure needed to handle inference latency and action chunk overlap in real-time control. It introduces the \RTCConfig\ dataclass to manage settings such as enabled state, guidance mode (guided or trained), and execution horizon. The \RTCProcessor\ implements the core RTC guidance logic by wrapping the denoising step to apply prefix guidance based on leftover actions from previous chunks. A thread-safe \ActionQueue\ manages the flow of original and processed actions, supporting both RTC-enabled (replace) and RTC-disabled (append) modes. Additionally, the module includes a \LatencyTracker\ for monitoring inference performance, debug tracking and visualization utilities for inspecting denoising steps, and helper functions to re-anchor relative action prefixes for policies using relative action spaces.

src/lerobot/policies/rtc · high confidence

Added the SARM (Stage-Aware Reward Modeling) package under src/lerobot/rewards/sarm, providing a new reward model that predicts both high-level stage classification and fine-grained within-stage progress (tau) for long-horizon robot tasks. The implementation includes the SARMConfig, SARMRewardModel, and a CLIP-based processor that encodes visual and state inputs to generate sparse and dense stage/progress targets. It also introduces RA-BC (Reward-Aligned Behavior Cloning) sample weighting via the RABCWeights class and a compute\_rabc\_weights utility to precompute progress values for training. The module enforces strict annotation validation, failing fast if episode metadata lacks usable subtask annotations to prevent training on invalid zero-targets.

src/lerobot/rewards/sarm · high confidence

This change adds the SO-100 and SO-101 follower robot implementations to the LeRobot library, enabling users to control these specific hardware models. The new \SOFollower\ class and its configuration classes (\SO100FollowerConfig\, \SO101FollowerConfig\) allow users to specify the serial port, enable/disable torque on disconnect, and configure camera inputs. Key behavioral improvements include configurable position-mode PID gains (P, I, D coefficients) for tuning motor response, a safety limit on relative target movement magnitude, and automatic retries for transient Feetech bus read errors to improve stability. The implementation also supports both degree and range-based motor normalization modes and integrates with the existing processor pipeline for end-effector reference and delta calculations.

_src/lerobot/robots/so\follower · high confidence

Added the SO-100 and SO-101 leader arm teleoperators, including configuration classes and the core implementation. The leader now uses degrees for angle normalization by default and includes retry logic for transient Feetech bus read errors to improve stability during teleoperation.

_src/lerobot/teleoperators/so\leader · high confidence

Users can now train and infer with the SmolVLA policy, which integrates the SmolVLM2-500M-Video-Instruct vision-language model with a dedicated action expert. This policy supports Real-Time Chunking (RTC) for low-latency inference and allows users to fine-tune the action expert while freezing the VLM backbone. The implementation includes configuration for normalization, device handling, and torch.compile optimization, along with pre/post-processing pipelines for state and action data.

src/lerobot/policies/smolvla · high confidence

Added the TOPReward reward model, a zero-shot capability that uses an off-the-shelf vision-language model (defaulting to Qwen3-VL) to score robot trajectories. This change introduces the model configuration, the inference logic, and a pre/post-processing pipeline that tokenizes video frames and task instructions to extract log-likelihood rewards. It also includes a utility script to compute per-frame reward progress curves for LeRobot datasets, enabling users to evaluate and analyze trajectory quality without fine-tuning a dedicated reward model.

src/lerobot/rewards/topreward · high confidence

Adds the VLA-JEPA policy to the library, integrating a Qwen3-VL vision-language backbone, a DiT-based flow-matching action head, and a V-JEPA world model for video prediction. The implementation includes configuration for cross-embodiment transfer, device-safe autocast handling, and processor steps for image preparation and gripper action post-processing, enabling users to load and run this specific policy variant.

_src/lerobot/policies/vla\jepa · high confidence

Adds the VQ-BeT policy, implementing the 'Behavior Generation with Latent Actions' approach. This new capability includes the VQBeTConfig configuration class, the VQBeTPolicy model, and processor pipelines for data normalization and device management. The policy uses a Residual VQ-VAE to discretize actions and a GPT-based transformer to predict action chunks from proprioceptive and single-camera visual observations, with pretrained ResNet18 vision backbone weights enabled by default.

src/lerobot/policies/vqbet · high confidence

A new Wall-X policy is available for cross-embodiment robotic control, built on Qwen2.5-VL with flow matching for action prediction. This policy supports multi-modal inputs (vision, state, and language) and introduces a language runtime with text supervision, allowing the model to predict actions in language alongside standard action vectors. Users can configure the policy via WallXConfig, which supports both diffusion and fast prediction modes, and utilizes a dedicated processor pipeline for pre- and post-processing of images, text, and actions.

_src/lerobot/policies/wall\x · high confidence

This change adds the XVLA (Extended Vision-Language-Action) policy to the LeRobot framework, enabling users to train and run policies that combine the Florence-2 vision-language model with a soft-prompted transformer head for robotic control. The implementation includes a configuration class (\XVLAConfig\) that supports native Hugging Face Florence-2 configs as well as translation from legacy Microsoft checkpoint formats, and allows users to freeze specific VLM components (vision/language encoders) while training the policy transformer and soft prompts. The policy integrates a registry of action spaces (currently \ee6d\ for end-effector pose and \joint\ for joint angles) with specific loss computations and preprocessing/postprocessing hooks, and provides a dedicated processor pipeline for handling image normalization, tokenization, and domain ID injection. This location specifically provides the policy model, configuration, action space definitions, and data processing steps required to plug XVLA into the LeRobot training and inference stack.

src/lerobot/policies/xvla · high confidence

Adds a new \lerobot.async\_inference\ module providing a gRPC-based server/client system for running robot policies asynchronously. The \PolicyServer\ handles policy loading, pre/post-processing, and observation inference, while the \RobotClient\ manages robot connection, observation streaming, and action execution. Configuration is centralized in \PolicyServerConfig\ and \RobotClientConfig\, supporting multiple policies (ACT, Pi0, Diffusion, etc.) and robots (SO arms, OMX). The module requires the \grpcio\ package via the \async\ extra.

_src/lerobot/async\inference · high confidence

This change introduces the core components for a distributed Human-in-the-Loop (HILSerl) reinforcement learning training pipeline. It adds an actor server (\actor.py\) that runs on the robot to collect experience and a learner server (\learner.py\) that receives transitions and updates the policy via gRPC. The module includes a new \ReplayBuffer\ (\buffer.py\) with memory optimization and image augmentation, data mixing strategies (\data\_sources/data\_mixer.py\) for online/offline training, and a \crop\_dataset\_roi.py\ tool to manually select and save image regions of interest. It also adds observation processors for joint velocity and motor current, and a \gym\_manipulator.py\ environment for robot control and data recording.

src/lerobot/rl · high confidence

Users can now control robots via a gamepad using the new \GamepadTeleop\ class and \GamepadTeleopConfig\. The implementation primarily uses pygame for input but includes a configurable \hidapi\_fallback\ option to improve controller detection reliability on macOS. The teleoperator supports optional gripper control (enabled by default) and exposes standard teleoperation events such as intervention status and episode termination signals.

src/lerobot/teleoperators/gamepad · high confidence

The \src/lerobot/robots\ module now provides a unified entry point for robot integration, exposing \RobotConfig\ for standardized settings (including camera parameters and calibration paths), an abstract \Robot\ base class with context-manager support for connection lifecycle, and a \make\_robot\_from\_config\ factory function. This factory resolves specific robot implementations (such as Koch, OMX, SO100, Hope Jr, Reachy 2, OpenArm, and ReBot B601) from configuration types, ensuring consistent initialization and calibration handling across supported hardware.

src/lerobot/robots · high confidence

The teleoperators module has been restructured to provide a unified, standardized interface for all teleoperation devices, introducing a base Teleoperator class and a centralized factory (make\_teleoperator\_from\_config) that resolves device types from configuration. This change adds native support for bimanual teleoperation setups, specifically introducing BiOpenArmMini and BiRebot102Leader, which compose two single-arm instances and namespace their action/feedback keys with left/right prefixes. The update also includes a new TeleopEvents enum for shared event constants and ensures consistent calibration handling and context-manager support across all supported devices.

src/lerobot/teleoperators · high confidence

The \src/lerobot/annotations\ package now includes a steerable annotation pipeline that automatically generates structured language data for robot episodes. This pipeline runs in six phases to produce \language\_persistent\ columns (subtask decomposition, plan, and memory) and \language\_events\ columns (interjections and speech) by leveraging a VLM (defaulting to Qwen-VL via vLLM). It features legible contact-sheet frame sampling for efficient visual grounding, seeded relabeling for improved subtask accuracy, and task augmentation to create diverse training phrasings. The system is designed to run on Hugging Face Jobs and writes the resulting language features directly into the dataset's parquet shards and metadata.

src/lerobot/annotations · high confidence

The \src/lerobot/processor\ module now provides a comprehensive, registry-based processor pipeline for handling environment transitions. This includes steps for batching dimensions, converting between PyTorch tensors and NumPy arrays, moving data to specific devices (CPU/GPU) with dtype casting, and normalizing/unnormalizing features. It also introduces environment-specific processors for LIBERO and IsaacLab Arena, delta-action mapping for robot control, and human-in-the-loop (HIL) support for teleoperation events and actions. A factory module standardizes the creation of default policy pre/post-processing pipelines, ensuring consistent data flow from observation to policy action and back.

src/lerobot/processor · high confidence

The \src/lerobot/rewards\ package now provides a centralized structure for reward models, introducing a \PreTrainedRewardModel\ base class that handles safetensors loading and Hub integration, alongside a factory module (\factory.py\) that dynamically instantiates specific models (such as Robometer, TOPReward, SARM, and RewardClassifier) and their associated pre/post-processing pipelines based on configuration.

src/lerobot/rewards · high confidence

The library has been restructured into a modular package under \src/lerobot\, enabling a lightweight base installation where specific capabilities are gated behind optional extras such as \dataset\, \training\, \hardware\, and \core\_scripts\. This change also introduces a standardized type system for robotics interactions via \lerobot\_types.py\, defining \EnvTransition\ and related types to ensure consistent handling of observations, actions, and rewards across the platform.

src/lerobot · high confidence

Added the Hugging Face implementation for the MolmoAct2 policy, including the core model architecture, configuration classes, and specialized processors for images, videos, and actions. This update introduces a UniversalActionProcessor that encodes and decodes action trajectories using Discrete Cosine Transform (DCT) and Byte-Pair Encoding (BPE), alongside image and video processors that handle tiling, overlapping crops, and normalization. The model also supports advanced inference optimizations such as CUDA Graphs and static KV caches to improve performance during continuous training and generation.

_src/lerobot/policies/molmoact2/molmoact2\_hf\model · high confidence

Added dedicated Dockerfiles to build isolated benchmark images for LIBERO, LIBERO-plus, MetaWorld, RoboCasa, RoboCerebra, RoboMME, RoboTwin 2.0, and VLABench. Each image extends the nightly GPU base with the specific simulator dependencies, pinned source code, and pre-cached assets required for integration tests, allowing users to run \lerobot-eval\ against these environments without manual setup.

docker · high confidence

Added a new example in \examples/isaac\_teleop\_to\_so101\ that enables teleoperating an SO-101 (or SO-100) follower arm using NVIDIA Isaac Teleop. The example supports two input devices: an XR (VR) controller, which drives the end-effector through a squeeze-to-engage clutch and LeRobot's Cartesian IK pipeline, and a back-drivable SO-101 leader arm, which mirrors 1:1 onto the follower. It includes scripts for teleoperation (\teleoperate.py\) and dataset recording (\record.py\), along with shared infrastructure for device management, clutch logic, and CloudXR runtime integration.

_examples/isaac\_teleop\_to\so101 · high confidence

The \examples/lekiwi\ directory now includes five new Python scripts (\evaluate.py\, \record.py\, \replay.py\, \rollout.py\, \teleoperate.py\) that provide concrete, self-contained workflows for the LeKiwi robot. \evaluate.py\ demonstrates how to load a pretrained policy (e.g., ACT) and run inference while recording evaluation episodes to a dataset. \record.py\ shows how to collect demonstration data using either a keyboard or an SO100 leader arm teleoperator. \replay.py\ allows users to playback recorded actions from a dataset back to the robot. \rollout.py\ provides a base strategy for autonomous policy execution without recording, and \teleoperate.py\ enables real-time manual control via keyboard or leader arm with visualization support.

examples/lekiwi · high confidence

A new Jupyter notebook (\examples/notebooks/quickstart.ipynb\) has been added to provide a guided, ready-to-paste workflow for LeRobot users. It covers the complete lifecycle from calibration and teleoperation to data collection, training, and evaluation, allowing users to configure settings in a single cell and generate the necessary terminal commands for each step.

examples/notebooks · high confidence

A new evaluation script (\examples/rtc/eval\_dataset.py\) has been added to allow users to benchmark Real-Time Chunking (RTC) performance. This tool compares action predictions from policies (such as Pi0, Pi0.5, and Smolvla) with and without RTC enabled, measuring consistency and ground truth alignment on dataset samples. It supports various hardware configurations (CUDA, MPS, CPU) and includes options for torch.compile acceleration and debug visualizations.

examples/rtc · high confidence

Added a new \lerobot.data\_processing\ module containing utilities for SARM (Stage-Aware Reward Modeling) subtask annotation. This includes a script that uses a local Qwen3-VL model to analyze robot demonstration videos and automatically identify subtask timestamps, supporting sparse, dense, or dual annotation modes to enhance dataset metadata for reward modeling.

_src/lerobot/data\processing · high confidence

Added \examples/so100\_to\_so100\_EE\ (and a parallel \phone\_to\_so100\ example) that demonstrate how to record, replay, and run policies in end-effector (EE) space on the SO100 robot. These scripts use \RobotProcessorPipeline\ with \ForwardKinematicsJointsToEE\ and \InverseKinematicsEEToJoints\ to convert between joint and EE coordinates, allowing users to train and deploy policies that operate in Cartesian space rather than joint space.

_examples/so100\_to\_so100\EE · high confidence

Added a new \replay.py\ script in the \examples/backward\_compatibility\ directory that demonstrates how to replay actions from a LeRobot dataset episode on a robot. This example specifically targets SO (Series-Optimized) arms, applying necessary coordinate transformations (such as adjusting shoulder lift and elbow flex positions) to ensure compatibility with the hardware, and utilizes the updated \precise\_sleep\ utility for accurate timing control.

_examples/backward\compatibility · high confidence

This change introduces a new \lerobot.jobs\ module and associated CLI scripts to support remote execution and dataset annotation workflows. Users can now run the \lerobot-annotate\ command to automatically populate \language\_persistent\ and \language\_events\ columns on LeRobot datasets using a steerable VLM pipeline, with the option to offload the computation to Hugging Face Jobs GPUs via \--job.target\. The infrastructure includes helpers to ensure datasets are available on the Hub for remote pods and utilities to convert DCP-format training checkpoints into distributable safetensors models. Additionally, a new script is provided to augment existing datasets with quantile statistics.

src/lerobot/scripts · high confidence

Added several new example scripts in the examples/dataset directory to demonstrate advanced LeRobot dataset capabilities. use\_dataset\_image\_transforms.py shows how to apply default, custom, or pure torchvision image augmentations at training time. use\_dataset\_tools.py demonstrates programmatic dataset management including deleting episodes, splitting into train/val sets, adding/removing/modifying features, and merging datasets. create\_progress\_videos.py provides a tool to generate MP4/GIF videos with per-frame progress overlays for specific episodes. slurm\_compute\_rabc.py introduces a distributed pipeline for computing SARM reward-based annotation progress values across SLURM workers. load\_lerobot\_dataset.py serves as a comprehensive guide for loading metadata, accessing frames by episode, and using PyTorch DataLoaders with timestamp-based history/future frame selection.

examples/dataset · high confidence

The \src/lerobot/configs\ package introduces a structured, dataclass-based configuration system that replaces ad-hoc argument handling. Users can now explicitly configure distributed training topology (FSDP2, DDP, HSDP, and context-parallelism placeholders) via \ParallelismConfig\ and \AcceleratorConfig\, manage dataset recording options (including video encoding, streaming, and Hub visibility) via \DatasetRecordConfig\, and control training behaviors such as Exponential Moving Average (EMA) of policy weights, WandB tagging, and evaluation splits via \EMAConfig\, \WandBConfig\, and \DatasetConfig\. The system also standardizes policy loading through \PreTrainedConfig\ and provides a unified entry point in \\_\init\\_.py\ for all configuration types, ensuring that CLI arguments and YAML/JSON configs round-trip consistently.

src/lerobot/configs · high confidence

The \src/lerobot/distributed\ package introduces the core runtime for distributed training, including an \Accelerator\ factory that enforces configuration via \TrainPipelineConfig\ and blocks conflicting \accelerate\ environment variables. It provides sharding-aware checkpointing using PyTorch DCP (saving and loading model and optimizer shards) and merging DCP shards into \model.safetensors\. The package also includes utilities to strip accelerate's context-parallel hooks that could corrupt attention masks and to register FSDP forward methods for sharded policies.

src/lerobot/distributed · high confidence

Added utility scripts to enforce documentation standards and manage doctests. \check\_config\_docstrings.py\ ensures robot configuration classes document critical user-facing fields like \port\ and calibration details. \check\_docstrings.py\ validates that public object signatures match their \Args:\ blocks, including default values, and can auto-fix mismatches. \check\_doctest\_list.py\ maintains an allowlist of files (\documentation\_tests.txt\) whose docstring examples are executed, ensuring paths exist and remain sorted.

utils · high confidence

This change introduces dedicated environment wrappers and benchmark integrations for LeRobot, adding support for MetaWorld, RoboCasa, RoboMME, and RoboTwin 2.0. It includes the \MetaworldEnv\ class with a configuration file for task descriptions and policies, a \RoboCasaEnv\ wrapper for kitchen tasks, a \RoboMMEGymEnv\ for evaluation benchmarks, and a \LiberoEnv\ for the LIBERO suite. These additions expand the available simulation environments for training and evaluating robotic policies.

src/lerobot/envs · high confidence

The \lerobot.transport\ module has been introduced to provide a gRPC-based communication layer for async inference. This addition includes the protobuf service definitions (\services.proto\) for \LearnerService\ and \AsyncInference\, along with the generated Python stubs. It also provides utility functions for serializing and deserializing PyTorch tensors and transitions, handling large data transfers in chunks, and configuring gRPC channels with built-in retry mechanisms for network resilience. Users can now leverage this module to stream observations and actions between robots and remote policy servers.

src/lerobot/transport · high confidence

A new \lerobot.common\ package has been introduced to host cross-cutting modules that bridge multiple lerobot packages (policies, processors, configs). This location now provides \control\_utils\ for single-step inference and teleoperation handover helpers, \train\_utils\ for checkpoint management and training metadata persistence, and \wandb\_utils\ for Weights & Biases logging and run resumption. These utilities are explicitly not re-exported from the top-level \lerobot\ package and are intended for direct import by internal components.

src/lerobot/common · high confidence

The camera module has been restructured into a new, modular subsystem that introduces a standard \Camera\ interface and a factory function (\make\_cameras\_from\_configs\) to instantiate specific backend implementations (OpenCV, Intel RealSense, Reachy2, ZMQ) based on configuration. This change adds support for configurable OpenCV backends (e.g., DShow, V4L2) and rotation modes, while intentionally keeping backend-specific dependencies lazy-loaded to avoid pulling them in unless needed. Users can now define camera configurations centrally and have the system automatically resolve and initialize the appropriate hardware driver.

src/lerobot/cameras · high confidence

The \src/lerobot/rollout\ package introduces a structured policy deployment engine that decouples policy execution from data recording. It provides a \RolloutController\ for programmatic lifecycle management (start, pause, reset, stop) and an \InteractiveSession\ for chat-style CLI control. The engine supports multiple inference backends—synchronous (\SyncInferenceEngine\) and real-time chunking (\RTCInferenceEngine\)—and a registry of rollout strategies (e.g., \Base\, \Sentry\, \Highlight\, \Episodic\, \DAgger\) that can be selected via CLI. This architecture allows users to run autonomous rollouts, record data with specific strategies, or interactively control the robot while keeping hardware and policy connections stable.

src/lerobot/rollout · high confidence

The rollout system has been restructured into a modular strategy framework located in \src/lerobot/rollout/strategies\. This introduces a factory-based dispatch system (\create\_strategy\) that supports five distinct execution modes: \Base\ for autonomous policy execution without recording, \Sentry\ for continuous autonomous recording with automatic episode rotation and Hub uploads, \Highlight\ for on-demand recording using a ring buffer, \Episodic\ for multi-episode recording with manual reset phases, and \DAgger\ for interactive human-in-the-loop imitation learning with correction capabilities. The framework provides a common abstract base (\RolloutStrategy\) and shared utilities for inference engine management, action interpolation, and hardware teardown, allowing users to select the appropriate strategy via configuration for different data collection and deployment workflows.

src/lerobot/rollout/strategies · high confidence

The motors module now exposes a structured API for hardware interaction, introducing a \MotorsBusBase\ abstract class that standardizes connection, torque control, and read/write operations across different communication protocols. This change includes new data models for \Motor\ and \MotorCalibration\, utility functions for encoding/decoding signed magnitude and two's complement values, and a new Pygame-based graphical interface (\calibration\_gui.py\) that allows users to visually adjust and save motor range calibrations via interactive sliders.

src/lerobot/motors · high confidence

This change introduces a new teleoperator module for controlling robots via a smartphone. It includes configuration for iOS and Android platforms, a processor step to map phone pose and button inputs to robot actions, and the core teleoperation logic using the HEBI Mobile I/O SDK for iOS and a generic teleop library for Android. Users can now use their phones as a controller for supported robots.

src/lerobot/teleoperators/phone · high confidence

The \src/lerobot/policies\ module introduces a new factory system (\factory.py\) that resolves policy classes by convention and supports third-party plugins, alongside a new \PreTrainedPolicy\ base class (\pretrained.py\) that standardizes configuration, Hub integration, and FSDP2-aware saving/loading. A new \PiGemma\ model (\pi\_gemma.py\) is added, featuring adaptive RMSNorm for conditional modulation. Inference performance is improved by moving image normalization to the target device in \prepare\_observation\_for\_inference\ (\utils.py\), and new utility functions \make\_robot\_action\ and \build\_inference\_frame\ are exposed to simplify API-based inference workflows.

src/lerobot/policies · high confidence

The examples/port\_datasets directory now includes a complete set of scripts to convert the DROID robotics dataset into the LeRobot format and upload it to Hugging Face. This includes port\_droid.py, which defines the dataset schema and conversion logic; slurm\_port\_shards.py and slurm\_aggregate\_shards.py, which handle distributed processing and aggregation of the converted shards; slurm\_upload.py, which manages the final upload to the Hugging Face Hub; and display\_error\_files.py, a utility for debugging failed worker processes.

_examples/port\datasets · high confidence

A new reward model type, \reward\_classifier\, has been added to the library, enabling users to train models that classify video observations to generate reward signals. This feature includes a configuration class (\RewardClassifierConfig\) that supports CNN and transformer backbones (defaulting to a ResNet10 encoder), a \Classifier\ model implementation that processes multi-camera image inputs, and a dedicated processor pipeline for normalizing inputs and handling outputs. Users can now register and utilize this specific architecture for reward modeling tasks within the Lerobot framework.

src/lerobot/rewards/classifier · high confidence

The \src/lerobot/transforms\ module now provides a suite of eight image augmentation transforms designed for robotics data, including CoarseDropout, GammaCorrection, GaussianNoise, GaussianPatchBrightness, JPEGCompression, MotionBlur, PlanckianJitter, RandomShadow, and SharpnessJitter. These tools allow users to simulate real-world camera conditions such as sensor noise, motion blur, and lighting variations to improve model robustness.

src/lerobot/transforms · high confidence

Added two new scripts in the training examples directory: \train\_policy.py\ demonstrates offline training of a Diffusion Policy on the PushT environment, while \train\_with\_streaming.py\ shows how to train an ACT Policy on large datasets (like DROID) using streaming mode to avoid high memory usage.

examples/training · high confidence

Added new tutorial scripts in the \examples/tutorial\ directory demonstrating how to train and use several robot learning policies. This includes training and inference examples for ACT and Diffusion policies, inference examples for Pi0 and SmolVLA policies, and a Human-in-the-Loop SERL (HIL-SERL) example featuring a reward classifier and SAC algorithm. Additionally, async inference examples are provided for setting up a policy server and connecting a robot client.

examples/tutorial · high confidence

The \src/lerobot/utils\ package now includes several new modules that enhance robot control and evaluation capabilities. The \ActionInterpolator\ class allows for smoother robot motion by interpolating between consecutive actions, effectively increasing the control rate. The \CycleTimer\ provides cadence pacing and reporting for real-time control loops, ensuring consistent frame rates and warning when the loop body cannot keep up. Device management is improved with \device\_utils\, which now supports Intel XPU backends and includes safer device selection logic. Additionally, \eval\_stats\ introduces statistical helpers for evaluation success rates, including Wilson score intervals and Fisher's exact test, providing more robust metrics for comparing policy performance.

src/lerobot/utils · high confidence

The repository is initialized with essential configuration files including \.dockerignore\, \.gitattributes\ (configuring Git LFS for binary assets like \.stl\, \.mp4\, \.safetensors\), and \.gitignore\. A comprehensive \pre-commit\ configuration is added, enforcing code quality via Ruff, typos, and security checks (Bandit, gitleaks, zizmor). The project also introduces structured documentation for contributors (\CONTRIBUTING.md\, \CODE\_OF\_CONDUCT.md\) and AI agents (\AGENTS.md\, \AGENT\_GUIDE.md\), alongside an AI usage policy (\AI\_POLICY.md\).

(repo-wide) · high confidence

Extracted common flow-matching sampling primitives (beta-distributed timestep sampling, forward-Euler denoising loop with optional real-time-chunking hooks) and VLA preprocessing helpers (sinusoidal positional embeddings, 2D attention mask construction, past key-value cloning, vector padding, and image resizing) from individual policy implementations into shared modules in \src/lerobot/policies/common\. This refactoring consolidates historically copy-pasted code into canonical, stateless functions, ensuring consistent behavior across openpi-derived policies (pi0, pi05, smolvla, eo1) without affecting existing checkpoints.

src/lerobot/policies/common · high confidence

The dataset module has been upgraded to version 3.0, introducing a new storage format and a comprehensive set of dataset editing tools. Users can now merge, split, delete, and modify episodes and features using the new \dataset\_tools\ module. The system also supports streaming from Hugging Face Storage Buckets, accepts authentication tokens for private datasets, and includes a new \BaseDatasetReader\ abstraction to handle different storage backends.

src/lerobot/datasets · high confidence

The training pipeline now uses a dedicated \lerobot.optim\ module to manage optimizer and learning-rate scheduler configurations. Users can select from multiple optimizer types (Adam, AdamW, SGD, and the XVLA-specific AdamW with differential learning rates) and several learning-rate schedules (Cosine Decay with Warmup, Diffuser, VQBeT, Constant with Warmup, and Cosine Annealing with Warmup) via dataclass configs. The new \make\_optimizer\_and\_scheduler\ factory constructs these components from the training pipeline config, and state save/load utilities are provided for both optimizers and schedulers to support checkpointing.

src/lerobot/optim · high confidence

The reinforcement learning algorithm module has been restructured to support a pluggable algorithm architecture. A new abstract base class (RLAlgorithm) and configuration registry (RLAlgorithmConfig) define the interface for algorithm training, state management, and serialization. The Soft Actor-Critic (SAC) algorithm is now implemented as a concrete subclass of this base, with its own dedicated configuration class (SACAlgorithmConfig) and factory functions to instantiate algorithms by name. This change introduces a standardized way to load, save, and extend RL algorithms within the Lerobot framework.

src/lerobot/rl/algorithms · high confidence

The Wall-X policy model has been refactored to subclass the native Hugging Face Transformers Qwen2.5-VL implementation rather than using a vendored copy. This change introduces support for Wall-X-specific Mixture-of-Experts (MoE) layers, including hard-routed expert MLPs and a causal-mask override that allows action tokens to attend bidirectionally. Additionally, the vision attention path now uses a packed \torch.nn.attention.varlen\ backend for improved performance on multi-camera frames, with a native SDPA fallback for compatibility.

_src/lerobot/policies/wall\_x/qwen\model · high confidence

Added behavior-pinning tests for flow-matching and VLA utility functions; Added comprehensive test coverage for distributed training, utility functions, and visualization helpers; Added comprehensive test coverage for the new data processor pipeline; Added comprehensive test suite for dataset operations; Added comprehensive tests for training configuration validation and plugin loading; Added mock hardware and robot components for testing; Added parity tests and vendored PyTorch reference for PI0/PI0.5 policies; Added smoke tests for the EO1 policy interface; Added test artifact generation script for policy policies; Added test artifacts and utility script for dataset backward compatibility; Added test artifacts for ALOHA simulation insertion policy; Added test artifacts for image transform configurations; Added test artifacts for pusht\_diffusion policy; Added test artifacts for xarm lift medium TDMPC policies; Added test coverage for dataset editing, evaluation, training, and annotation scripts; Added test coverage for environment configuration, dispatch, and new environment integrations; Added test coverage for motor bus implementations; Added test coverage for multiple robot integrations; Added test coverage for reward models and processors; Added tests for EMA, multi-GPU training, and visual validation; Added tests for GR00T N1.7 policy integration; Added tests for Hugging Face Jobs orchestration; Added tests for LingBot-VA policy configuration, factory, modules, and processor; Added tests for Multi-Task DiT policy; Added tests for PI0Fast policy integration; Added tests for RL actor-learner communication, data mixing, and training infrastructure; Added tests for Reachy 2, Rebot 102, and Unitree G1 teleoperators; Added tests for Real-Time Chunking (RTC) components; Added tests for SmolVLA Real-Time Chunking (RTC) policy; Added tests for Wall-X policy integration; Added tests for XVLA policy integration with LeRobot; Added tests for checkpoint contracts, save/resume logic, model publishing, and Weights & Biases integration; Added tests for optimizer and learning rate scheduler configuration and state persistence; Added tests for the FastWAM policy implementation; Added tests for the asynchronous inference stack; Added tests for the language annotation pipeline; Added tests for transport utility functions; Added unit tests for MolmoAct2 policy; Added unit tests for OpenCV, RealSense, and Reachy2 camera implementations; Added unit tests for the EVO1 policy implementation; Expanded test coverage for policy infrastructure and new policy implementations; Expanded test coverage for rollout, robot control, and configuration parsing; Initial test coverage for VLA-JEPA policy; Initialize model test package; New test fixtures for cadence, datasets, and policies.

The project is updated to version 0.6.2 with a comprehensive dependency manifest in pyproject.toml. Core requirements now mandate Python 3.12+ and constrain PyTorch to \>=2.7,\<2.12.0, torchvision to \>=0.22.0,\<0.27.0, and numpy to \>=2.0.0,\<2.3.0. Optional extras are defined for datasets (including platform-specific torchcodec versions), training (wandb, accelerate), hardware (pyserial, pynput), and visualization (rerun-sdk, foxglove-sdk). Specific constraints are applied to placo (\<0.9.16) and its cmeel dependencies to ensure ABI compatibility, while transformers is capped at \<5.6.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 69.

• Code Health 80
• Architecture 99
• Maturity 74
• Readiness 62
• Security 72

• 300 commits — 177 feature/other, 123 fixes

• src/lerobot — 202 commits
• docs/source — 41 commits
• (root) — 31 commits
• .github/workflows — 9 commits
• (repo) — 2 commits
• tests/policies — 2 commits
• tests/training — 2 commits
• .github/dependabot.yml — 1 commit
• docker/Dockerfile.internal — 1 commit
• docker/Dockerfile.jetson — 1 commit
• examples/annotations — 1 commit
• examples/dataset — 1 commit
• examples/isaac_teleop_to_so101 — 1 commit
• examples/rtc — 1 commit
• tests/cameras — 1 commit
• tests/conftest.py — 1 commit
• tests/motors — 1 commit
• tests/test_cli_peft.py — 1 commit

• fix: Fix ACT policy type examples in docs (#3792)
• fix: Fix Backtrackable.can_peek_back off-by-one contract violation (#4065)
• fix: Fix batch wandb logging metrics and handle scalar stats (#3821)
• fix: Fix metadata when parquet files columns have different orders (#3964)
• fix: Fix missing periods at end of sentences in README (#3473)
• fix: Fix pi0fast model id in docs (#3855)
• fix: Fix policy.path in YAML configs (PR #3145 followup) (#3597)
• fix: Fix reset config joint positions encoding (#4545)
• fix: Revert "fix(pyproject): adding ceiling bound on mujoco (<3.9.0) (#3751)" (#3754)
• fix: fix broken link (#4304)
• fix: fix convverstion err (#3656)
• fix: fix examples (#3623)
• fix: fix peft factory test mocking (#4201)
• fix: fix rollout policy revision loading (#4161)
• fix: fix(RGB only): remove the stereo module fallback when setting colors parameters on RealSense cameras (#4225)
• fix: fix(aggregate stats): fix episode statistics aggregation. Frames and episodes index statistics are offseted and tastk index statistics recomputed from the new labels. (#4276)
• fix: fix(cameras): D405 RealSense connection timeout on startup (#3894)
• fix: fix(cameras): release device handle when connect() setup fails (#4187)
• fix: fix(cameras): snapshot stop_event in read loops to avoid None deref (#3812)
• fix: fix(ci): benchmark jobs skipped for forks (#4411)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

huggingface/lerobot was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.