Introduction

Artificial intelligence has conquered text and images, but physical robotics has historically struggled with a severe agility-generalization trade-off. Training a robot to execute a highly agile movement like a backflip usually meant it would fail to adapt to generalized tasks like walking on uneven terrain without extensive, task-specific retraining. Humanoid-GPT, introduced by Galaxy General Robotics (Galbot) and accepted to CVPR 2026, applies large language model scaling laws directly to physical motion. With over 400 GitHub stars, Humanoid-GPT is the first GPT-style humanoid motion Transformer trained on a billion-scale corpus for whole-body control. It allows developers to deploy robust, zero-shot motion tracking on physical humanoid robots without needing secondary fine-tuning stages.

What Is Humanoid-GPT?

Humanoid-GPT is an open-source, generative pre-trained transformer designed specifically for zero-shot humanoid motion tracking. It replaces traditional multi-layer perceptron (MLP) architectures with a Causal Transformer utilizing Rotary Position Embeddings (RoPE). By processing variable-length motion sequences as input, it predicts and outputs real-time control commands for the 29 degrees of freedom (DOF) found in humanoid robots like the Unitree G1.

Developed in collaboration with researchers from Tsinghua University and Peking University, the repository provides a complete inference and deployment stack. The model relies heavily on a massively curated 2-billion-frame retargeted corpus, which unifies all major open-source motion capture datasets alongside large-scale in-house recordings. This massive data scale allows the model to treat physical motion as a continuous sequence problem, much like text generation.

Why Humanoid-GPT Matters

Historically, roboticists assumed that “scaling laws”—the principle that adding more data and parameters linearly improves performance—did not map cleanly to physical control systems. Previous reinforcement learning models required strictly constrained environments and struggled with out-of-distribution tasks. Humanoid-GPT proves that scaling laws hold true for physical robotics. By scaling the training data from millions to 2 billion frames, the zero-shot success rate of the model leaped from 76.89% (on older MLP architectures) to 92.58%.

This breakthrough drastically reduces the engineering overhead required to teach robots new skills. Previously, adding a new task required gathering domain-specific data, retraining the control policy, and carefully tuning reward functions. With Humanoid-GPT, researchers and engineers can pass arbitrary, unseen motion prompts to the humanoid, and the causal transformer will reliably track and execute the motion in a zero-shot manner. This capability bridges the gap between simulated capability and real-world deployment.

Key Features

• Billion-Scale Pre-Training: The model is trained on a 2-billion-frame motion corpus, marking the first time humanoid motion learning has been successfully scaled to this magnitude.
• GPT-Style Architecture: Utilizes a Causal Transformer with Rotary Position Embeddings (RoPE), enabling the system to support and attend to variable-length motion sequences efficiently.
• Zero-Shot Generalization: The architecture can track completely arbitrary, unseen motions and teleoperation commands without requiring any task-specific fine-tuning or secondary training epochs.
• Ultra-Low Inference Latency: The model is highly optimized for real-time control loops, achieving a staggering inference latency of just 0.39ms, which is critical for maintaining balance in physical hardware.
• Native Unitree G1 Support: The deployment code is explicitly optimized for the Unitree G1 humanoid robot, automatically handling the complexities of 29-DOF whole-body control.
• GPU-Accelerated Simulation: Integrates directly with MuJoCo-MJX, allowing researchers to run highly parallelized, GPU-accelerated simulations before deploying to physical robots.

How Humanoid-GPT Compares

To understand the utility of Humanoid-GPT, it is helpful to contrast it with existing frameworks that roboticists use for motion tracking, such as NVIDIA SONIC and mainstream kinematics systems like TWIST.

When compared to NVIDIA SONIC, Humanoid-GPT provides a more robust generalization capability. While SONIC was an excellent step forward for animating character motion in simulated physics, applying it to real-world humanoid robots often revealed limitations when faced with entirely out-of-distribution (OOD) tasks. Humanoid-GPT’s massive 2-billion-frame training corpus ensures that almost any reasonable humanoid motion falls within its learned distribution, yielding a much higher zero-shot success rate in physical deployments.

Against traditional setups like the TWIST system, the defining differentiator is inference speed and architecture complexity. Humanoid-GPT achieves a 0.39ms inference delay, which is approximately five times faster than TWIST’s typical ~1.95ms latency. This ultra-low latency is an absolute requirement for highly dynamic tasks, such as recovery from falls or agile athletic movements, where the control policy must react instantaneously to sensor feedback.

Getting Started: Installation

The repository provides an isolated Python environment setup to prevent dependency conflicts with other robotics frameworks. You will need a Linux machine with an NVIDIA GPU running CUDA 12.x. MacOS is also supported for testing and simulation purposes, though it defaults to CPU computation.

Prerequisites

Ensure you have Conda or Miniconda installed on your system, along with the appropriate NVIDIA drivers for CUDA 12.x.

Installation Steps

