Two Views in One Clip, a DINOv2 Reader, and a Rigged GLB for 26 Cents

Motion capture has a scaling problem that nobody talks about, and it isn't the cost of the suit. It's that mocap is built for humans — two legs, a known skeleton, a standard hip height — and the moment your character is a dragon, a giant spider, or a fire demon, the entire pipeline stops applying.
Games and films solve this with animators. An animator watches a reference, then keys a creature's limbs by hand, frame by frame, because the reference is a human walking and the target is something with six legs and a tail. That's the actual job. It's also why creature animation is one of the most expensive line items in a production that has many.
anymove, from Patch, is an attempt to automate that specific gap. It has 452 stars, it appeared on October 27, and it does one thing: turn a single AI-generated video of a creature into a rigged, animated GLB.
The interesting part is the trick it uses to get there, and the trick is about cameras.
Two views in one frame
Human mocap works because multiple cameras see the same body from different angles, and the intersection of those sightlines gives you a 3D position. One camera gives you a 2D position on a plane, and a plane is not a body.
You can't put two cameras around an AI-generated clip, because the clip doesn't exist in 3D. It's pixels.
So anymove asks the video model to do something a bit odd: shoot the same creature from the front and from the side, simultaneously, in the same frame. A diptych — two panels side by side, one creature, two viewpoints, moving in sync.
Now you have two sightlines again. Front view gives you X and Y. Side view gives you Z and Y. Intersect them and a joint has a 3D position, recovered from a flat video, without a depth model and without a multi-view rig.
The repo was originally called diptych, and the rename to anymove makes sense as a product decision, but the old name described the mechanism more honestly. The two-panel frame is the invention. Everything else is plumbing.

The pipeline, stage by stage
Generate the clip. One AI video per move. The README puts it at $0.26 per clip — the dragon, giant spider, fire demon and wolf demos were each made this way. The prompt has to hold the diptych composition steady, which is the one place the whole approach can fail: if the model drifts the framing between panels, the two views stop corresponding and the triangulation is garbage.
Read the joints. A DINOv2-based reader finds every joint in both views. That's the model you train, and it's the expensive part — 24GB of VRAM for training. Reading, afterwards, needs much less.
Fit the rig. The two views "stand up as walls and pin each joint in 3D," to borrow the README's image. The rig is then fitted to the recovered points. The output is a bone animation, not a point cloud, which is what makes it usable downstream.
Export. A GLB, plus a showcase.mp4 that puts the animation next to the source clip so you can compare them without lying to yourself.
That last artefact is the same instinct you see in the better agent tools this year: always produce the side-by-side, because the model will happily tell you it succeeded and the only defence is looking.
The install, which is where most people will stop
Requirements are specific: an NVIDIA GPU with CUDA, Python 3.11, Blender 5.x on your PATH (or a BLENDER environment variable), and a fal key if you want 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 # add your FAL_KEY
Note the pinned torch build and the explicit CUDA 12.8 index. This is not a project that will work on whatever Python you happen to have.
The nicest bit of onboarding is the CPU-only smoke test. The repo ships the joint detections its reader already found for the dragon's roar, so you can fit the rig without downloading 355MB of weights or installing Blender:
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
About twenty seconds, and it prints how well the two views agree — which is the diagnostic you actually want, because disagreement between views is the failure mode the whole architecture is exposed to.
The full path, with the example creature's mesh, trained reader and clip from the release (13MB mesh, 355MB reader, 4MB clip):
tools/fetch_examples.sh dragon --readers --clips
tools/prep.sh dragon && tools/rig.sh dragon
tools/capture.sh dragon runs/dragon/videos/roar/s1/h3max.mp4 roar
And a new move for the same creature, which costs about $0.52 because it films two clips:
.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
What's genuinely hard here
Retargeting. Recovering joint positions is one problem; mapping them onto a specific rig with a specific bone length and a specific rest pose is another. If the dragon's rig has a longer neck than the recovered points suggest, either the neck bends weirdly or the head floats. The README's framing — "the rig lands on the points" — suggests fitting rather than retargeting, which is the easier and more honest choice: the animation is only as good as the rig's proportions matching the clip's.
Foot contact. Every mocap pipeline struggles with feet sliding, and a two-view solve from a generated video has no ground plane, no force data, and no physical constraints. A dragon that skates is a dragon that looks fake, no matter how good the joints are.
Occlusion. Two views help, but only two. A limb hidden behind the body in both panels has to be inferred, and the model will invent something plausible.
The economics, which is the real story
Twenty-six cents per clip. Under a minute to read and fit. Four example creatures in the repo, each with its own rig, prompts and reader.
Compare that with the alternative: an animator, a day, and a revision cycle. The comparison isn't fair — the output isn't the same quality, and nobody is going to ship a hero character's signature move from this. But for background creatures, enemy variants, crowd filler, or the forty seconds of a trailer where the monster is only on screen for two, twenty-six cents removes an entire argument about whether the shot is worth doing.
That's the pattern of this year, again. Not "AI replaces the craft." AI collapses the cost of the version you were going to throw away, and the craft moves up to the decisions that survive.
Should you try it
If you have an NVIDIA card, a Blender install, and a creature rig you care about, yes — and start with the CPU smoke test, not the full pipeline. It takes twenty seconds and tells you whether the two views agree on your data, which is the only question that matters before you spend anything.
If you're on a Mac, the reader training is out and the fitting is theoretical. The repo is Apache-2.0, so you can port it. I wouldn't, this month.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.