Openlambda for Generalist Humanoid Learning

Highlights · Overview · Results · Get started · Hardware · Alignment · TODO · Citation

• 2026.10.27 🤖 Real-robot demonstration collection for Unitree G1 is released. See the collection guide (中文教程).
• 2026.10.21 🤗 The λ₀ report is featured in Hugging Face Daily Papers.
• 2026.10.14 🚀 openlambda is open-sourced with λ₀ training code, human data collection, motion alignment and alignment examples.
• 2026.10.13 📄 The λ₀ report is on arXiv: from everyday human experience to humanoid intelligence. The shape of λ echoes 人, the Chinese character for “human”.
• 2026.09.30 📄 Towards a General Humanoid Loco-Manipulation Model via Egocentric Whole-Body Human Data Pretraining is on arXiv.
• 2026.09.29 📄 EgoHumanoid-V2 and EgoAlign are on arXiv.

• 🌍 HumanVerse: 500 hours of robot-free capture across open-world scenes and tasks, pairing egocentric video with synchronized whole-body and hand motion.
• 🔗 Robot-aligned data pipeline: human video and motion are aligned to the robot's camera view and action space (details).
• ⚡ Cheaper data: about 3.4× collection throughput compared with robot teleoperation across representative task families (≈29 s vs. ≈100 s per demonstration).
• 🤖 Strong transfer on Unitree G1: 62.5% real-world success and 80.4% task progress over four tasks, +22.5 and +25.8 points over the strongest external baseline.

λ₀ couples a shared vision–language backbone with an action expert. It takes a robot camera image, a language instruction and proprioception, and outputs whole-body motion tokens executed by SONIC together with hand commands. Training runs in three stages:

Real-world evaluation on Unitree G1 across four tasks (Close Laptop, Open Fridge, Pull Curtain, Close Drawer), 40 trials per method.

• Simulation: 90.0% success on SIMPLE (six core tasks, three difficulty levels, 180 trials).
• Zero-shot transfer: 76.2% progress on long-range loco-manipulation (EgoAlign) and 51.7% on whole-body loco-manipulation (EgoHumanoid-V2).
• Data scaling: with a fixed 2B model, going from 5% to 100% of the human data lowers the minimum validation loss by 35.5% on the representative holdout and 40.6% on the clean holdout.

See the project page and the report for the full evaluation.

git clone https://github.com/LambdaHumanoid/openlambda.git
cd openlambda

Requires Python 3.11 or 3.12. From the repository root:

PYTHON=python3.11 bash scripts/install.sh
source .venv/bin/activate
python scripts/test.py -v

scripts/test.py checks package installation and CLI compatibility.

Optional extras: bash scripts/install.sh serve,tracking enables HTTP inference and WandB; fast adds platform-dependent GPU kernels. Existing environments can still use python -m pip install -e . (or .[serve], .[tracking], .[fast]) from the repository root.

The Stage III example initializes from the raw weights in the Stage II checkpoint. Set STAGE2_CHECKPOINT_DIR to its downloaded directory.

From the repository root, set the paths required by the selected config, then prepare data and validate it (Stage I example). Relative paths in JSON configs resolve from the config file; command-line paths resolve from the current working directory:

python scripts/prepare.py --source-config configs/lambda0/pretrain/data.json \
  --data-root "$DATA_ROOT" --output "$BUNDLE_DIR"
python scripts/train.py --config configs/lambda0/pretrain/train.json --check-only

Human Hardware 🔴 PICO 4 Ultra Tracking: PICO 4 Ultra + trackers for whole-body and hand tracking Software: XRobo​Toolkit Setup guide · Python SDK Connec​tion: same LAN as the PC enable Head, Hand and Send 🔵 5× PICO Trackers Placement: five trackers both wrists, waist and both ankles Calibration: PICO Motion Tracker pair and calibrate in the app (guide) Mode: Full Body in XRobo​Toolkit enable Hand tracking (setup guide) 🟠 GoPro Mount: neck-mounted bracket Example: JD listing Alignment: match height, pitch and framing to the robot camera Connec​tion: Bluetooth pairing and WiFi setup; WiFi / COHN recording and download (API)