Clone the repository and create the dedicated Conda environment using Python 3.12, then install the package with CUDA extensions enabled.

git clone https://github.com/GalaxyGeneralRobotics/Humanoid-GPT.gitncd Humanoid-GPTnconda create -n h-gpt python=3.12 -ynconda activate h-gptnpip install -e ".[cuda
    ]"

If you are testing the simulation on a Mac, or if you only intend to deploy the inference code to a real robot without needing simulation dependencies, you can substitute the last command with pip install -e “.[cpu]” or pip install -e “.” respectively.

How to Use Humanoid-GPT

Once the environment is installed, the most common first step is to run the model inside the MuJoCo simulation viewer. This allows you to visually verify that the causal transformer is correctly processing motion commands and successfully tracking the generated sequences without risking physical hardware.

For standard Linux setups with a GPU, you can launch the application directly via Python. If you are operating on macOS, you must use the mjpython executable provided by the MuJoCo library instead of the standard Python interpreter. This ensures the viewer’s GUI loop renders correctly on Apple’s windowing system.

When the script initializes, the system loads the pre-trained checkpoints (located in the /storage/ckpts/ directory) and boots the MuJoCo-MJX physics environment. You can then pass target motion sequences to the tracker, and the simulation will display the Unitree G1 attempting to mimic the exact kinematics in real-time.

Code Examples

The repository provides straightforward entry points for testing inference and running the simulation viewer.

Running the Viewer (macOS)

To run the basic simulation application on macOS, utilize mjpython to launch the app script.

mjpython -m scripts.app

Running Inference (Linux)

For headless inference or testing the raw control outputs on a standard Linux environment, you can run the inference script directly using your Conda environment’s Python.

python -m scripts.inference

Advanced Configuration

Humanoid-GPT natively targets the Unitree G1 humanoid robot, which exists in several minor hardware revisions. To ensure that the physics simulation and control outputs perfectly match your specific physical robot, the repository supports hardware version selection via environment variables.

Before launching the inference or application scripts, you can declare the exact G1 hardware version in your terminal. This instructs the underlying architecture to load the correct URDF (Unified Robot Description Format) files and adjust the DOF mappings accordingly.

G1_VERSION=5010 python -m scripts.inference

Real-World Use Cases

The capabilities unlocked by scaling motion data and utilizing a GPT-style architecture enable several advanced robotics use cases.

1. Zero-Shot Teleoperation: Operators using VR headsets or motion capture suits can command the humanoid robot in real-time. Because the model generalizes perfectly to unseen motions, the robot can mimic the operator’s exact arm and leg movements instantly, without the engineering team needing to fine-tune the model for the specific teleoperation session.

2. Athletic and Dynamic Motion Tracking: Traditional MLPs often fail when tasked with highly dynamic movements like jumping, dancing, or kicking a soccer ball, due to the agility-generalization trade-off. Humanoid-GPT’s ultra-low latency and RoPE attention mechanism allow the robot to maintain balance while executing complex, high-velocity choreographies directly from reference data.

3. Rapid Sim-to-Real Deployment: Robotics companies can validate complex assembly-line or warehouse navigation behaviors purely in the MuJoCo-MJX simulation. Because the model bridges the sim-to-real gap effectively, those simulated successes translate directly to the physical Unitree G1 with minimal adjustment.

Contributing to Humanoid-GPT

As an active academic and commercial project presented at CVPR 2026, the repository is frequently updated. The authors outline a clear “TODO” list in the README, which includes planned releases for the underlying training code and the massive 2-billion-frame dataset. Developers interested in contributing to the codebase can fork the repository, test their changes using the provided simulation scripts, and submit pull requests via GitHub. Researchers utilizing the codebase are encouraged to cite the associated arXiv paper.

Community and Support

The primary hub for Humanoid-GPT discussions is its GitHub repository, managed by Galaxy General Robotics. Since its release, the project has gained significant traction on platforms like Trendshift and Twitter/X, where roboticists share videos of the Unitree G1 successfully tracking complex dances and athletic movements. For technical issues regarding installation or hardware version mismatches, users should utilize the GitHub Issues tab, where the core maintainers actively triage bugs and deployment queries.

Conclusion

Humanoid-GPT represents a pivotal shift in how the robotics industry approaches whole-body control. By discarding shallow, task-specific MLPs in favor of a massive, causal Transformer trained on billions of motion frames, Galaxy General Robotics has proven that the scaling laws driving modern AI apply directly to physical motion. The result is a highly capable, zero-shot motion tracker that operates with unprecedented speed and reliability.

For robotics researchers, simulation engineers, and embodied AI developers working with the Unitree G1, this repository offers an immediate, production-ready leap in capabilities. Star the repository, set up your Conda environment, and begin testing the boundaries of zero-shot robotic motion tracking today.

Resources

• Humanoid-GPT GitHub Repository
• Official arXiv Paper
• MuJoCo-MJX Documentation