Skip to content
Robotlar
Industry Guide

Controllable text-to-motion generation for the Unitree G1 and human characters with NVIDIA Kimodo

Unitree Turkey Distributor

Kimodo is a kinematic motion diffusion model released by NVIDIA's research team, and its name is built from the syllables of kinematic motion diffusion. According to NVIDIA, it was trained on a 700-hour, commercially friendly optical motion capture dataset and generates 3D human and robot motion. You describe the motion with a text prompt and shape it with constraints such as keyframes, hand and foot targets or a path on the ground. Alongside the SOMA and SMPL-X human skeletons, the model family includes two models trained for the Unitree G1.

This guide covers how Kimodo works, the output format of the G1 models, setup and the licence split. We also explain where Kimodo sits among NVIDIA's humanoid motion projects in our hub guide.

Related models

Unitree G1 humanoid robot, motion generated from a text prompt with NVIDIA Kimodo

What is Kimodo?

Kimodo is a text-to-motion model controlled with kinematic constraints. The technical report and the arXiv 2603.15546 paper describe the method and the training. NVIDIA provides four parts in the nv-tlabs/kimodo repository:

  • Inference code and a command-line tool to generate motion on human and robot skeletons.
  • An interactive browser demo where you arrange text prompts and constraints on a timeline.
  • A benchmark suite and evaluation code built on the BONES-SEED dataset.
  • Fine-grained temporal text annotations added to the BONES-SEED clips.

The first open-source release came out on 16 March 2026 with five model variants. The SOMA-RP-v1.2 models released on 15 October 2026 were trained on corrected data splits for benchmark compatibility. The same team's ARDY project builds on Kimodo and brings the same control to real-time generation.

How does Kimodo work?

Kimodo is an explicit motion diffusion model. It generates motion by cleaning up a noisy sequence of skeleton poses step by step. At each step the model takes an embedding of the text prompt, the set of constraints and the current noisy motion. Constraints are written in the same representation as the motion and overwrite the matching values in the noisy motion, and a mask marks which elements are constrained.

The denoiser is a two-stage transformer. The root denoiser first predicts the global root motion, which is converted into a local representation and passed to the body denoiser, and the final output joins the two stages. According to the documentation, the smoothed root in the representation emulates paths drawn in animation tools, and the design also reduces artifacts such as floating and foot skating.

The constraint types are:

  • Sparse 2D root waypoints and dense 2D root paths.
  • Full-body keyframe poses at specific frames.
  • Hand and foot (end-effector) targets that leave the rest of the body free.
  • Toe and heel contact patterns. The model was trained for these too; the demo UI and Python API do not currently expose them.

Because it is hard for a neural network to follow constraints exactly, the demo and the command line include a lightweight post-processing step that settles the joints onto the constraints while minimising changes in acceleration and velocity.

Kimodo models and training data

A separate model was trained for each skeleton. Models download automatically on the first generation from the command line or the demo, so there is no manual download.

ModelSkeletonTraining dataRelease date
Kimodo-SOMA-RP-v1.2SOMABones Rigplay 115 October 2026
Kimodo-SOMA-RP-ArdyRep-v1.2SOMABones Rigplay 115 October 2026
Kimodo-SOMA-RP-v1.1SOMABones Rigplay 110 April 2026
Kimodo-SOMA-SEED-v1.1SOMABONES-SEED10 April 2026
Kimodo-SOMA-RP-v1SOMABones Rigplay 116 March 2026
Kimodo-G1-RP-v1Unitree G1Bones Rigplay 116 March 2026
Kimodo-SOMA-SEED-v1SOMABONES-SEED16 March 2026
Kimodo-G1-SEED-v1Unitree G1BONES-SEED16 March 2026
Kimodo-SMPLX-RP-v1SMPL-XBones Rigplay 116 March 2026

NVIDIA recommends the models trained on the full Bones Rigplay 1 dataset (700 hours) as the default. The BONES-SEED models use the public 288-hour data; they are less capable but useful for comparison with other models trained on the same data. The Rigplay data covers locomotion, gestures, everyday activities, object interactions, videogame combat and dancing, along with styles such as tired, angry, old or stealthy.

Kimodo with the Unitree G1

Kimodo's G1 models, Kimodo-G1-RP-v1 and Kimodo-G1-SEED-v1, generate motion directly on the G1 skeleton from text prompts and constraints. According to the documentation, the G1 skeleton Kimodo uses has 34 joints, with extra toe joints added to ease learning that are removed on export.

When you pass --output while generating with a G1 model, the tool writes MuJoCo qpos data to a CSV file. Each row is one pose with 36 values: the root x, y, z translation, a quaternion in w, x, y, z order and 29 joint values in G1 joint order. The CSV uses the MuJoCo coordinate convention, z up and +x forward. The python -m kimodo.scripts.mujoco_load script in the repository plays the file back in MuJoCo.

The README shows two routes on the robot side. Kimodo's NPZ and CSV outputs are compatible with ProtoMotions, so you can train physics-based policies on generated motion. NVIDIA also added Kimodo to the interactive GEAR-SONIC demo as a proof of concept: Kimodo generates kinematic motion on the G1 skeleton and GEAR-SONIC tracks it in simulation. Kimodo-SMPLX output is written as AMASS NPZ and can be retargeted to other robots with GMR.

