NVIDIA Kimodo: text-to-motion for game characters

NVIDIA released Kimodo on March 16, 2026: a motion model you run on your own GPU that turns a sentence into 3D character animation (GitHub). It was trained on 700 hours of optical motion capture from the Bones Rigplay dataset, which NVIDIA describes as commercially friendly.

NVIDIA lists game animation among its uses, but its docs stop at NPZ, BVH and robot formats and never mention a game engine. This guide covers the game side: install, prompts, constraints, and the retarget that gets a clip onto your own character. Facts come from NVIDIA’s repository, docs and model cards as of October 1, 2026.

What Kimodo is

Kimodo is a motion diffusion model. It writes joint rotations and a root path, not video and not physics. You steer it with text plus optional constraints: full-body key poses, hand and foot targets, and 2D waypoints or paths on the ground (Kimodo).

Fact	Kimodo, as of October 2026
Newest models	Kimodo-SOMA-RP-v1.1 and Kimodo-SOMA-SEED-v1.1, April 10, 2026
Clip length	Up to 10 seconds per prompt, at 30 fps (model card)
Skeletons	SOMA (human), Unitree G1 (robot), SMPL-X (research only)
Export	NPZ for every model; BVH for SOMA; MuJoCo CSV for G1; AMASS NPZ for SMPL-X (output formats)
Training data	Bones Rigplay 1, 700 hours; or the public BONES-SEED subset, 288 hours
License	Code Apache-2.0; SOMA and G1 weights under the NVIDIA Open Model License
Cost	Free

For games, use the SOMA models trained on the full Rigplay data, which NVIDIA recommends by default (quick start). Kimodo generates while you build; your game ships the finished clips, so players need no GPU.

What you need

• An NVIDIA GPU. Running everything on the GPU takes about 17 GB of VRAM. Set TEXT_ENCODER_DEVICE=cpu and it drops under 3 GB, slightly slower (quick start). NVIDIA tested it most on the GeForce RTX 3090, RTX 4090 and A100, and the model card also lists the RTX 5090, L40S, L4, RTX 6000 Ada and RTX A6000 (model card).
• Linux, or Windows with Docker. The repository was developed on Linux, and NVIDIA says Windows “should work especially if using Docker” (GitHub).
• Python 3.10 or later and PyTorch 2.0 or later, with a CUDA build of PyTorch.
• A free Hugging Face account. The text encoder is built on Meta’s gated Llama 3 8B Instruct, so request access on its model page and create a read token.
• Disk space. The first run downloads the encoder and the model; the community animation-builder project measures that download at about 18 GB (animation-builder).

Install Kimodo

On Linux, in a fresh environment (installation):

conda create -n kimodo python=3.10
conda activate kimodo
# install a CUDA build of PyTorch first: https://pytorch.org/get-started/locally/
pip install "kimodo[all] @ git+https://github.com/nv-tlabs/kimodo.git"
hf auth login   # paste your Hugging Face read token

[all] adds the browser demo and the SOMA body model. On Windows, use Docker. Docker Desktop passes an NVIDIA GPU to Linux containers through its WSL 2 backend, with current NVIDIA drivers and wsl --update (Docker docs). Log in to Hugging Face on the host first, so the token sits in ~/.cache/huggingface/token, then (Docker install):

git clone https://github.com/nv-tlabs/kimodo.git
cd kimodo
git clone https://github.com/nv-tlabs/kimodo-viser.git
docker compose up -d --build

That builds and starts the text encoder and the demo. In Docker, run every command below through the demo container: docker compose exec demo kimodo_gen ….

Generate your first clips

Start the text encoder once and leave it running. Without it, every command loads the large encoder again (quick start):

kimodo_textencoder
# on a card with less than 16 GB: TEXT_ENCODER_DEVICE=cpu kimodo_textencoder

Then, in a second terminal:

kimodo_gen "A person sneaks forward in a crouch, looking left and right." \
  --model Kimodo-SOMA-RP-v1.1 --duration 6 --num_samples 4 --seed 7 \
  --output sneak --bvh --bvh_standard_tpose

What the flags do (CLI docs):

• --model picks the checkpoint. The default is the older Kimodo-SOMA-RP-v1, so name v1.1.
• --duration is in seconds, 10 at most per prompt.
• --num_samples 4 writes four takes into a folder, sneak/sneak_00 to sneak_03.
• --bvh adds a BVH next to each NPZ. --bvh_standard_tpose makes its rest pose a standard T-pose instead of the BONES-SEED rest pose, which makes retargeting onto a T-posed rig simpler.
• --seed makes a take repeatable. Post-processing, which cleans up foot skating and pulls the motion onto constraints, is on unless you pass --no-postprocess.

