anymove

# anymove

Makes a 3D animation for a rigged creature from a single AI video, then exports it as a GLB file. For game developers and 3D artists who have an NVIDIA graphics card.

Made by patch-gg on GitHub. These notes are Mindket's, written from its README; the project's own files and license are in its repository.

## About

What it is: anymove builds an animation for a rigged 3D creature from one AI video. A video model films the creature from the front and the side in one frame, and a reader trained on that creature locates each joint in both views. The rig is then matched to those joints on every frame and exported as a GLB. It copes with wings, tails and eight legs.

Who it suits: Game developers and 3D artists who need moves for monsters and other non-human bodies, and who own a computer with an NVIDIA card.

```table
Industry | Who uses it | How they use it | Example
Game development | Indie developers and technical artists | Animate a creature without keyframing it by hand or renting a motion-capture rig | A developer makes a dragon rear up and roar, then plays the GLB in an engine
Film and animation | 3D artists | Get big single gestures for creatures such as an ape or an ogre | An artist makes an ape beat its chest from one AI video
Concept and prototyping | Solo creators | See how a new creature looks in motion before committing to hand animation | A creator tests a mech or a centaur with a few moves
```

Anyone without an NVIDIA card can skip it, since it does not run without one and there is no cloud version.

Where to use it:

- A computer with an NVIDIA graphics card
- Blender 5.x, where the skeleton is placed and skinned
- fal, which hosts the video model
- Any engine that plays GLB files
- The ready-made creatures in Patch's Assets

```table
Use case | Who | What they get back
Animate your own rigged creature | 3D artists | A GLB with a real animation on a real skeleton
Big single gestures | Game developers | Roars, slams and rearing up, plus chest beats and stomps
Walks and runs | Game developers | Walk and run cycles for creatures on two and four legs
Ready-made creatures | Anyone | Nine creatures, each with 4 to 7 moves, including a knight, a horse and a scorpion
```

How to set it up: The hardware is the main requirement, and costs add up for each creature.

- An NVIDIA card with 12 GB to train a reader, and 24 GB is safer
- Blender 5.x
- Python 3.11
- A fal key
- No cloud version exists, so the card has to be yours

The repository includes agent skills that run the pipeline.

How to use it: You pick a creature and a gesture, and the agent skills run the steps below. The video model is prompted to animate the front and side views at once. Most clips do not pass the checks, so expect to capture several for each move.

```table
Tool | What it does
Flux 3 and Tripo H3.1 | Turn one picture into a textured 3D mesh at real size, for about $0.40
Blender | Places bones on grid views and skins the mesh, with 42 bones for legs, wings and tail
Limb colours | Paint each of the 6 limbs a different colour, which stops the left and right sides from being confused
MiniMax H3 Max on fal | Animates the front and side views together, with a 5 s clip costing about $0.26
Joint reader | Learns one creature from 2,200 random poses in 20 minutes on one GPU, then finds 50 joints in about 10 s a clip
```

Example: You want a dragon to rear up and roar. The video model films it from the front and the side in one frame. The reader locates every joint in both views, and the two views together fix each joint in 3D. The rig is fitted to those points and exported as a GLB that any engine can play.

For newcomers and experts: It is a way to animate a 3D monster without hand keyframes or a motion-capture studio. An AI video of the creature acts as the performance, and the software turns that video into bone movement. A first small thing to try is looking at the nine ready-made creatures before running anything yourself.

Underneath, each joint sits at the same height in the front and side views, so the pair pins it in 3D. A reader is trained on one creature from random poses with known joints, and training cuts its average error from 40 pixels to 6. The trade-off is cost and fit. A new creature needs a new reader, which costs about $17 and a couple of hours, so each animation is tied to its own creature.

```flow
One picture becomes a textured 3D model
Bones are placed and skinned in Blender
A video model films front and side views
A trained reader finds every joint
The rig is fitted and exported as a GLB
```

Good to know:

- A usable move costs about $3 all in, and a new creature with about 5 moves costs about $17.
- Expect to capture about 7 clips for each move, because only 58% of captured clips pass the checks.
- Weak spots: eight-legged walking, lying down, bird wings, tail swipes, fast runs and fine foot contact.
- Feet drift by 1 to 2 cm with each step, and the drift shows up close.
- The files are large: each creature is about 55,000 to 60,000 triangles and has 4K textures. No lighter versions exist yet.

```chart
Title: Approximate cost in dollars
Textured 3D model: 0.4 dollars
One 5 s video clip: 0.26 dollars
One usable move: 3 dollars
New creature with 5 moves: 17 dollars
```

## On GitHub, 6 November 2026

- Stars: 543
- Forks: 61
- Watching: 6
- Open issues and pull requests: 1
- Language: Python
- License: Apache-2.0
- Topics: agent-skills, animation, blender, claude-code-plugin, dinov2, gamedev, generative-ai, motion-capture

## Links

- Code: https://github.com/patch-gg/anymove
- Website: https://patch.gg/
- Releases: https://github.com/patch-gg/anymove/releases
- Issues: https://github.com/patch-gg/anymove/issues
- Star history: https://www.star-history.com/#patch-gg/anymove&Date

## Intro videos

- AI Can Now Animate Any Monster. Opus 5.5 Built the Tool: https://www.youtube.com/watch?v=AS92HYsEBqo

## Get the code

```
git clone https://github.com/patch-gg/anymove.git
```

Then follow the setup in its README. Nothing in this kit runs by itself.

README.md  6 KB