Skip to content
Robotlar
Industry Guide

NVIDIA ARDY: a guide to real-time motion generation for the Unitree G1 and humanoid characters

Unitree Turkey Distributor

ARDY is an autoregressive diffusion model that NVIDIA researchers built for interactive human motion generation. You steer the character at runtime with changing text prompts and kinematic constraints. The pretrained models include two checkpoints trained for the Unitree G1 skeleton. Within NVIDIA's family of humanoid motion projects, ARDY sits next to Kimodo and MotionBricks.

This guide explains how ARDY works, its G1 models, setup, the demo and the licence split. The last sections show where to start and how we can set this work up together in Turkey.

Related models

Unitree G1 humanoid robot, real-time motion generation from text prompts and kinematic constraints with NVIDIA ARDY

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:

ModelSkeletonFPSHorizonRelease
ARDY-Core-RP-20FPS-Horizon40Core2040July 10, 2026
ARDY-Core-RP-20FPS-Horizon8Core208July 10, 2026
ARDY-G1-RP-25FPS-Horizon52Unitree G12552July 10, 2026
ARDY-G1-RP-25FPS-Horizon8Unitree G1258July 10, 2026
ARDY-SOMA-RP-30FPS-Horizon60SOMA3060October 15, 2026
ARDY-SOMA-RP-30FPS-KimodoRep-Horizon60SOMA3060October 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:

  1. Create a fresh Python environment with conda or venv.
  2. Install the PyTorch build that matches your CUDA version yourself first.
  3. 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.
  4. 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:

MetricARDY-SOMA-RP-30FPS-Horizon60Kimodo-SOMA-RP-ArdyRep-v1.2
Overview R@3 (higher is better)77.8682.12
Overview Skate, cm/s (lower is better)2.7603.625
With-text FB Pos, cm (lower is better)2.773.08
With-text 2D Root, cm (lower is better)1.472.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.

PartLicence
CodeApache-2.0
Model checkpointsNVIDIA Open Model Agreement (on the Hugging Face page)
Llama model behind the text encoderAccess terms on the Meta-Llama-3-8B-Instruct page
Bones SEED dataTerms 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.

WorkStarting pointRelated page
Text-to-motion and interactive character testsThe ARDY demo on a workstation, without a robotTurkish ARDY repository
Offline motion authoringKimodoKimodo guide
Real-time inbetweening between posesMotionBricksMotionBricks guide
Tracking generated motion on the real robotUnitree G1 EDU and GEAR SONICG1 EDU quote, GEAR SONIC guide
Tracking reference motion with reinforcement learningG1 EDU and simulationRL Gym
Lab setupG1 research platformG1 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

Let's Find Your Solution

The investment depends on the selected robot platform, additional sensor and payload equipment, and the integration scope of your site. Share your requirements and our engineering team will prepare a feasibility report and a pro forma quotation for your organisation.