UniLab

Contract-driven infrastructure for robot learning across physics backends and hardware

Languages: English | 简体中文

🎉 🎉 UniLab has been accepted to CoRL 2026! 🎉 🎉

One task-authoring surface for locomotion, manipulation, and motion tracking.

UniLab is configurable infrastructure for robot reinforcement learning. Describe a task with Hydra, assemble it from manager terms, select a physics backend, and train or evaluate through one CLI. The same task-facing contract connects CPU, GPU, and external-worker simulation to the learner runtime.

The same framework has documented paths for Windows, Apple Silicon macOS, Linux CUDA, AMD ROCm, and Intel XPU. Backend and task maturity are evidence-graded; use the support matrix to choose a tested combination.

See policies in action on the project page, or read Why UniLab? to understand the project fit, evidence, and comparison with alternatives.

Highlights

UniLab's core idea is simple: define task semantics once as reusable configuration, then change the simulator, hardware, or learner without rewriting the task's environment lifecycle.

• Configure, don't code. Actions, observations, rewards, terminations, events, commands, curricula, and metrics are manager terms assembled in Hydra owner YAML. Variants built from existing terms need no new environment class — often no Python code at all.
• Change the backend, keep the workflow. Registered simulators meet the public SimBackend contract. Choose a backend with --sim; when a matching task owner exists, task authoring and train/eval stay consistent while backend-specific details remain explicit.
• Keep solver and learner devices independent. CPU-parallel, native, or external-worker simulation can feed an accelerator learner without first becoming a CUDA-resident simulator. The learner can run on CUDA, ROCm, MPS, or XPU; the support matrix records the evidence level of each backend/task combination.
• Accelerate replay-based off-policy training. SAC/FlashSAC lets simulation data collection overlap with learner updates. The paper reports 3–10× end-to-end gains on representative configurations; see Why UniLab for scope and measurements.

Quick start

The supported source workflow uses uv. This is the shortest path to a policy demo:

curl -LsSf https://astral.sh/uv/install.sh | sh
git clone https://github.com/unilabsim/UniLab.git
cd UniLab

make setup
# Downloads the checkpoint and assets from Hugging Face on first run.
uv run demo dance

For Windows, macOS, CUDA, ROCm, XPU, optional backends, and headless rendering, use the installation guide and quick demo guide.

Train and evaluate

# Train the g1 flat-walking task with MuJoCo and replay it.
uv run train --algo sac --task g1_walk_flat --sim mujoco
uv run eval --algo sac --task g1_walk_flat --sim mujoco --render-mode viser

# sim2sim
#   motrixsim
uv run --extra motrix eval --algo sac --task g1_walk_flat --sim motrix --render-mode interactive --load-run -1
#   newton
uv run --extra newton eval --algo sac --task g1_walk_flat --sim newton --load-run -1
#   isaacgym
bash scripts/tools/setup_isaacgym_env.sh
uv run eval --algo sac --task g1_walk_flat --sim isaacgym --load-run -1


# Train the g1 motion-tracking task with mjwarp and replay it with Genesis physics.
uv run --extra mjwarp train --algo flashsac --task g1_motion_tracking --sim mjwarp
# Two GPUs
CUDA_VISIBLE_DEVICES=0,1 \
  uv run --extra mjwarp train --algo flashsac --task g1_motion_tracking --sim mjwarp
uv run --extra genesis eval --algo flashsac --task g1_motion_tracking --sim genesis --load-run -1

To use MPS, start one service per selected GPU before training, append training.cuda_process_sharing=mps to the training command, and stop those services manually after training. For example, for GPUs 0 and 1:

uv run uni-cumps start --gpus 0 --name train-gpu0 --daemon
uv run uni-cumps start --gpus 1 --name train-gpu1 --daemon
CUDA_VISIBLE_DEVICES=0,1 \
  uv run --extra mjwarp train --algo flashsac --task g1_motion_tracking --sim mjwarp \
  training.cuda_process_sharing=mps
# Run training, then stop only these services after its processes exit.
uv run uni-cumps stop --name train-gpu0
uv run uni-cumps stop --name train-gpu1

An mps request binds each rank to its GPU's recorded service automatically (index-form CUDA_VISIBLE_DEVICES entries are normalized to GPU UUIDs, which per-GPU MPS servers require, before CUDA initializes); uni-cumps env is only for external launchers — do not eval it for training, since it pins visibility to a single GPU. Run these management commands without a conflicting GPU mask. For more options, use uv run uni-cumps --help. See execution contracts.

The flags keep algorithm, task, and simulator choices visible. Resume, W&B, Hydra overrides, playback, backend setup, and the full command matrix belong in the training guide, backend guide, and support matrix.

Ecosystem

UniLab is designed to be a shared task and training surface for robot-specific repositories. They can ship robot recipes independently while consuming the same task, backend, and RL contracts. Current downstream examples:

• MicroDuck RL
• EngineAI RL
• Unitree RL
• Wuji
• Legged Manipulation
• Sharpa
• Cricket-Gym

Documentation

• Why UniLab?
• Installation and first demo
• Training and evaluation
• Backend support matrix
• Sim-to-sim deployment
• Developer guide

For development and contribution workflows, see the contributing guide.

Community

Add the UniLab assistant on WeChat to join the community.

Citation

@article{jia2026unilab,
  title         = {UniLab: A Heterogeneous Architecture for Robot RL Beyond GPU-Dominant Paradigms},
  author        = {Jia, Yufei and Cao, Zhanxiang and Yu, Mingrui and Zhang, Heng and Chen, Shenyu and Jiang, Dixuan and Li, Meng and Li, Xiaofan and Liu, Yiyang and Wu, Junzhe and Li, Zheng and Fang, XiLin and Cui, Tingyu and Fu, Shengcheng and Li, Haoyang and Wang, Anqi and Wang, Zifan and Zhu, Dongjie and Cao, Chenyu and Huang, Zhenbiao and Zheng, Ziang and Lu, Jie and Ma, Xin and Wei, Zhengyang and Zhao, Xiang and Zhan, Tianyue and He, Ye and Chen, Yuxiang and Jiang, Yizhou and Li, Yue and Ge, Haizhou and Dong, Yuhang and Jia, Fan and Zhang, Ziheng and Zhang, Meng and Deng, Xiwa and Chen, Zhixing and Shao, Hanyang and Dong, Chenxin and Li, Yixuan and Chen, Yizhi and Chen, Bokui and Zhang, Kaifeng and Cui, Hanqing and Qin, Yusen and Huang, Ruqi and Han, Lei and Wang, Tiancai and Li, Xiang and Gao, Yue and Zhou, Guyue},
  journal       = {arXiv preprint arXiv:2605.30313},
  year          = {2026},
  url           = {https://arxiv.org/abs/2605.30313}
}

UniLab is released under the Apache License 2.0. See the independent UniSim repository for its own release and citation information. The RL stack (algorithms, async runtime, training logging) ships inside this repository under src/unilab/rl/; it was merged from the former unilab_rl repository, which is kept for historical reference.

Acknowledgments

UniLab would not exist without the excellent work of the Isaac Lab team and the mjlab developers and contributors. Isaac Lab's manager-based API design and abstractions, together with mjlab's clear, lightweight reference implementation, helped shape UniLab's Hydra and NumPy task authoring experience. We sincerely thank both communities for sharing their work and ideas.