To look before you export, kimodo_demo opens a browser app at http://localhost:7860 with a timeline, constraint editing and NPZ or BVH export.

Prompts that work

NVIDIA’s best practices (Kimodo docs):

• Begin with “A person…”. Style words help: tired, angry, happy, sad, scared, drunk, injured, stealthy, old, childlike.
• Keep one or two behaviors per prompt, at medium detail.
• Stay near the training data: locomotion, gestures, everyday activities, common object interactions, videogame combat and dancing.
• For a sequence, separate prompts with periods and give each a duration. Each prompt must make sense alone, because Kimodo generates them one after another and blends the joins:

kimodo_gen "A person walks forward. A person stops and waves with the right hand." \
  --model Kimodo-SOMA-RP-v1.1 --duration "4.0 3.0" --output walk-wave --bvh --bvh_standard_tpose

Kimodo has no loop switch. For a walk or run cycle, generate six to eight seconds and cut one cycle between two frames where the same foot lands.

Steer a clip with constraints

Constraints pin the motion to where your level needs it. A root2d constraint sets ground positions at given frames (constraints). Y is up and units are meters. The root starts at (0, 0) on frame 0, facing +Z, and frames count at 30 per second. Keep each constraint type under 20 frames; dense root paths are the exception.

Save this as path.json. The walk covers 2.5 meters in three seconds, then bends 90 degrees for 2 more:

[
  {
    "type": "root2d",
    "frame_indices": [0, 90, 179],
    "smooth_root_2d": [[0.0, 0.0], [0.0, 2.5], [2.0, 2.5]]
  }
]

kimodo_gen "A person walks forward, then turns and keeps walking." \
  --model Kimodo-SOMA-RP-v1.1 --duration 6 --constraints path.json \
  --output corner --bvh --bvh_standard_tpose

Full-body keyframes pin a whole pose at a frame, which is how you end an attack in your idle stance so it blends back cleanly. Those are easiest to pose in the demo and save with its constraints export.

Map the SOMA skeleton to your rig

Kimodo’s BVH uses NVIDIA’s SOMA skeleton: 77 joints, a Root joint on the floor and Hips 100 centimeters above it, stored in centimeters at 30 frames per second (SOMA T-pose BVH, output formats). These are the body joints to map; the right side mirrors the left.

Body part	SOMA (Kimodo)	Mixamo	Godot
Pelvis	Hips	Hips	Hips
Lower spine	Spine1	Spine	Spine
Middle spine	Spine2	Spine1	Chest
Upper chest	Chest	Spine2	UpperChest
Neck	Neck1	Neck	Neck
Head	Head	Head	Head
Collarbone	LeftShoulder	LeftShoulder	LeftShoulder
Upper arm	LeftArm	LeftArm	LeftUpperArm
Forearm	LeftForeArm	LeftForeArm	LeftLowerArm
Hand	LeftHand	LeftHand	LeftHand
Thigh	LeftLeg	LeftUpLeg	LeftUpperLeg
Shin	LeftShin	LeftLeg	LeftLowerLeg
Foot	LeftFoot	LeftFoot	LeftFoot
Toes	LeftToeBase	LeftToeBase	LeftToes

Mixamo’s bones carry a mixamorig: prefix, which Three.js turns into mixamorigHips and so on; the Godot column is its SkeletonProfileHumanoid. Sources: Kimodo’s T-pose BVH, Godot’s SkeletonProfileHumanoid and the Mixamo names in three.js’s retargeting example.

Watch the legs. SOMA’s LeftLeg is the thigh, while Mixamo’s LeftLeg is the shin. A tool that matches bones by name puts the thigh’s rotation on the shin, and the legs swing from the knees. Leave Neck2, Root and the fingers unmapped at first: Kimodo generates on a reduced 30-joint skeleton without most finger detail (skeleton docs).

Get the clip into your engine

Blender, then any engine or the web

1. Import the BVH. File › Import › Motion Capture (.bvh), with Scale 0.01 to turn centimeters into meters and Update Scene FPS on (Blender manual). Kimodo’s BVH is Y-up; if the skeleton lands on its back, set the importer’s Up axis to Y.
2. Import your character and check both face the same way. Rotate the imported armature object if not.
3. Retarget. Install the free Retarget extension (Blender 5.0+, GPL-3.0) from Edit › Preferences › Get Extensions (Retarget). Bind your character to the SOMA armature with Bind to Active Armature in the right-click menu, map the bones with the table above, save the mapping as a preset, then Bake Constrained Actions.
4. Trim loops to one cycle in the action’s frame range.
5. Export File › Export › glTF 2.0 (.glb) with animation, then drop redundant keys with gltf-transform resample hero.glb hero-lean.glb (glTF Transform).

