AI 3D animation for games, rigged and retargeted

By GamesByAI · Published · Updated · 32 sources

On this page

To animate a 3D character with clips, you need three things: a skeleton, the motion clips themselves and some code that plays them. AI can now help with the first two.

An auto-rigger builds the skeleton from your mesh, a text-to-motion model writes a clip from a sentence, and a phone video turns into motion capture. Below we go through each route, then how to get the clips onto your own rig and how to play them in a game.

Prices and licenses are as of October 1, 2026, and each one links to the page it comes from.

Pick the route by the move you need

If your character is 2D, you’ll want AI sprite animation for games instead, which goes through reference frames, pose plans, sprite sheets and playback in Phaser, PixiJS and Canvas.

For 3D, the move decides the route. A library gets you the basics in minutes, and text-to-motion makes the moves no library has. Video records your own timing, while physics skips clips entirely.

Route Best for Tools Cost to start Catch
Clip library Idle, walk, run, jump, stock attacks Mixamo, Meshy, Tripo Free (Mixamo) Stock moves that players may recognize
Text-to-motion A limp, a sneak, a victory dance Kimodo, HY-Motion 1.0, Meshy, Uthana Free on your own GPU (Kimodo) Humanoids only; Kimodo and Meshy cap a prompt at 10 seconds
Video capture Your own performance and timing Rokoko Vision, DeepMotion 30 or 60 free seconds a month Free tiers limit exports or commercial use
Physics Ragdolls, knockbacks, wobbly fighters Rapier or your engine’s physics Free You tune it in code, not on a timeline

You don’t have to pick just one, either. The routes mix pretty well, so you might take library clips for getting around, generate or capture a few moves for personality and leave the falls to physics.

1. Rig the character

A rig is the skeleton plus the weights that tie each vertex to its bones. Auto-riggers make both from your mesh, which leaves you fixing only what they get wrong.

Tool What it rigs Output Cost and license
Mixamo Bipedal humanoids only FBX Free with an Adobe ID; characters and animations royalty free, video games included (Adobe FAQ)
Meshy Textured humanoids up to 300,000 faces, facing +Z FBX and GLB, with walk and run clips (Meshy rigging) Credits; free-plan output is CC BY 4.0 with credit (Meshy license)
Tripo Biped, quadruped, hexapod, octopod, avian, serpentine, aquatic GLB or FBX, Mixamo bone names on request (Tripo rigging) Credits; read the plan terms
UniRig Humans, animals and objects FBX (UniRig) MIT code; runs locally on a CUDA GPU with at least 8 GB

Adobe’s checklist for Mixamo works as a fair test for any auto-rigger (Adobe FAQ).

  • A humanoid with a clear head, body, arms and legs, and no wings, tails or big hair.

  • A neutral pose, with nothing else in the file, so no cameras, props or helpers.

  • No gaps between parts, the character centered at the world origin, and a clean mesh.

It’s worth using one skeleton for your whole cast. Three.js finds a clip’s bones by name, so a clip made for one Mixamo-rigged character plays on the next one too. Tripo can output Mixamo bone names as well, which helps a lot when your clips come from different places.

If your model started as a picture, image to 3D for games covers the A-pose and polygon budget that make rigging work.

2. Write motion from text

What a text-to-motion model gives you back is skeleton motion (joint rotations plus a root path), not a video or a mesh. That’s exactly what a game needs, because the clip goes onto your rig like any other motion capture.

Model Where it runs What you need License and cost
Kimodo (NVIDIA) Your PC An NVIDIA GPU: about 17 GB of VRAM, or under 3 GB with the text encoder on the CPU Free; weights under the NVIDIA Open Model License, commercial use allowed (GitHub)
HY-Motion 1.0 (Tencent) Your PC At least 24 GB of VRAM for Lite, 26 GB for the full model (GitHub) Free, but the license excludes the EU, the UK and South Korea (license)
Meshy Text to Motion Meshy’s servers A Meshy account 3 credits for a fast BVH clip, 10 for a higher-quality FBX clip; 2 to 10 seconds (Meshy)
Uthana Uthana’s servers An account Pay per second, from $0.02; paid use includes commercial rights (Uthana pricing)

Those HY-Motion VRAM figures assume one seed, prompts under 30 words and clips under 5 seconds, and its prompt-engineering helper needs even more memory (HY-Motion).

Kimodo writes up to 10 seconds per prompt at 30 frames per second and exports BVH. It gets a whole NVIDIA Kimodo guide of its own, which walks through the install, prompts, constraints and getting clips into each engine.

Name one move per prompt

NVIDIA publishes best practices for Kimodo prompts (Kimodo docs), and HY-Motion’s example prompts follow them too.

  • Start with “A person…”, and add a style when it matters, like tired, angry, scared, drunk, injured, stealthy, old or childlike.

  • Ask for one or two behaviors per prompt, and split longer actions into several prompts.

  • Use medium detail. “A person walks.” is too vague, and a paragraph about every joint is too much.

  • Stay inside what the model was trained on, which is locomotion, gestures, everyday actions, object interactions, videogame combat and dancing. Kimodo wasn’t trained on baseball, and NVIDIA actually uses a batting prompt as its example of what fails.

