NVIDIA Kimodo text-to-motion for game characters

By GamesByAI · Published · Updated · 36 sources

On this page

Kimodo turns a sentence into character motion you can put on a game rig. NVIDIA’s model runs on your own GPU, and you export the finished clips (GitHub).

NVIDIA released it on March 16, 2026. It learned from 700 hours of optical motion capture in the Bones Rigplay dataset, which NVIDIA describes as commercially friendly, and that’s really a big part of why it’s interesting for games.

NVIDIA lists game animation among its uses, but oddly its docs stop at NPZ, BVH and robot formats and never mention a game engine. So this guide picks up the game side, from installing it and writing prompts to constraints and the retarget that gets a clip onto your own character. The facts come from NVIDIA’s repository, docs and model cards as of October 1, 2026.

Kimodo writes joint rotations and a root path

Under the hood, Kimodo is a motion diffusion model. What comes out is joint rotations and a root path, so it’s basically animation data, with no video and no physics involved.

You steer it with text, plus optional constraints such as 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 is also what NVIDIA recommends by default (quick start). And since Kimodo only runs while you build, your game ships the finished clips, so players don’t even need a GPU.

Check GPU memory and dependencies before installing

  • An NVIDIA GPU. If GPU memory is tight, you can move the text encoder to the CPU, and generation only gets a little slower (quick start).
Encoder location VRAM needed
GPU, with the rest of the model About 17 GB
CPU, using TEXT_ENCODER_DEVICE=cpu Under 3 GB

The model card lists the hardware NVIDIA tested it on.

Hardware notes GPUs
Most tested GeForce RTX 3090, RTX 4090, A100
Also listed RTX 5090, L40S, L4, RTX 6000 Ada, RTX A6000
  • Linux, or Windows with Docker. The repository was developed on Linux, and NVIDIA says Windows “should work especially if using Docker” (GitHub).

  • Compatible Python and PyTorch. Use a CUDA build of PyTorch, and leave the pinned Transformers dependency alone (dependencies).

Dependency Version
Python 3.10 or later
PyTorch with CUDA 2.4 or later
Transformers Pinned to 5.1.0; switches PyTorch off below 2.4
  • A free Hugging Face account. The text encoder is built on Meta’s gated Llama 3 8B Instruct, so you’ll need to request access on its model page and create a read token.

  • Disk space. The first run downloads the encoder and the model, about 18 GB according to the community animation-builder project (animation-builder).

Install Kimodo

On Linux, start 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

The [all] part adds the browser demo and the SOMA body model.

