NVIDIA Kimodo text-to-motion for game characters
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).
-
--modelpicks the checkpoint. The default,kimodo-soma-rp, points to whatever’s newest, which is v1.1 today (model registry), so namingKimodo-SOMA-RP-v1.1keeps a run reproducible. -
--durationis in seconds, 10 at most per prompt. -
--num_samples 4writes four takes into a folder,sneak/sneak_00tosneak_03. -
--bvhadds a BVH next to each NPZ.--bvh_standard_tposemakes its rest pose a standard T-pose instead of the BONES-SEED rest pose, which makes retargeting onto a T-posed rig simpler. -
--seedmakes 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
-
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.
-
Import your character and check that both face the same way. If they don’t, rotate the imported armature object.
-
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.
-
Trim loops to one cycle in the action’s frame range.
-
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
, Online multiplayerWaifu Mercs
Shoot waves of zombies from behind the shoulder in split-screen co-op.
MANA FIGHT
Pick a spellcasting class and fight through fast third-person arena battles.
Pro Skater: The Warehouse
Skate a two-minute run through a warehouse park, chaining tricks and hitting goals.
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.