HY-Motion’s README also lists what it can’t do. Animals, clothing or appearance, scenes and camera moves, two-person interactions, looping clips and in-place motion are all on that list (HY-Motion), so plan on trimming loops yourself.

A starter set for a third-person game could look like this.

A person stands idle, shifting weight from foot to foot and glancing around.
A person jogs forward at a steady pace.
A person sneaks forward in a crouch, looking left and right.
A person swings a sword overhead with both hands, then returns to a fighting stance.
A person is hit in the chest, staggers back two steps and recovers.
A person falls backwards to the ground and lies still.

Every seed gives you a different take, so generate several of each and keep the best one.

3. Capture motion from a phone video

Video capture turns a clip of you into skeleton motion. It’s the quickest way to get your own timing, a specific dance or a stunt you can actually pull off.

Service Free tier Paid Output
Rokoko Vision 30 seconds of processing a month, FBX only (Rokoko) Basic: $10 a month billed yearly, 600 seconds, custom character retargeting FBX, BVH
DeepMotion Animate 3D 60 seconds a month, personal non-commercial use (DeepMotion pricing) Paid plans for commercial use FBX, BVH, MP4; GLB for custom characters

Hands are where the two differ. Rokoko Vision doesn’t track fingers, while DeepMotion charges extra credits for hand and face tracking.

Open-source research code is tempting too, but read its license before you build on it. GVHMR’s only covers education, research and non-profit use, so it can’t go into a game you sell.

DeepMotion’s capture guidelines make a good baseline for any video service (DeepMotion).

  • Put the camera on a tripod 2 to 6 meters away, square to you, and don’t pan or zoom.

  • Keep your whole body in frame for the whole clip, with nothing in front of your limbs.

  • Wear fitted clothes with some pattern, not all black.

  • Film at 1080p and 30 fps or more, in even light, against a background that contrasts with you.

4. Let physics handle the fall

Some games get away with no authored motion at all. You can see it in Floppy Brawler, whose fighters are loose-limbed ragdolls, and collisions and momentum shape each match in Goal-Locked: The Crucible instead of fixed animations.

In Pro Skater: The Warehouse a bail turns the skater into a ragdoll, who then gets back up.

If you want that in your own game, Rapier is a physics engine with JavaScript bindings, and it has the joints a ragdoll needs (Rapier joints). You could hand your coding agent something like this.

Add a ragdoll to the player with @dimforge/rapier3d. Make one capsule rigid body per limb, spherical joints at the shoulders and hips, and revolute joints at the elbows and knees (RAPIER.JointData.spherical, RAPIER.JointData.revolute, world.createImpulseJoint). On a hard hit, copy the current bone transforms into the bodies and switch from the animation clip to physics. After two seconds, blend back into the get-up clip.

5. Retarget clips onto your rig

A clip made for someone else’s skeleton won’t play right on yours until you retarget it. Retargeting maps each bone of the clip’s skeleton onto yours and corrects for different names, rest poses and units. You do it once, while building, and ship the result.

Matching by name alone rarely works, and the reasons are a little sneaky. Kimodo’s skeleton calls the thigh LeftLeg, for instance, and Mixamo’s LeftLeg is the shin. Kimodo’s BVH is also in centimeters while glTF uses meters, and one rig rests in a T-pose while the next uses an A-pose.

Where you build When it happens How
Blender, for any engine Once, before export File › Import › Motion Capture (.bvh) or FBX (Blender manual), then the free Retarget extension for Blender 5.0+, with presets for Mixamo, Unreal and other rigs (Retarget). Export a GLB
Three.js At load SkeletonUtils.retargetClip(target, source, clip, { names, hip }) (docs). Bones whose local axes differ need localOffsets, as three.js’s own retargeting example shows
Babylon.js At load AnimatorAvatar and retargetAnimationGroup(), added in Babylon.js 9.0 (Babylon.js forum)
Godot 4 On import Advanced Import › Skeleton3D › Retarget: a BoneMap with SkeletonProfileHumanoid, Rest Fixer’s Overwrite Axis, then save the clips as an AnimationLibrary (Godot docs)
Unity On import Rig tab › Animation Type › Humanoid on the character and on each clip’s FBX (Unity manual)
Unreal Engine In the editor Right-click the animation › Retarget Animation Assets, with Auto Generate Retargeter on (Unreal docs)

Godot’s docs even call Overwrite Axis “the most important option for sharing animations in Godot 4”, so don’t skip that one. Unity wants at least 15 bones for a Humanoid.

Neither engine imports BVH, though. Godot takes glTF, .blend and FBX (Godot formats), and Unity’s Humanoid setup works on FBX files, so convert BVH in Blender first. For the web, retargeting in Blender and shipping a baked GLB is the least fragile route.

6. Play the clips in the browser