Robot Hardware 🟢 Unitree G1 Platform: Unitree G1, 29 body DOF excluding hands (joint layout) Control: SONIC whole-body controller runs on an external Linux PC Connec​tion: wired or WiFi to the PC via the ZMQ bridge 🔵 BrainCo Revo2 Hand: 6 active DOF per hand 11 including passive joints (specs) Software: official SDK hand control and state feedback Mount: custom G1–Revo2 adapters STL: part 1 · part 2 🟠 GoPro Mount: head-mounted bracket STL: part 1 · part 2 Alignment: match height, pitch and framing to the human camera Connec​tion: USB control and video to robot; wired / WiFi forwarding to host (API)

Use separate environments for robot control, human collection, and model training.

sudo apt-get update
sudo apt-get install -y --no-install-recommends ca-certificates curl build-essential cmake git git-lfs libgl1 libegl1 libegl-mesa0 libglib2.0-0 ffmpeg libyaml-cpp-dev libeigen3-dev libmsgpack-dev libzmq3-dev nlohmann-json3-dev libssl-dev zlib1g-dev
curl -LsSf https://astral.sh/uv/0.11.14/install.sh | sh
source "$HOME/.local/bin/env"
curl -fL https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.1-1_all.deb -o /tmp/cuda-keyring.deb
sudo dpkg -i /tmp/cuda-keyring.deb
sudo apt-get update
sudo apt-get install -y --no-install-recommends cuda-minimal-build-12-4

sudo tar -xzf TensorRT-10.13.3.9.Linux.x86_64-gnu.cuda-13.0.tar.gz -C /opt
curl -fL https://github.com/microsoft/onnxruntime/releases/download/v1.16.3/onnxruntime-linux-x64-1.16.3.tgz -o /tmp/onnxruntime.tgz
sudo tar -xzf /tmp/onnxruntime.tgz -C /opt

export TensorRT_ROOT=/opt/TensorRT-10.13.3.9
export onnxruntime_ROOT=/opt/onnxruntime-linux-x64-1.16.3
export CUDAToolkit_ROOT=/usr/local/cuda-12.4
export LD_LIBRARY_PATH="$TensorRT_ROOT/lib:$onnxruntime_ROOT/lib:$CUDAToolkit_ROOT/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
bash data_collection/robot/setup/install_host.sh

source sonic/.venv/bin/activate

sudo apt-get update
sudo apt-get install -y python3-dev python3-venv build-essential cmake git python3-colcon-common-extensions ros-foxy-rmw-cyclonedds-cpp ros-foxy-rosidl-generator-dds-idl libyaml-cpp-dev libssl-dev libgl1 libglib2.0-0
bash data_collection/robot/setup/install_robot.sh

source /opt/ros/foxy/setup.bash
source .venv-robot/ros_ws/install/setup.bash
source .venv-robot/bin/activate

sudo apt-get update
sudo apt-get install -y ca-certificates python3.10-dev python3.10-venv build-essential cmake git ffmpeg bluez network-manager
bash data_collection/human/setup/install.sh

source .venv-human/bin/activate

1. Prepare devices.

Connect the host and PICO headset to the same network. Start the XRoboToolkit PC service on the host and the XRoboToolkit app on the headset, then enable body and hand tracking. Turn on the GoPro, enable Bluetooth pairing and select Video mode; the collector connects it to the host's WiFi network in the next step.

2. Start recording.

lambda-collect-human --task-name "{task_name}" --task "{task_instruction}"

Open http://127.0.0.1:8080. Enter the host's WiFi credentials if needed, then click Prepare collection → Start recording → Save episode / Discard episode. Wait for saving before recording again. Episodes are saved in LeRobot format to data/{task_name}/; new recordings append to the dataset.

3. Check and synchronize data.

lambda-sync-human --root "data/{task_name}"

Synchronizes motion and video at 50 Hz. Output: data/{task_name}_synced/; synchronization and quality reports: meta/.

Record G1/SONIC/Revo2 demonstrations with a wired GoPro. Video, robot states and hand targets are saved on G1 during teleoperation, then aligned and exported as Parquet and MP4 on the workstation.

Follow the collection guide or 中文教程 to record your first episode. The data format reference covers the 44D state and 76D action layout for training adapters.

Four example trajectories and their data, reports, and videos are available. Each replay compares motion before (left) and after (right) alignment.

1. Align motion.

The pipeline performs human-reference alignment, robot-reference alignment, and dynamics-aware optimization. For hand tasks, H first corrects SMPL collar, shoulder, and elbow poses using a uniformly scaled virtual body while preserving the original end-effector targets. Foot tasks encode the input SMPL directly without this correction; K and D retain their joint-space and motion-token optimization.

Place the input recording at {task_name}/input.parquet. Set {endpoints} to hands for hand alignment or feet for foot alignment.

