anymove
anymove turns one AI video into a real animation on a creature's own skeleton, for any creature: wings, tails and eight legs included. You bring a 3D model and one sentence per move; you get a game file with the creature, its skeleton and the moves.
A video model films the creature from the front and the side in one frame, a small AI trained on that one creature finds every joint in both views, and the skeleton is fitted to those joints frame by frame. In the live demo, drag the slider to scrub a real capture: the AI video and the finished animation move together, and the animation is the real thing in 3D, so you can turn it and look at its feet.
Just want a creature? Nine made with anymove are ready in Assets, with 4 to 7 moves each: T-rex, knight, horse, centaur, woman, ogre, ape, mech and scorpion. That costs nothing and takes seconds. Everything below is for making your own.
before you start.
- You need: an NVIDIA card (12 GB to train a reader, 24 GB is safer), Blender 5.x, Python 3.11 and a fal key. Without the card it doesn't run, and there's no cloud version.
- It costs about $3 for a usable move, all in, and about $17 and a couple of hours for a new creature with about 5 moves. The numbers are below.
- Most clips don't make it. A move took about 7 clips on average, and 58% of captured clips passed the checks.
what it's good at, and what it isn't.
Good at: big single gestures on any body plan: roars, slams, rearing up, chest beats, stomps, taking off. Walks and runs work on two and four legs. You get a real animation on a real skeleton, in a file any engine plays.
Not good at:
- Eight-legged walking. The two views disagree about which legs are up (0.36-0.49). Scorpions and spiders can rear, bite and strike, but they don't walk.
- Lying down. The reader learns from random poses inside the joint limits, which don't include lying on a side.
- Bird wings. The eagle's wings don't fit (15-30 px off), and it was left out of the nine. Bat-like wings do fit, on the dragon and the demon.
- Tail swipes. The two views disagree about where the tail tip is. The T-rex's was dropped after six tries.
- Fine foot contact. Feet slide 1 to 2 cm a step and nothing pins them yet. That's fine for most uses, and visible up close.
- Fast runs. Runs look like fast walks in places: the video model doesn't lower the body on a run.
- Moving an animation to another creature. An animation only fits the creature it was made for, and a new model needs a new reader.
- Light files. Generated creatures are 55,000 to 60,000 triangles with 4K textures, which is heavy for a browser game, and there are no lighter versions yet.
run it end to end (for agents).
Follow these in order. The skills in skills/ hold the detail and the checks that tell a good capture from a bad one.
- Look in Assets first. Search with
assets_search. If something close enough is there, use it and stop. - Check the machine.
nvidia-smifor the NVIDIA card (12 GB to train, 24 GB is safer), then Blender 5 and Python 3.11. On Windows use Git Bash. Without the card, stop and say so: there's no cloud version. - Say the cost and get a yes. "About $17 and a couple of hours for a new creature with about 5 moves, and about $3 for each extra move." Never call fal before that yes.
- Set up as "quick start" below says, and put
FAL_KEYin.env. Never print it. - Make the creature (
skills/anymove-rig). A picture, then a 3D model, about $0.40 (tools/make_mesh.py). Look at it and count the legs on the model, not the picture. - Place the skeleton on grid pictures (
tools/rig.sh <name> preview), then build it, paint the limbs and test a bend (tools/rig.sh <name>). This is the step that takes judgment. - Teach the reader (
skills/anymove-reader).tools/dataset.sh <name>, thentools/train.sh <name>, about 45 minutes on one big card. - Film and capture each move (
skills/anymove-film,skills/anymove-capture). Write the prompt withtools/make_prompt.py, film two or more tries withtools/film.sh, runtools/capture.shon each, and keep the best by the numbers (tools/score_takes.py): do the two views agree, how far do the feet slide. - Build the pack (
skills/anymove-pack,tools/pack.sh): cut loops, make the moving versions, and write the final.glb. - Put the file in the game and play it. Each extra move only needs steps 8 and 9.
The live demo's source is in demo/. Its art is CC0 1.0, like the creatures in Assets, and its credits, which name the AI video service behind the clips, are in demo/CREDITS.txt. The code is also on GitHub.
how it works.
| 1 · a 3d model.One picture becomes a textured mesh at real size. flux 3 picture, tripo h3.1 mesh · $0.40 | |
| 2 · a skeleton.Bones placed on grid views, skinned in Blender.42 bones: legs, wings, tail | |
| 3 · limb colours.Every limb its own colour, so left and right never swap.6 limbs, 6 colours | |
| 4 · two cameras.One camera at the front, one at the side, both views in one frame; a video model animates both at once from a prompt. minimax h3 max on fal · 5 s, $0.26 | |
| 5 · teach a reader.A vision model learns this one dragon from random poses whose joints are known; its average miss falls from 40 px to 6 px. dinov2 · 2,200 poses · 20 min on one gpu | |
| 6 · read every joint.The reader finds every joint in both views, in every frame.50 joints · 10 s a clip | |
| 7 · two views, 3d.Stand the two views up as walls at a right angle: each joint is where its two lines meet. The front gives side to side, the side gives nose to tail.x from the front, y from the side, z from both | |
| 8 · the rig follows.The rig bends its bones onto the points, ignores the strays, and exports for any engine.glb, 24 fps, no hand edits · under a minute a clip |
Then the best takes become one file, with seamless loops and root motion (docs/PACKS.md). docs/PIPELINE.md has the file-by-file version.
quick start.
You need an NVIDIA GPU with CUDA (12 GB to train a reader, 24 GB is safer; reading and fitting need much less), Python
3.11, Blender 5.x on your PATH (or BLENDER=/path/to/blender), and a
fal key to make new clips.
git clone https://github.com/Patch-gg/anymove && cd anymove
python3.11 -m venv .venv
.venv/bin/pip install torch==2.11.0 --index-url https://download.pytorch.org/whl/cu128
.venv/bin/pip install -r requirements.txt
cp .env.example .env # then add your FAL_KEY; git ignores .env
On Windows, use Git Bash, and the same commands with the venv's other folder.
Every tools/*.sh finds the venv and handles Blender's paths and Python's line endings. Blender usually isn't on your
PATH, so point at it:
git clone https://github.com/Patch-gg/anymove && cd anymove
py -3.11 -m venv .venv
.venv/Scripts/pip install torch==2.11.0 --index-url https://download.pytorch.org/whl/cu128
.venv/Scripts/pip install -r requirements.txt
cp .env.example .env
export BLENDER="/c/Program Files/Blender Foundation/Blender 5.2/blender.exe"
Where a command below says .venv/bin/python, use .venv/Scripts/python.exe.
Fit the dragon's roar on the CPU, no Blender or downloads needed. The repo carries the joints its reader found in the clip; this fits the rig to them (about a minute and a half) and prints how well the two views agree:
mkdir -p runs/dragon/clips/roar
MOCAP_CREATURE=assets/dragon .venv/bin/python -m mocap.solve examples/dragon_roar/det.npz \
assets/dragon/rigged/rig_info.json runs/dragon/clips/roar/motion.json
The whole capture, from the AI clip to a GLB, with an example creature's mesh, trained reader and clip from the release (13 MB mesh, 355 MB reader, 4 MB clip):
tools/fetch_examples.sh dragon --readers --clips
tools/prep.sh dragon && tools/rig.sh dragon # real size, skeleton, skin, limb paint, reference frame
tools/capture.sh dragon runs/dragon/videos/roar/s1/h3max.mp4 roar
# runs/dragon/clips/roar/render/animation.glb, and showcase.mp4 to compare it with the clip
A new move for the same dragon (two clips, about $0.52 on fal; expect to need more, since a usable move took about 7 clips on average):
.venv/bin/python tools/make_prompt.py assets/dragon "the dragon whips its tail from side to side, then stands still." prompts/dragon/tailwhip.txt
tools/film.sh dragon tailwhip h3max 1,2
tools/capture.sh dragon runs/dragon/videos/tailwhip/s1/h3max.mp4 tailwhip
your own creature.
Copy the closest example in assets/ (wolf: four legs; dragon: four legs and wings; spider: eight legs; demon: two
legs, two arms, wings and a tail), put your mesh at assets/<name>/model.glb, and work through:
tools/prep.sh <name> # set "prep" in creature.json first: real size, facing -Y
# place joints in assets/<name>/rig.json on the grid views; check with: tools/rig.sh <name> preview
tools/rig.sh <name> # build, skin, paint, reference frame
tools/dataset.sh <name> # 2,200 random poses, about 25 min
tools/train.sh <name> # the joint reader, about 20 min
tools/film.sh <name> <move> # after tools/make_prompt.py writes prompts/<name>/<move>.txt
tools/capture.sh <name> runs/<name>/videos/<move>/s1/h3max.mp4 <move>_s1
.venv/bin/python tools/score_takes.py <name> # which takes pass the checks
tools/pack.sh <name> # after listing the keepers in picks/<name>.json: one GLB with every move
tools/make_mesh.py makes the picture and the mesh on fal, if you don't have a model. The skills below walk an agent (or
you) through each step, with the checks that tell a good capture from a bad one.
agent skills.
anymove is a Claude Code plugin and its own marketplace:
/plugin marketplace add Patch-gg/anymove
/plugin install anymove@anymove
| skill | for |
|---|---|
anymove | the method, setup, which step comes next, costs |
anymove-rig | mesh, facing and scale, placing joints in rig.json, building and painting the rig, framing |
anymove-film | writing the prompt, generating clips on fal, checking them before capture |
anymove-reader | rendering the dataset, training the reader, the exam in centimetres |
anymove-capture | reading, fitting, the quality gates, fixing bad fits, showcase renders |
anymove-pack | choosing takes, seamless loops, root motion, foot slide, the final GLB |
anymove-lora | training and testing the MiniMax H3 LoRA on fal |
They're plain Agent Skills (skills/<name>/SKILL.md), so other agents can load them from that
folder too.
results.
| creature | skeleton | reader error, front / side (px) | how well the views agree (1 = same footfalls) |
|---|---|---|---|
| wolf, 1.6 m | 30 bones, 36 joints | 6.9 / 3.8 | trot 0.94 · exam: 0.94 cm mean 3D joint error |
| dragon, 3 m | 42 bones, 50 joints, wings | 6.2 / 5.5 | take off 1.00, roar 0.93, swipe 0.85, walk 0.81 |
| giant spider, 2.4 m span | 28 bones, 40 joints, 8 legs | 2.9 / 3.6 | rear up 0.99, bite 0.96, pounce 0.89 |
| fire demon, 3.6 m | 38 bones, 46 joints, wings, tail | 8.4 / 9.4 | wing beat 0.99, slam 0.84, roar 0.73 (feet planted) |
Reader error is the held-out mean on the 720-row frame; the demon stands 412 px tall, so its 8.4 px is about 2% of its height. Every clip in the table is MiniMax H3 Max. The exam renders a made-up motion with known joints in the same studio and reads it back.
Then one run made ten more creatures. What's in each pack, with the worst foot slide across its walk and run:
| creature | moves | worst slide | creature | moves | worst slide | |
|---|---|---|---|---|---|---|
| T-rex | 7 | 2.26 cm | ogre | 6 | 1.15 cm | |
| knight | 7 | 1.88 cm | ape | 5 | 1.40 cm | |
| centaur | 7 | 1.62 cm | horse | 5 | 1.64 cm | |
| mech | 7 | 2.12 cm | woman | 4 | 1.36 cm | |
| scorpion | 4 | no walk | eagle | 1 (left out) |
Their choices, and each clip's seed and prompt, are in picks/.
what it costs.
A clip's price isn't a move's price, because most moves take several tries. These are the real numbers from the run that made ten creatures, on fal and rented GPUs:
| a usable move, all in | about $3 |
| its clips alone | about $1.80, about 7 clips |
| a new creature with about 5 moves, all in | about $17 ($110 of AI services and about $55-65 of cloud GPU, across 10 creatures) |
| the same on your own card | about $11 of AI services |
| captured clips that pass the checks | 58% (193 of 335) |
What goes into that:
| a concept picture and a mesh, Tripo H3.1 with HD texture | about $0.50, more if the first mesh comes back wrong |
| a 5 s two-camera clip, MiniMax H3 Max | about $0.26 (H3: $0.30) |
| placing the skeleton | your or your agent's time; nobody has timed it |
| training renders and the joint reader | about 75 min on one RTX 4090, 10 min of training on a cloud H100 |
| reading a clip / fitting it | about 12 s / about 45 s (about 90 s for the dragon's roar on a CPU) |
| exporting the GLB and renders | about 3 min a clip |
| the optional H3 LoRA, 1,200 steps on fal | about $12, about 2 h |
Prices on fal as of October 2026. After a creature's first move, each new one only needs clips and capture.
limits.
What it isn't good at comes first. And:
- Skeletons are placed by hand on grid views (
tools/prep.sh,tools/rig.sh preview). UniRig could do it; its install pulls prebuilt flash-attn wheels. - Video models drift. Plain MiniMax H3 swapped the limb colours on 2 of 5 wolf clips; with the LoRA, 0 of 5 (one seed per move: a first read, not a benchmark). Seedance 2.5 played the views out of step on a trot.
- The LoRA's data is AI-derived. Its training clips re-render motions solved from AI clips, so the halves are in sync by construction but the motion itself is AI-made. Real dog mocap exists (AI4Animation) under a non-commercial licence.
- Mirrored arms need their own limits.
_Land_Rbones share a local Z axis, so one sideways limit is wrong for one side. Giveupperarm_Landupperarm_Rmirrored Z ranges inrig.json(anymove-rig). - Overhead moves can leave the frame. The layout's height needs room for the biggest move, or the prompt has to keep limbs low.
- Fur and cloth need extra bones: springs (
apply_motion.py --springs) or tracked tips (the wolf's tracked fur read 7-28° swings from the video).
licence.
Apache-2.0, see LICENSE. The Patch name, mark, wordmark and Patch Pixel belong to Patch and aren't covered
by it. Other companies' marks in this README belong to their owners and are shown only to credit their tools (icons
from lobe-icons, MIT, and Simple Icons, CC0).
MiniMax H3's open weights carry a community licence and hosted use on fal goes through fal's terms: check both before
shipping what you make with them. What you make doesn't automatically get the licence of anything here, including the
CC0 on Patch's nine creatures: its terms depend on the models you use and the keys you use them with. The wolf LoRA in the release (lora-wolf-twocam-h3.safetensors) is a LoRA on
MiniMax H3, so MiniMax H3's community licence applies to it, not Apache-2.0.
credits.
- The two-camera method is @CanItCode's, and the H3 LoRA step is @Graalitoo's.
- DINOv2 by Meta (with registers, Apache-2.0) is the reader's backbone.
- Tripo H3.1 made the meshes, from concept pictures by Black Forest Labs' FLUX 3.
- MiniMax H3 and H3 Max made the clips, all run on fal.
- Blender rigs, renders and exports everything.
- Made by Patch (@patch_gg).