In Three.js, each character gets an AnimationMixer, and each clip becomes an action you can start, stop and crossfade (AnimationAction). The code below is the pattern from three.js’s blending example, trimmed down for a game.

import * as THREE from 'three';
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import * as SkeletonUtils from 'three/addons/utils/SkeletonUtils.js';

const gltf = await new GLTFLoader().loadAsync('/models/hero.glb');
const hero = SkeletonUtils.clone(gltf.scene); // one clone per character on screen
scene.add(hero);

const mixer = new THREE.AnimationMixer(hero);
const action = (name) => mixer.clipAction(THREE.AnimationClip.findByName(gltf.animations, name));
const idle = action('idle');
const run = action('run');
idle.play();

function startRunning() {
  run.reset().play();
  idle.crossFadeTo(run, 0.25, false);
}

const timer = new THREE.Timer();
timer.connect(document);
renderer.setAnimationLoop(() => {
  timer.update();
  mixer.update(timer.getDelta());
  renderer.render(scene, camera);
});

That SkeletonUtils.clone call really matters, because a plain clone() leaves the copy’s skinned mesh bound to the original’s bones. Two more things come up in every game.

  • In-place clips. Generated walks travel forward, but your game code usually moves the character, so the clip shouldn’t. Pin the hips’ X and Z to the first frame and keep the up-and-down bob.
function inPlace(clip, hips = 'mixamorigHips') {
  const track = clip.tracks.find((t) => t.name === `${hips}.position`);
  if (track === undefined) return clip;
  const v = track.values; // x, y, z per keyframe
  for (let i = 0; i < v.length; i += 3) { v[i] = v[0]; v[i + 2] = v[2]; }
  return clip;
}
  • File size. Generated and captured clips usually carry a key on every frame. glTF Transform’s resample removes the redundant ones without changing the motion (glTF Transform).
gltf-transform resample hero.glb hero-lean.glb
gltf-transform inspect hero-lean.glb

If you’re on Babylon.js, a GLB’s clips arrive as AnimationGroups, and group.start(true) loops one. For the scene, camera and physics around the character, see the 3D game guide.

Generate while building and ship finished clips

None of these generators run inside the browser. Kimodo and HY-Motion need a desktop GPU with plenty of memory, while Meshy, Uthana, Rokoko and DeepMotion run on their own servers. So the usual route is to generate clips while you build and ship the finished ones, which play in any browser that runs Three.js or Babylon.js.

A game can also ask a server for motion during play. Meshy exposes animation through an API (Meshy), and NVIDIA’s ARDY, a sibling of Kimodo, streams motion from text and keyboard input. According to its paper, each generation takes 33 ms on average on an RTX 4090 (ARDY).

Either way, the generation runs on a server you pay for or host yourself, so baked clips are still the practical choice for most web games.

Licenses to check before you ship

  • Kimodo’s license from NVIDIA allows commercial use and claims no ownership of the motion you generate.

  • HY-Motion 1.0 isn’t licensed in the EU, the UK or South Korea (license), and that covers the motion it generates too. Using or distributing those clips there is unlicensed, wherever you ran the model. A company whose products had more than 1 million monthly active users at its release also has to ask Tencent for a license.

  • The free tiers come with strings. DeepMotion’s free minutes are for personal, non-commercial use, and Cascadeur’s free plan is non-commercial and only exports its own .casc format (Cascadeur plans). Meshy’s free output needs a credit line.

  • Mixamo costs nothing and is royalty free, games included.

  • Steam asks you to disclose pre-generated AI content that ships with the game (Steam), so keep a note of which tool made which clip.

Build the rest of the pipeline

If text-to-motion is your route, the NVIDIA Kimodo guide has the full local pipeline. And if you still need the character itself, image to 3D for games starts from a picture and gets you a model you can rig.

Doing the retarget and export by hand gets old fast. MCP servers for game development shows how to let your coding agent drive Blender for it.

To see what other people made, browse the Three.js games, Babylon.js games and Godot games in the catalog.

Games to look at

Questions

What is the best AI tool for 3D game animation?

It depends on the move. A free library like Mixamo covers idles, walks and runs, and for moves no library has, NVIDIA's Kimodo writes clips from text on your own GPU at no cost. If you want your own timing, video capture services such as Rokoko Vision and DeepMotion turn a phone clip into motion.

Is Mixamo still free?

Yes. Adobe's FAQ says Mixamo is free with an Adobe ID and that its characters and animations are royalty free in commercial projects, video games included. Its auto-rigger only handles bipedal humanoids, though.

Can AI animate a four-legged character?

It can rig one. Tripo's rigging covers quadrupeds, birds, snakes and fish, and the open-source UniRig handles animals and objects. The text-to-motion and video capture tools on this page only output human motion, though, so animals still need a library, keyframes or procedural code.

Can a browser game generate animations while you play?

Not inside the browser, because these models run on a desktop GPU or a vendor's servers. A game could ask such a server for motion during play, and NVIDIA's real-time model, ARDY, averages 33 ms per generation on an RTX 4090, a desktop GPU. Most web games still generate clips while building and ship them in the GLB.