lambda-align \
  --input "{task_name}/input.parquet" \
  --endpoints {endpoints} \
  --output "results/{task_name}"

Results are saved under results/{task_name}/: data.parquet contains the original human SMPL motion and aligned tokens; run.json records per-round metrics and the selected round.

2. Replay motion.

SMPL replay: encode the original human motion online, without human-reference correction, to simulate before alignment.

lambda-replay \
  --input "{task_name}/data.parquet" \
  --mode smpl \
  --output "results/{task_name}/before"

Token replay: replay the aligned motion tokens to simulate after alignment.

lambda-replay \
  --input "{task_name}/data.parquet" \
  --mode token \
  --output "results/{task_name}/after"

Each command saves replay.mp4 in its output directory. Results may vary slightly between runs.

python scripts/serve.py (also lambda0 serve) takes camera observations, language instructions, and proprioceptive state, and returns SONIC motion tokens and Revo2 hand commands. It does not send actuator commands. Motion-level simulation replay is available under Action alignment.

• Human data collection, synchronization and motion alignment
• Real-robot demonstration recording on G1
• Stage II checkpoint on Hugging Face
• HumanVerse sample data on Hugging Face
• Hardware guides: assembly, calibration, connectivity checks and troubleshooting for the human and robot setups
• Visual alignment: render the robot arm into human egocentric video to match the robot camera view
• Data conversion: episode validation and converters from human and robot recordings to the canonical training format
• Training and evaluation: complete Stage III post-training and policy evaluation workflows
• SIMPLE evaluation: release the evaluation pipeline and a guide for reproducing results on the six SIMPLE core tasks
• Deployment: connect policy outputs to the robot controller with runtime monitoring and safety checks
• Beginner tutorial: setup, a sample recording, data preparation and local inference with expected outputs

Join our WeChat community to discuss humanoid intelligence, human data, and λ₀. For bug reports and feature requests, please open a GitHub issue.

微信扫码加入 Lambda0 交流群

If you find λ₀ or openlambda useful in your research, please cite our report:

@misc{lambdahumanoidteam2026lambda0scalingopenworldegocentric,
  title         = {$\lambda_0$: Scaling Open-World Egocentric Human Data for Humanoid Loco-Manipulation},
  author        = {{Lambda-humanoid Team}},
  year          = {2026},
  eprint        = {2610.18950},
  archivePrefix = {arXiv},
  primaryClass  = {cs.RO},
  url           = {https://arxiv.org/abs/2610.18950},
}

@article{xu2026generalhumanoidlocomanipulationmodel,
  title   = {Towards a General Humanoid Loco-Manipulation Model via Egocentric Whole-Body Human Data Pretraining},
  author  = {Xu, Chongyang and Wu, Zhao and Chen, Jin and Jiang, Yiming and Ye, Jinhui and Jiang, Yuming and Zhang, Shifeng and Feng, Ziliang and Xu, Mu and Chen, Yilun and Lu, Li and Hoi, Steven C. H.},
  journal = {arXiv preprint arXiv:2610.00438},
  year    = {2026}
}

@article{chen2026egohumanoidv2,
  title   = {{EgoHumanoid-V2}: Human-to-Humanoid Transfer of Coordinated Whole-Body Skills for Loco-Manipulation},
  author  = {Chen, Jin and Jiang, Yiming and Xu, Chongyang and Shi, Modi and Peng, Shijia and Chen, Li and Li, Tianyu and Xu, Mu and Chen, Yilun and Hoi, Steven and Li, Hongyang},
  journal = {arXiv preprint arXiv:2609.37181},
  year    = {2026}
}

@article{jiang2026egoalign,
  title   = {{EgoAlign}: Bridging the Human-Humanoid Gap for Long-Range Loco-Manipulation},
  author  = {Jiang, Yiming and Chen, Jin and Xu, Chongyang and Chen, Yilun and Hao, Aimin and He, Yisheng},
  journal = {arXiv preprint arXiv:2609.38046},
  year    = {2026}
}

openlambda builds on the following open-source projects and prior work. We thank their authors for making them available.

See NOTICE for detailed source and asset attributions.

openlambda is released under the Apache License 2.0.

Third-party components keep their original licenses:

• The Unitree G1 model files in data_collection/robot/hardware/model are licensed under the BSD 3-Clause License.
• SONIC, hardware SDKs and model weights are installed separately and are subject to their own licenses and terms.