The GLB plays in Three.js with an AnimationMixer; the AI 3D animation guide has the playback code, crossfades and an in-place fix for walks.

Three.js can also retarget at load: BVHLoader returns a skeleton and a clip (BVHLoader), and SkeletonUtils.retargetClip maps it with names, hip: 'Hips' and scale: 0.01. It copies world rotations, though, so bones whose local axes differ from SOMA’s need hand-tuned localOffsets, as three.js’s own example shows. For a shipped game, baking in Blender is less work.

Godot 4

Export the SOMA clip from Blender as a GLB. In the Advanced Import Settings for both that file and your character, select Skeleton3D and add a BoneMap with SkeletonProfileHumanoid under Retarget (Godot docs). Check the legs by hand (LeftLeg goes to LeftUpperLeg, LeftShin to LeftLowerLeg), turn on Rest Fixer’s Overwrite Axis, and save the clip file’s animations as an AnimationLibrary your character’s AnimationPlayer can load.

Unity

Export FBX from Blender. On the character and on the clip, open the Rig tab and set Animation Type to Humanoid (Unity manual). Open Configure and check that the thigh and shin landed on Upper Leg and Lower Leg; after that, the clip plays on any Humanoid in the project.

Unreal Engine

Two routes. Animotive’s Kimodo plugin is free on Fab, published June 12, 2026 and updated September 22, 2026. It generates from the Sequencer toolbar through Animotive’s cloud, which has a free tier, or through your own Kimodo in Docker, with no account needed (Fab listing).

By hand, import the FBX and right-click the animation › Retarget Animation Assets with Auto Generate Retargeter on (Unreal docs). Unreal’s auto retargeting names common biped skeletons such as the mannequins and MetaHumans, so check the chains it builds for SOMA.

Community tools that do the plumbing

Tool	What it does	Needs	License
animation-builder	A web app: upload a Mixamo-rigged FBX, prompt, auto-trim a loop and blend the seam, download an FBX for Unity or Unreal	Docker, an NVIDIA GPU with about 17 GB, Linux or Windows	Apache-2.0
Blender Kimodo Motion	Generates inside Blender and retargets onto Mixamo, VRoid, MMD or custom humanoid armatures	Windows 10 or 11, Blender 5.0.1+, 16 GB of VRAM, about 50 GB of disk	MIT, per its README
Animatica	A Blender panel with prompt blocks on the timeline, key poses, loop and in-place options	Blender 5.0+ and a free Animatica account for its cloud, or your own server	GPL-3.0
Animotive Kimodo	The Unreal plugin above	Unreal Engine; cloud or Docker	Fab Standard License

These are small third-party projects, not NVIDIA’s. Each installer runs with your permissions, so read it before you run it.

Kimodo’s license, read for a game

• Code: Apache-2.0.
• SOMA and G1 weights: the NVIDIA Open Model License allows commercial use, and NVIDIA “claims no ownership rights in outputs” (license). Its notice requirement applies when you share the model itself; the clips you make are outputs.
• One trap: the license ends automatically if you bypass the model’s safety guardrails without an equivalent of your own.
• SMPL-X weights: a separate NVIDIA research license, so keep them out of a game.
• Text encoder: requesting access on Hugging Face means accepting Meta’s Llama 3 license.
• Stores: Steam asks you to disclose pre-generated AI content that ships with a game (Steam), and generated animation counts. The AI 3D animation guide lists what other tools require.

ARDY: the real-time sibling

NVIDIA released ARDY on July 10, 2026 (GitHub). It streams motion from text while you steer with the mouse and keyboard. Its SIGGRAPH 2026 paper reports an average generation latency of 33 ms for the 4-step model on an RTX 4090 (ARDY paper).

Its checkpoints use a “Core” skeleton at 20 fps and the Unitree G1 at 25 fps, and a SOMA version is listed as coming soon. The code is Apache-2.0, and the weights link to NVIDIA’s Open Model Agreement.

For now, ARDY is a way to try prompts interactively on a desktop GPU. A browser game still ships baked clips from Kimodo.

Next: build around the character

• AI 3D animation for games: libraries, video capture and physics next to text-to-motion.
• Image to 3D for games: make and rig the character first.
• How to make a 3D game with AI: the Three.js game around it.
• Pro Skater: The Warehouse shows the Blender-scripted route: its creator says every 3D asset was generated by Python scripts in Blender and exported as GLB, running in Godot.
• Browse the Three.js games and Godot games in the catalog.