- Oct 28, 2026: Metatron is released. Metatron is our generative whole-body policy for the Unitree G1: one network that handles motion tracking, steering, path following, reaching for sparse body goals, scene interaction and getting back up after a fall. Read the paper and the project page, try it in your browser with the interactive demo, race six of them in G1 Racer, download the weights and the native package from Hugging Face with
python scripts/download_metatron.py, or train your own with the Metatron G1 student guide. - Oct 28, 2026:
mainreceived a major refactor. The environment is now a short list of explicit step phases over modular state owners and task control components, with checked boundaries between them, so a change in one place cannot silently break another. Experiments use a cleaner configuration system and a declarative way of authoring observations, rewards and terminations as pure tensor kernels bound to named context paths. Sensors are declared once per channel, each with measurement noise and a state-estimation stage, which gives domain randomization and sim-to-real transfer a principled footing. Saved configurations from earlier versions must be regenerated, and the Genesis backend has been removed; the changelog has the full list.
ProtoMotions3 is a GPU-accelerated simulation and learning framework for training physically simulated digital humans and humanoid robots. Our mission is to provide a fast prototyping platform for various simulated humanoid learning tasks and environments—for researchers and practitioners in animation, robotics, and reinforcement learning—bridging efforts across communities.
Modularity, extensibility, and scalability are at the core of ProtoMotions3. It is community-driven and permissively licensed under the Apache-2.0 license.
Also check out MimicKit, our sibling repository for a lightweight framework for motion imitation learning.
Train a generative policy that chooses its own "move" to finish a task instead of following one reference clip. MaskedMimic learns a single policy that completes a motion from partial goals such as a few target bodies, a path or objects in the scene. The GPC recipe trains a reusable discrete latent prior and then adapts it to new tasks with small PEFT adapters; see the GPC and PEFT guide. Our released Unitree G1 policy, Metatron, is trained this way: a MaskedMimic-style student distilled from a motion-tracking teacher, whose learned prior turns tracking, steering, body-goal, scene and recovery goals into whole-body motion. Run it in the browser demo, race it in G1 Racer, download the weights from Hugging Face, or follow the Metatron G1 student guide to train your own.
 |
 |
| GPC: human-scene interaction | G1 Racer: six robots, one batched Metatron policy, in your browser |
 |