On Windows, Docker is the way to go. Docker Desktop passes an NVIDIA GPU to Linux containers through its WSL 2 backend, as long as you have current NVIDIA drivers and have run wsl --update (Docker docs). Log in to Hugging Face on the host first, so the token sits in ~/.cache/huggingface/token, and then build it (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 both services, the text encoder and the demo, and they come already connected to each other (compose file), so in Docker you can skip the two start commands below. Open the demo at http://localhost:7860, and run generation through the demo container with docker compose exec demo kimodo_gen ….

If you want the encoder on the CPU, add TEXT_ENCODER_DEVICE=cpu to the text-encoder service’s environment before docker compose up.

Generate your first clips

Outside Docker, start the text encoder once and leave it running, because otherwise every command loads the large encoder all over again (quick start).

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

Then open a second terminal and generate.

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

The flags are worth a quick look (CLI docs).

  • --model picks the checkpoint. The default, kimodo-soma-rp, points to whatever’s newest, which is v1.1 today (model registry), so naming Kimodo-SOMA-RP-v1.1 keeps a run reproducible.

  • --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 is on unless you pass --no-postprocess, and you’ll want to leave it on, since it cleans up foot skating and pulls the motion onto constraints.

If you’d like 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.

Ask for one or two moves near the training data

NVIDIA’s docs have a few best practices for prompts (Kimodo docs).

  • Begin with “A person…”. Style words help too, like tired, angry, happy, sad, scared, drunk, injured, stealthy, old or childlike.

  • Keep one or two behaviors per prompt, at medium detail.

  • Stay close to the training data, which means locomotion, gestures, everyday activities, common object interactions, videogame combat and dancing. It’s nice to see videogame combat on that list.

  • For a sequence, separate prompts with periods and give each one a duration. Each prompt has to make sense on its own, 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

There’s no loop switch, unfortunately. 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 are how you get the motion to go where your level needs it. A root2d constraint sets ground positions at given frames (constraints), and when you write one, you use the same coordinate and timing rules as the model.

Constraint setting Value
Up axis and units Y-up, meters
Root start (0, 0) on frame 0, facing +Z
Frame rate 30 per second
Frames per constraint type Under 20; dense root paths are the exception

Save this as path.json. It makes the walk cover 2.5 meters in the first three seconds, then turn 90 degrees and cover 2 more meters in the next three.

[
  {
    "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. That’s how you end an attack in your idle stance, so it blends back cleanly, and they’re easiest to pose in the demo and save with its constraints export.

Map the SOMA skeleton to your rig

Kimodo’s BVH puts the SOMA skeleton under an extra Root joint on the floor, and the units and the rest pose need a little attention before you retarget (SOMA T-pose BVH, BVH exporter, output formats).

BVH property Value
SOMA skeleton 77 joints
Including the floor Root 78 joints
Hips above Root 100 centimeters
Stored units Centimeters
Frame rate 30 frames per second

These are the body joints you’ll map, and 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, and the Godot column is Godot’s SkeletonProfileHumanoid. The names come from Kimodo’s T-pose BVH, Godot’s SkeletonProfileHumanoid and the Mixamo names in three.js’s retargeting example.

Watch the legs, because they’re kind of sneaky. SOMA’s LeftLeg is the thigh, while Mixamo’s LeftLeg is the shin, so 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, since Kimodo generates on a reduced 30-joint skeleton without most finger detail anyway (skeleton docs).

Get the clip into your engine

Retarget in Blender and export a baked clip

  1. Import the BVH. Use 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, so if the skeleton lands on its back, set the importer’s Up axis to Y.

  2. Import your character and check that both face the same way. If they don’t, rotate the imported armature object.

  3. Retarget. Install the free Retarget extension (Blender 5.0+, GPL-3.0) from Edit › Preferences › Get Extensions (Retarget). Then 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 and finish with Bake Constrained Actions.

  4. Trim loops to one cycle in the action’s frame range.

  5. Export with File › Export › glTF 2.0 (.glb), animation included, and then drop redundant keys with gltf-transform resample hero.glb hero-lean.glb (glTF Transform).

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

Three.js can also retarget at load time. 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 fiddly, hand-tuned localOffsets, as three.js’s own example shows. For a shipped game, baking in Blender ends up being less work.

Map the clip with Godot’s humanoid profile

Export the SOMA clip from Blender as a GLB. Then, in the Advanced Import Settings for both that file and your character, select Skeleton3D and add a BoneMap with SkeletonProfileHumanoid under Retarget (Godot docs).

The legs are the tricky part, so check them by hand, since that’s where the names disagree (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.

Configure both FBX rigs as Humanoid in Unity

Export FBX from Blender. On both the character and the clip, open the Rig tab and set Animation Type to Humanoid (Unity manual). Then open Configure and check that the thigh and shin landed on Upper Leg and Lower Leg.

Once they have, the clip plays on any Humanoid in the project.

Generate in Sequencer or import both skeletons

Luckily for Unreal users, there’s a free Kimodo plugin from Animotive. 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). The listing went up on June 12 and was updated on September 22, 2026.

Doing it by hand needs a second character, because Auto Retargeting needs two Skeletal Mesh assets with different Skeletons (Unreal docs). So first import a SOMA source character (the BVH skeleton with a simple skinned mesh made in Blender) and your target character. Then import the clip against the SOMA Skeleton (FBX animation import), right-click it and choose Retarget Animation Assets with Auto Generate Retargeter on.

Unreal’s auto retargeting names common biped skeletons such as the mannequins and MetaHumans, so check the chains it builds for SOMA. If that sounds like a lot, retarget onto your character in Blender first and import the finished FBX, which skips this setup.

Let a community tool handle generation and export

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

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

Read the model license separately from the code license

The code and the models are actually licensed separately. The code is Apache-2.0, while the SOMA and G1 weights are under the NVIDIA Open Model License, which allows commercial use, and NVIDIA “claims no ownership rights in outputs” (license). Its notice requirement applies when you share the model itself, and the clips you make are outputs.

The one trap is that the license ends automatically if you bypass the model’s safety guardrails without an equivalent of your own.

The SMPL-X weights fall under a separate NVIDIA research license, so keep them out of a game. And requesting access to the text encoder on Hugging Face means accepting Meta’s Llama 3 license.

Stores have their own rules too. Steam asks you to disclose pre-generated AI content that ships with a game (Steam), and of course generated animation counts. The AI 3D animation guide lists what other tools require.

ARDY streams motion while you steer

ARDY goes a step further and streams motion from text while you steer with the mouse and keyboard (GitHub). Its paper measures generation on a desktop GPU, not in a player’s browser (ARDY paper).

ARDY release and measurement Value
Release July 10, 2026
Paper SIGGRAPH 2026
Average generation latency 33 ms
Model and GPU 4-step model on an RTX 4090

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.

ARDY’s repository shows online generation in a web browser viewport, with the model running on the GPU machine (GitHub). So a browser game could, in theory, stream motion from a server like that during play, but you’d be running GPU servers for your players. For most web games, baked clips from Kimodo are still the practical route.

Build the rest around the character

AI 3D animation for games puts libraries, video capture and physics next to text-to-motion. If you don’t have a character yet, image to 3D for games shows how to make and rig one, and how to make a 3D game with AI builds 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.

You can also browse the Three.js games and Godot games in our catalog.

Games to look at

Questions

Is NVIDIA Kimodo free?

Yes. The code is Apache-2.0, and the SOMA and G1 model weights are under the NVIDIA Open Model License, which allows commercial use and claims no ownership of what you generate. The only things you pay for are the GPU and the electricity.

What GPU does Kimodo need?

About 17 GB of VRAM if everything runs on the GPU. With TEXT_ENCODER_DEVICE=cpu it needs under 3 GB and runs a little slower. NVIDIA tested it most on the GeForce RTX 3090, RTX 4090 and A100.

Does Kimodo run on Windows?

NVIDIA says it should, especially through Docker. Kimodo was developed on Linux, and the model card lists both Linux and Windows. On Windows, Docker Desktop's WSL 2 backend passes the NVIDIA GPU to the container.

Can I use Kimodo in Blender or Unreal Engine?

Yes. You can export BVH and retarget it yourself, or use a community tool like Animotive's free Kimodo plugin for Unreal on Fab, or Blender add-ons such as Blender Kimodo Motion and Animatica. Those are third-party projects, not NVIDIA's.

Can Kimodo animate animals or make looping walk cycles?

Not animals, since the SOMA models generate human motion and the G1 models a humanoid robot. There's no loop switch either, but you can generate a longer walk and cut one cycle between two frames where the same foot lands.

More sources

  1. research.nvidia.com/labs/sil/projects/kimodo/