What is ARDY?
The project's full name is "ARDY: Autoregressive Diffusion with Hybrid Representation for Interactive Human Motion Generation". The paper appeared as article 86 in ACM Transactions on Graphics 45(4), and the repository introduces it as a SIGGRAPH paper. The authors are Kaifeng Zhao, Mathis Petrovich, Haotian Zhang, Tingwu Wang, Siyu Tang and Davis Rempe.
According to the README, the model supports online text prompting and flexible long-horizon kinematic constraints with real-time responsiveness. The constraints come in four kinds:
- Root paths and waypoints
- Full-body keyframes
- Sparse joint positions
- Sparse joint rotations
The repository provides code, checkpoints and demos. The code lives in nv-tlabs/ardy, and the weights are on the nvidia account on Hugging Face.
How does ARDY work?
ARDY generates motion step by step rather than in one pass. At each autoregressive step the model takes text embeddings and optional kinematic constraints and returns new motion frames. The entry point in the code is Ardy.autoregressive_step(), and constraints are passed through the motion_mask and observed_motion tensors.
On the text side, the LLM2Vec encoder runs on top of the gated Meta-Llama-3-8B-Instruct model. The repository carries a version of the LLM2Vec codebase patched to work with transformers 5.0.0rc3.
The demo settings also show how the model works. History Crop Length limits the number of history frames given to the model. A short history adapts faster to new prompts, while a long history gives context for complex semantic motion and smoother transitions. The models were trained with a 10-second window. Replanning starts when the number of unplayed frames drops to the Replan Trigger Threshold. An optional motion correction step written in C++ reduces foot skating.
The Unitree G1 models and the other checkpoints
ARDY ships six checkpoints. All were trained on Bones Rigplay 1 data and are licensed under the NVIDIA Open Model Agreement. Skeleton, FPS and prediction horizon vary by model:
| Model | Skeleton | FPS | Horizon | Release |
|---|---|---|---|---|
| ARDY-Core-RP-20FPS-Horizon40 | Core | 20 | 40 | July 10, 2026 |
| ARDY-Core-RP-20FPS-Horizon8 | Core | 20 | 8 | July 10, 2026 |
| ARDY-G1-RP-25FPS-Horizon52 | Unitree G1 | 25 | 52 | July 10, 2026 |
| ARDY-G1-RP-25FPS-Horizon8 | Unitree G1 | 25 | 8 | July 10, 2026 |
| ARDY-SOMA-RP-30FPS-Horizon60 | SOMA | 30 | 60 | October 15, 2026 |
| ARDY-SOMA-RP-30FPS-KimodoRep-Horizon60 | SOMA | 30 | 60 | October 15, 2026 |
On the command line you call the G1 model with the nickname g1 or g152. For the G1, the generation script writes a MuJoCo-qpos .csv file next to the .npz file. Kinematic constraint sampling in the demo draws on the G1 CSV motions of the Bones SEED dataset. The KimodoRep variant was trained on Kimodo's smoothed-root representation instead of raw hips.
According to the README, ARDY can be used as a motion planner for GEAR SONIC, the behaviour foundation model for physical humanoid robots. ARDY outputs kinematic motion. On the robot a tracking controller executes that motion, and you handle joint limits and safety validation in that layer.
Interactive demo and command line
The interactive demo starts with python scripts/run_demo.py and runs in the browser at http://localhost:2333. You steer the character with the prompt you type. The p key enables mouse waypoints, the t key enables target-velocity control with the arrow keys, and the z key samples kinematic constraints from a dataset sequence. In the Model tab you choose TensorRT, torch.compile or no acceleration. At the default cuda / bfloat16 setting the text encoder uses about 14 GB of VRAM.
For batch generation there is scripts/generate.py. For example, python scripts/generate.py "A person waves." --model g1 --num_samples 4 --output waves writes four samples to outputs/waves/. Each .npz file holds world-space joint positions (posed_joints), joint rotations, root positions, foot contacts, the fps and the prompt text. Play the result with scripts/visualize.py at http://localhost:2334. If you generate often, start the text encoder service in the background with python scripts/run_text_encoder_server.py so that each run skips reloading the model.
Setup summary
The repository has mainly been tested on Ubuntu Linux 22.04 with an RTX 4090, nvidia-driver-575 and Python 3.11. The minimum is Python 3.10 and PyTorch 2.4. Setup takes these steps:
- Create a fresh Python environment with conda or venv.
- Install the PyTorch build that matches your CUDA version yourself first.
- Run pip install -e ".[all]" in the repository root. The install builds the motion correction extension, so CMake 3.15 and a C++17 compiler are required.
- Get access to Meta-Llama-3-8B-Instruct for your Hugging Face account and register your token with hf auth login.
For inference only, pip install -e . is enough. Choose the .[demo] extra for the demo and .[trt] for TensorRT acceleration. The TensorRT extra needs an NVIDIA driver 525 or newer and access to pypi.nvidia.com during install. Checkpoints download automatically the first time the demo uses them. For the constrained generation demo, put the Bones SEED data in datasets/bones-seed/. We collected Turkish setup notes in our Turkish repository.
ARDY on the Kimodo benchmark
NVIDIA evaluated ARDY-SOMA-RP-30FPS-Horizon60 on the Kimodo Motion Generation Benchmark. The same table includes Kimodo-SOMA-RP-ArdyRep-v1.2, which predicts the same motion representation. A few values from the Content split:
| Metric | ARDY-SOMA-RP-30FPS-Horizon60 | Kimodo-SOMA-RP-ArdyRep-v1.2 |
|---|---|---|
| Overview R@3 (higher is better) | 77.86 | 82.12 |
| Overview Skate, cm/s (lower is better) | 2.760 | 3.625 |
| With-text FB Pos, cm (lower is better) | 2.77 | 3.08 |
| With-text 2D Root, cm (lower is better) | 1.47 | 2.90 |
In these rows ARDY scores lower on foot skating and constraint error, while Kimodo leads on text matching (R@3). To reproduce the evaluation, you build the test suite in the Kimodo repository, generate with scripts/generate_eval.py in the ARDY repository and finish scoring back in the Kimodo repository. The full tables and protocol notes are in the Turkish README.
Licence split
The ARDY codebase is licensed under Apache-2.0. Model checkpoints and data come under separate licences, as indicated on the Hugging Face download pages. The checkpoint table lists the NVIDIA Open Model Agreement for all six models.
| Part | Licence |
|---|---|
| Code | Apache-2.0 |
| Model checkpoints | NVIDIA Open Model Agreement (on the Hugging Face page) |
| Llama model behind the text encoder | Access terms on the Meta-Llama-3-8B-Instruct page |
| Bones SEED data | Terms on the Hugging Face dataset page |
The project downloads third-party open-source software during install, and the repository collects these notices in ATTRIBUTIONS.MD. If you plan a commercial project, review these terms with your legal team first.
Where to start
ARDY runs on a workstation with an NVIDIA GPU and generates kinematic motion for the G1. Moving to the robot goes through a whole-body controller and the SDK, so the layer your work runs on decides the product.
| Work | Starting point | Related page |
|---|---|---|
| Text-to-motion and interactive character tests | The ARDY demo on a workstation, without a robot | Turkish ARDY repository |
| Offline motion authoring | Kimodo | Kimodo guide |
| Real-time inbetweening between poses | MotionBricks | MotionBricks guide |
| Tracking generated motion on the real robot | Unitree G1 EDU and GEAR SONIC | G1 EDU quote, GEAR SONIC guide |
| Tracking reference motion with reinforcement learning | G1 EDU and simulation | RL Gym |
| Lab setup | G1 research platform | G1 research platform |
Our central guide to NVIDIA's humanoid motion projects explains how the projects connect. For the Isaac GR00T workflow see the Unitree G1 and Isaac GR00T guide, and for collecting real demonstration data see the G1 teleoperation page.
Frequently asked questions
Does ARDY move the Unitree G1 directly?
ARDY generates kinematic motion for the G1 skeleton. According to the README, this motion can be given as planner output to GEAR SONIC, which handles whole-body control on the real robot.
What hardware do I need?
A CUDA-capable NVIDIA GPU. The repository has mainly been tested with an RTX 4090 on Ubuntu 22.04. At its default setting the text encoder uses about 14 GB of VRAM, and the CPU options need less.
How is it different from Kimodo?
NVIDIA describes Kimodo as a model specialised in controllable offline motion authoring. ARDY runs autoregressively for interactive, real-time generation. Both were evaluated on the same benchmark suite.
Can I use it in a commercial project?
The code is Apache-2.0. The models come under the NVIDIA Open Model Agreement, and the Llama model and Bones SEED data follow the terms on their own pages. Read these three documents before you start.
Can I start without a robot?
Yes. The demo and the command line generate G1 motion on a workstation and show it in the browser. The generated .csv file is in MuJoCo-qpos format.
Is there a Turkish resource?
Yes. The nvidia-ardy-turkce repository holds a full Turkish translation of the ARDY README and the motion correction library notes.
Unitree G1 and ARDY in Turkey
As Unitree Robotics' official distributor in Turkey, Robotlar.org works with teams researching on the G1 family. We published a Turkish translation of the ARDY documentation in the nvidia-ardy-turkce repository. The translation is based on NVIDIA's Apache-2.0 documentation and shared with a notice of changes. For the other Turkish repositories of the same family, see nvidia-kimodo-turkce and unitree-g1-motionbricks-turkce.
In a discovery call we decide with you which layer your project starts on. Some teams begin with text-to-motion tests on a workstation, others go straight to a whole-body controller on the G1 EDU. For configuration and pricing, use the enterprise quote form or the G1 EDU quote page. Options for universities and research labs are on the Unitree education solutions page.
Sources
- nv-tlabs/ardy repository and README
- ARDY project page
- ACM TOG 45(4), article 86, DOI 10.1145/3811284
- nvidia/ARDY-G1-RP-25FPS-Horizon52 on Hugging Face
- nvidia/ARDY-SOMA-RP-30FPS-Horizon60 on Hugging Face
- nv-tlabs/kimodo and the Kimodo Motion Generation Benchmark
- Unitree-Turkiye/nvidia-ardy-turkce (Turkish translation)