|
| Metatron on the real G1: sitting and standing, whole-body teleoperation, recovery from the ground | |
Train your fully physically simulated character to learn motion skills from the entire public AMASS human animation dataset (40+ hours) within 12 hours on 4 A100s.
Scale training to even larger datasets with each GPU handling a subset of motions. For example, we have trained with 24 A100s with 13K motions on each GPU with the BONES dataset in SOMA skeleton format. Check out Quick Start and SEED BVH Data Preparation to play around with the dataset and pre-trained models today.
Transfer (retarget) the entire AMASS dataset to your favorite robot with the built-in PyRoki-based optimizer—in one command.
Note: As of v3, we use PyRoki for retargeting. Earlier versions used Mink.
Train your robot to perform AMASS motor skills in 12 hours, by just changing one command argument:
--robot-name=smpl → --robot-name=h1_2 and preparing retargeted motions (see here)
One-click test (--simulator=isaacgym → --simulator=newton → --simulator=mujoco) of robot control policies on H1_2 or G1 in different physics engines (NVIDIA Newton, MuJoCo CPU). Policies shown below only use observations you could actually get from real hardware.
Train in simulation, deploy on real hardware. ProtoMotions trains one General Tracking Policy on entire BONES-SEED dataset (~142K motions) and transfers directly to the Unitree G1 humanoid robot zero-shot.
Our deployment pipeline exports a single ONNX model (with observation computation baked in), so deployment frameworks only need to provide raw sensor signals — no need to rewrite obs functions or match training internals. We tested on the Unitree G1 via the brilliant RoboJuDo framework, adding just one policy file with no mandatory changes to RoboJuDo core.
📖 Full Deployment Tutorial — from data preparation to real robot, fully reproducible.
Large generative policies such as Metatron are a different deployment problem from a small tracking network: a transformer with several hundred megabytes of weights has to return a command within its policy period, every step, so latency has to be engineered end to end instead of left to a general-purpose Python stack. For that we also prototype our own deployment runtime: a standalone C++ runtime with MuJoCo and Unitree G1 backends, a safety supervisor, a policy mapping workflow, and a TensorRT build and qualification pipeline. See Deployment runtime (experimental). That folder is prototyping reference code for people building their own deployment path, not a supported release artifact.
Test your policy in IsaacSim 5.0+, which allows you to load beautifully rendered Gaussian splatting backgrounds (with Omniverse NuRec — this rendered scene is not physically interact-able yet).
With Kimodo (NVIDIA's text-to-motion generation model), generate any motion from a text prompt and use ProtoMotions to train a physics-based policy that performs the motion — for both the SOMA animation character and the Unitree G1 robot. Policies trained this way can be deployed directly on real hardware.
See Kimodo Data Preparation for how to convert Kimodo outputs to ProtoMotions format.
Image Credit: NVIDIA Human Motion Modeling Research
Procedurally generate many scenes for scalable Synthetic Data Generation (SDG): start from a seed motion set, use RL to adapt motions to augmented scenes.
Train your robot to hike challenging terrains!
Have a new task? Build it from modular components — no monolithic env class needed. Here's how the steering task is composed:
| Layer | File | What it does |
|---|---|---|
| Control | steering_control.py |
Manages task state (target direction, speed, facing). Periodically samples new heading targets. |
| Observation | obs/steering.py |
Pure tensor kernel — transforms targets to robot-local frame → 5D feature vector. |
| Reward | rewards/task.py |
compute_heading_velocity_rew — blends direction-matching (0.7) and facing-matching (0.3) rewards. |
| Experiment | steering/mlp.py |
Wires components together as MdpComponent instances via context paths. |
Each piece is a standalone function or class — the experiment config binds them into a complete task using MdpComponent and FieldPath descriptors.
Want to try a new RL algorithm? Implement algorithms like ADD in ProtoMotions in ~50 lines of code, utilizing our modularized design:
📄 protomotions/agents/mimic/agent_add.py
Would like to use your own simulator? Implement these APIs interfacing among different simulators:
📄 protomotions/simulator/base_simulator/
Refer to the MuJoCo backend as the smallest reference implementation:
📄 protomotions/simulator/mujoco/
Want to add your own robot? Follow these steps:
- Add your
.xmlMuJoCo spec file toprotomotions/data/assets/mjcf/ - Create
protomotions/robot_configs/<your_robot>.pydefining exactly one class whose direct base isRobotConfig(copyprotomotions/robot_configs/g1.pyand fill in the fields) - That is the registration:
protomotions/robot_configs/factory.pyscans that directory, so the file's stem is the name you pass to--robot-name. There is nothing to edit in the factory. If the robot goes into this repository and you run the test suite, also add its name to_ROBOTSinprotomotions/tests/test_robot_facts_d1.py, which pins the registered list.
And you're good to go!
- Installation Guide
- Quick Start
- GPC and PEFT
- AMASS Data Preparation
- PHUMA Data Preparation
- SEED BVH Data Preparation
- SEED G1 CSV Data Preparation
- Kimodo Data Preparation
- Tutorials
- API Reference
- G1 Deployment: Data to Real Robot
We welcome contributions! Please read our Contributing Guide before submitting pull requests.
ProtoMotions3 source code is released under the Apache-2.0 License.
NVIDIA-provided pretrained models are released under the NVIDIA Open Model License, unless their model card explicitly states otherwise. Each model directory includes its model card, license and attribution notice. See model licensing and redistribution.
Third-party software and bundled asset notices are listed in legal/, including Unitree, BeyondMimic, Isaac Lab, and SMPL/SMPL-H attribution and license notices.
If you use ProtoMotions3 in your research, please cite:
@misc{ProtoMotions,
title = {ProtoMotions3: An Open-source Framework for Humanoid Simulation and Control},
author = {Tessler*, Chen and Jiang*, Yifeng and Peng, Xue Bin and Coumans, Erwin and Shi, Yi and Zhang, Haotian and Rempe, Davis and Chechik†, Gal and Fidler†, Sanja},
year = {2025},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/NVLabs/ProtoMotions/}},
}