Kimodo generates kinematic motion. When moving to a physical robot, the tracking controller, limit enforcement and safety validation are part of your workflow. The documentation notes that foot-skate and constraint post-processing currently gives limited results on the G1 skeleton.

Setup summary

Kimodo's text encoder uses the gated Meta-Llama-3-8B-Instruct model, so the first step is to request access to it on Hugging Face and log in with hf auth login. Then follow this order:

  1. Create a new Python environment (Python 3.10) and install a GPU-enabled PyTorch 2.0 or later build that matches your system.
  2. Install pip install git+https://github.com/nv-tlabs/kimodo.git for generation only, or the kimodo[all] package to include the demo. To work on the code, clone the repository and use pip install -e . or the Docker route.
  3. If you will run many generations in a row, start the text encoder service in the background with kimodo_textencoder.
  4. Generate from the command line with kimodo_gen, or open the demo with kimodo_demo and go to localhost:7860 in your browser.

Generating entirely on GPU needs about 17 GB of VRAM, most of it for the text encoder. On smaller cards, TEXT_ENCODER_DEVICE=cpu moves text encoding to the CPU and brings VRAM use below 3 GB. The model has been tested most on GeForce RTX 3090, GeForce RTX 4090 and NVIDIA A100 cards, and the repository was developed on Linux. You can find Turkish setup steps in our nvidia-kimodo-turkce repository.

Prompting and using constraints

NVIDIA's best practices page recommends starting prompts with "A person...", which matches the descriptions in the training data. Each prompt should focus on one or at most two behaviours; split a long sequence of actions into several prompts and generate them in order. In multi-prompt sequences each prompt should make sense on its own, because the second motion is conditioned on the last frames of the first and the transition happens at the start of the second motion.

The documentation gives the limits as numbers. A generated motion lasts at most 10 seconds per prompt, and each constraint type other than the root path should use fewer than 20 keyframes. When you need to balance prompt adherence against hitting constraints, adjust the classifier-free guidance weights; Kimodo offers a separated mode with independent text and constraint weights for this.

Licence split

In Kimodo, code and model weights come with different licences. If you plan a commercial project, review the table with your legal team first.

PartLicenceNote
Code and documentationApache-2.0nv-tlabs/kimodo repository
SOMA and G1 modelsNVIDIA Open Model LicenseShown on the Hugging Face download pages
Kimodo-SMPLX-RP-v1NVIDIA R&D Model LicenseGated model
Text encoder modelTerms on the Hugging Face model pageGated Meta-Llama-3-8B-Instruct

The project also downloads third-party open-source packages during setup, and each one's licence terms are in its own repository.

Where to start with the G1, G1 EDU and G1-D

Kimodo runs on a workstation with an NVIDIA GPU and generates kinematic reference motion for the G1. The layer your work runs on decides the product.

WorkStarting pointRelated page
Generating and previewing G1 motion from textKimodo-G1-RP-v1, MuJoCo, a workstation without a robotOpen-source projects
Interactive, real-time generationARDYARDY guide
Inbetweening between target posesMotionBricks G1 modelMotionBricks guide
Physics-based policy training on generated motionProtoMotions, G1 EDUProtoMotions guide, RL Gym
Tracking the motion on a real robotGEAR SONIC, Unitree G1 EDUGEAR SONIC guide, G1 EDU quote
Demonstration data and imitation learningUnitree G1-D, teleoperationG1-D, G1 teleoperation
Lab setupG1 research platformG1 research platform

To transfer human motion to the G1, see the SOMA Retargeter guide, and for the training data side the BONES-SEED guide. For the Isaac GR00T workflow see our Unitree G1 and Isaac GR00T guide.

Frequently asked questions

Does Kimodo move the G1 directly?

Kimodo generates kinematic motion on the G1 skeleton. A tracking controller such as GEAR SONIC, or a policy trained with ProtoMotions, makes the robot follow that motion.

What hardware do I need?

An NVIDIA card with about 17 GB of VRAM to generate entirely on GPU. With text encoding moved to the CPU via TEXT_ENCODER_DEVICE=cpu, less than 3 GB of VRAM is enough.

In what format do I get G1 output?

A MuJoCo qpos CSV file alongside the default Kimodo NPZ file. Each row holds 36 values: root translation, root quaternion and 29 joint values.

How long is one generation?

One prompt generates up to 10 seconds of motion. Longer sequences use several prompts generated in order, and --num_transition_frames sets the transition between them.

What is the difference between Kimodo and ARDY?

Kimodo focuses on controllable offline motion authoring. ARDY builds on Kimodo and offers the same control in real time for interactive applications.

Is there a Turkish resource?

Yes. The nvidia-kimodo-turkce repository holds a Turkish translation of the Kimodo README and of the setup, CLI, constraint, output format and skeleton documentation.

Unitree G1 and Kimodo 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 Kimodo documentation in the nvidia-kimodo-turkce repository, based on NVIDIA's Apache-2.0 documentation. The Turkish repositories of the sibling projects are nvidia-ardy-turkce and unitree-g1-motionbricks-turkce.

In a discovery call we decide with you which layer your project starts on. Some teams begin by generating G1 motion from text on a workstation, others move on to tracking controller development 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.