Four auto-riggers, twelve animals, one shared flaw: straight legs
By Oleg Sidorkin, CTO and Co-Founder of Cinevva
Take an artist-made walk cycle from a deer, retarget it onto the same deer after an auto-rigger has rigged it, and the result looks wrong in a way that's hard to name. The feet land in roughly the right places. The timing is right. It still reads like a table walking.
We spent a while assuming this was our retargeting code. It isn't. The rig is wrong before any animation touches it, and there's a single number that shows it.
The number
Take one leg. Add up the lengths of its bone segments, hip to foot. Call that the reach. Now measure the straight-line distance from the hip joint to the foot joint in the bind pose. Call that the span. Divide reach by span.
A real animal standing still has a folded leg, so the chain is meaningfully longer than the line it spans. Across the twelve artist-rigged animals in the Quaternius Ultimate Animated Animals pack, that ratio runs from 1.15 to 1.50, averaging 1.30. A deer's hind leg is 1.40. A fox's front leg is 1.29.
Now the important part. A leg with no fold can't bend without shortening its span. If the joints sit in a straight line, the only way to flex the knee is to pull the foot toward the hip. So either the foot leaves the ground or the body sinks. Ask that rig for the artist's knee angle and you get a crouch. No amount of retargeting fixes it, because the information the pose needs was never in the skeleton.
So the question is narrow, and it is measurable. Does the rigger put the intermediate leg joints where the leg can fold?
The test setup
Twelve animals, all CC0 from the Quaternius pack, each shipping an artist rig of 38 to 51 joints.
One detail in the mesh prep turned out to matter more than it looks. Those glTF files split the mesh into five primitives by material, and because the models are hard-edged low-poly, almost every vertex is duplicated per adjacent face. The fox stores 3,752 vertices and has 926 distinct ones. Riggers that build a graph over mesh topology read those coincident-but-unshared seams as cracks, so the head becomes a separate object from the body, the geodesic distance between them goes to infinity, and a joint that should sit in the neck has no reason to go there. Welding by position isn't an optimisation there. It's the difference between one animal and six islands. Nine of the twelve came out as a single watertight shell. The bull and cow keep their horns as separate pieces and the stag its antlers, which we left in on purpose, because real uploads look like that.
For scoring we used two things. The first is our own runtime function that reduces an arbitrary quadruped skeleton to a canonical structure. It has to find four feet in four distinct quadrants, a spine, and a neck. If it can't, the rig can't be driven at runtime, whatever else is true about it.
That function reads no bone names at all, deliberately, and the reason is instructive. Tripo numbers its limb chains by index with no fixed meaning, so chain 0 is the hind pair on its deer and the front pair on its horse. Its left and right labels disagree between rigs: Left sits at x=-0.072 on the deer and x=+0.076 on the horse, both facing the same way. On its fox it labels the spine as a limb chain. Every naming assumption we tried failed on measurement, so we read bind geometry instead, which says all of it unambiguously.
The second thing is the fold ratio above. Both measures are scale invariant, which matters because these riggers work at wildly different scales. Tripo normalises to roughly a unit cube, so its fox spans 0.13 by 0.34 by 0.65 against the artist's 0.77 by 2.47 by 6.59.
What came back
| rigger | rigs | drivable | mean joints | mean fold |
|---|---|---|---|---|
| artist (reference) | 12 | 11 | 46.8 | 1.299 |
| Anything World | 6 | 6 | 37.8 | 1.363 (see below) |
| RigNet | 12 | 12 | 54.1 | 1.146 |
| SkinTokens | 12 | 11 | 32.0 | 1.078 |
| Tripo | 12 | 10 | 25.8 | 1.045 |
Read that Anything World row with care, because it is the one number here that looks like a win and isn't. Its 1.363 average is above the artist's, and it comes entirely from a bug described further down. Set the bug aside and its legs measure 1.02 to 1.18. Straight, like the rest.
So not one of the four reaches the artist's minimum fold of 1.15. Including Tripo, which is the rigger we ship as our own Pro tier. That's the finding, and it beats a league table. Four independently built systems converge on the same error. They all put a quadruped's leg joints nearly in a line.
It makes sense once you see it. They were trained on datasets dominated by bipeds and by models in a neutral rest pose. A straight limb is the safe average. A folded hock is a specifically quadruped thing that a mostly-humanoid prior has little reason to learn.
Worth noting the reference row isn't perfect either. One artist rig, the Shiba Inu, fails our own drivability test, and the reason is instructive. These rigs ship an IK control layer: four pole targets parented to the root and sitting half a body-length in front of the animal, plus four IK chains with no parent at all. Those satisfy a geometric definition of "foot" as well as the real feet do, and on the Shiba Inu they win, giving eight false candidates out of twelve.
That raises an obvious suspicion, and it is worth killing off, because a control layer confusing a geometric analyser sounds like it could explain a lot. It doesn't. Removing the control bones and re-running the analysis changes the result on exactly one of the twelve artist rigs. The Shiba Inu goes from a broken 2 limbs to a clean 4, with a fold of 1.28 to 1.43 that lands right beside the husky's. The other eleven come out identical, fold ratios included. So the IK layer is a real bug in our foot detection and a one-line fix, and it is not what makes auto-rigged legs straight. The artist band of 1.15 to 1.50 was never measured on control bones, and the predicted rigs carry no control layer at all: Tripo's skeletons have none, and Anything World's five non-deforming joints are just leaf tip markers.
Predicted rigs being pure FK also cuts the other way. In this one narrow sense an auto-rigged animal is easier for a name-blind runtime to read than the artist's.
The four riggers have quite different failure modes
Tripo is the straightest at 1.045, and it uses the fewest joints by a wide margin, 25.8 against the artist's 46.8. But it gets the chain shape right where the others don't. Four of its twelve rigs reproduce the artist's exact 3/3/4/4 split, three joints per front leg and four per hind, which no other rigger managed even once. So it isn't placing the wrong number of joints. It's placing the right number almost in a line. That's a narrower defect than it first appears, and it suggests repositioning existing joints is a smaller job than re-rigging. Two of its rigs fail drivability outright: the fox comes back with two limbs, and so does the stag.
RigNet (SIGGRAPH 2020) has the best honest fold at 1.146 and was the only one to produce a drivable rig for all twelve. Its chains are the problem. The artist uses 3/3/4/4 on all twelve animals, front and back consistent. RigNet reproduces that shape exactly once. Three of its rigs have a leg of two joints or fewer, which cannot articulate at all, and four have a leg of seven or more. Its horse is 2/2/8/8: two joints in the front legs, eight in the back. The published critique of RigNet is that it "outputs irregular skeletons", and that's what irregular looks like in practice. A bandwidth sweep won't fix it either, because that parameter controls how many joints there are, not how they're distributed between limbs.
Anything World is the one that fails loudly rather than quietly. Two of the eight animals we submitted did not rig at all: the husky came back with FinetuningError: Incorrect segmentation exception and the cow with a bare Unknown error. The six that did rig are all drivable. All six use an identical 5/5/5/5 chain, the most consistent structure any predicted rigger produced.
Its front legs are the problem, and it is worth being precise about the shape of it, because the raw average flatters the service. Hind legs are mirrored exactly on all six: 1.10 and 1.10, 1.11 and 1.11, 1.13 and 1.13, and so on to five decimal places. Front legs break on three of the six, with one leg folded far past anything anatomical while its twin stands nearly straight. The alpaca is 3.60 on the front left against 1.87 on the front right. The horse is 2.47 against 1.43. The deer is 1.43 against 2.13, and note that the extreme side is the right one there, so this is not a consistent left bias.
We re-ran the deer and the horse to rule out our own submission. symmetry is a required upload field, and the stored response never echoes back what was sent. Submitted explicitly symmetric, both reproduced the anomaly. So it survives the parameter that exists to prevent it, on a mesh whose own artist rig is symmetric to three decimals.
SkinTokens (2025, from the VAST-AI group behind Tripo) is the tidiest by a distance. Eleven of twelve have mirrored left and right chain lengths, and not one has a leg of two joints or fewer. It's a well-behaved skeleton that stands too straight, at 1.078, rather than an erratic one.
Two things about SkinTokens worth writing down
It crashes on low-poly input. Nothing documents this. Our 926-vertex fox kills its Blender-side server mid-request with no Python traceback. The same fox subdivided to 88,706 vertices rigs in 70 seconds. Their own example model works because it was already dense. Adding a subdivision step to roughly 40k vertices before the call turned a total failure into twelve rigs out of twelve. If you're feeding it game assets, which are low-poly by definition, that precondition is the whole difference between working and not.
The more useful discovery is that it has a mode we'd never run. Passing --use_skeleton conditions it on a skeleton you supply instead of inventing one. It then keeps what you gave it. Every output joint sits on an input joint, mean offset 0.31% of the bounding box diagonal, worst case 0.50%. It renames them all to bone_0 and up on export and culls the ones carrying no weight, which is why this mode looked useless from the outside.
That relabelling is recoverable. Match the output joints back to the skeleton you supplied by position and every name comes back. That worked on 100% of joints, on all four animals we tried. And because the skeleton is now yours, so is the stance. Our horse measures 1.01 to 1.02 when SkinTokens picks the skeleton, and 1.11 to 1.36 when it's handed the artist's. The artist's own is 1.18 to 1.37.
Two preconditions before that works. It rejects a multi-root skeleton outright, and these artist rigs have five roots, the body plus four IK chains. Our first fix was to delete the strays. That was wrong. Dropping those eight bones leaves 90 to 128 vertices with no influence at all, on every animal in the pack, because FF and FFB are what the artist skinned the feet to. They aren't inert helpers. Re-parenting each stray root to its nearest body joint keeps every weight and still gives one root.
Anonymous bone names are not the blocker they look like
A predicted skeleton comes back as joint_0 or bone_0, and the usual conclusion is that no stock clip can bind to it. For quadrupeds that's a solved problem from either end.
Names can be recovered, as above, when you supplied the skeleton. Or they can be derived. A geometric analysis already knows which four chains are legs, which quadrant each sits in, and which run is spine and which is neck. Relabelling from that is not an inference. We ran it on all twelve RigNet rigs, writing names into a convention our runtime already reads, then analysed them again. Twelve of twelve came back identical through the named path and the geometric one. Same limb count, same quadrants, same chain lengths, same spine, same neck, same fold ratios.
A second number: is the skeleton even symmetric?
The Anything World front legs prompted a measurement we should have taken from the start, and it turned out to separate the riggers more cleanly than the fold does.
It works without reading a single bone name, which matters when half the output is called bone_0. Reflect every joint across the model's symmetry plane, then measure how far each reflection lands from the nearest real joint, as a percentage of the bounding box diagonal. A perfectly mirrored skeleton scores zero. The plane comes from the mesh bounding box, not from the joints. Letting an asymmetric skeleton nominate its own plane would let it define away its own asymmetry.
| rigger | mean mirror error |
|---|---|
| artist | 0.01% |
| RigNet | 0.08% |
| SkinTokens | 0.37% |
| Anything World | 1.08% |
| Tripo | 1.13% |
The artist rigs are mirrored to within rounding, which is the expected result and a useful check that the measure works. RigNet is very nearly as good, and that is not luck: it symmetrises explicitly, reflecting its candidate joints across x=0 before clustering them. The design choice shows up in the number.
Tripo comes last, though only just, and its spread is what stands out rather than its average. Eight of its twelve rigs land under 0.8%, and then the fox is 15.02% and the stag 14.45%. Those two are also the two that fail drivability, which is not a coincidence: a rigger whose geometry is not mirrored has no stable way to tell one side from the other, and that is the same trouble behind the naming problems earlier, where its own left and right labels disagreed between rigs.
These are small percentages. A fraction of a percent is invisible standing still. It shows up the moment a walk cycle asks the left and right legs to do the same thing half a period apart.
What we're doing about it
The fix belongs in the rig, not the retarget. Two routes are open and both are cheaper than training anything.
Supply the skeleton and let the model skin it. SkinTokens already supports this and preserves what it's given, and for humanoids our production rigger already emits a properly named Mixamo skeleton that could feed straight into it. Or reposition the joints in the rig you already have, which for Tripo means moving intermediate leg joints on a chain whose joint count is already correct.
What we won't do is swap one straight-legged rigger for another. There is no gain in it. On the number that matters, the spread between them is 1.04 to 1.15 against an artist 1.30, and the gap to the reference is larger than the gap between any two of them.
Update: there turned out to be a third route, and it changes the picture enough to earn its own article. Instead of retargeting between skeletons, we now solve the animation into each rig's own space from the deformed surface, and the quality ranking this produces reverses the one above. That story is part 2: solve the surface, not the skeleton.
Caveats, because they matter here
Sample sizes are uneven and that limits what the averages mean. RigNet, SkinTokens and Tripo all ran on the full twelve. Anything World ran on eight, of which six produced a rig, and the two that failed did so with errors that name themselves rather than with a bad rig we could measure. Tripo's five original rigs were leftovers from earlier retargeting work, so the other seven were rigged for this benchmark through the same endpoint on the same inputs. Adding them moved its mean fold by 0.004 and its mean mirror error from 1.54% down to 1.13%, which is roughly how much a five-model sample was flattering it in one direction and punishing it in the other.
On Anything World specifically, we started with two rigs and nearly published a claim off them. Both showed the same front-leg anomaly, which looked damning. Then the first model of the wider run came back clean, and suddenly it looked like our own submission was at fault. Only at six models was the actual shape visible: half the sample is affected, the hind legs are always perfect, and the extreme side is not always the same one. Two models would have produced a confident, wrong article. In either direction.
RigNet's checkpoints came from a third-party mirror rather than the paper's own download, which needs interactive confirmation and rate-limits. So its numbers describe our pipeline, not the authors' certified results. Getting it running at all took seven separate undocumented fixes. One is an interactive timezone prompt that hangs the container build with no error at all. Another is a debug viewer that opens a window and then blocks forever. You can't avoid that one by going headless either, because its voxeliser rasterises through OpenGL, so the process needs a display.
Finally, the fold ratio assumes a neutral standing bind pose. It's the right measure for these twelve animals and it would be the wrong measure for a rig delivered mid-stride.
The animals are CC0 from Quaternius, so anyone can repeat this. If you rig quadrupeds and you've measured something different, we'd like to hear it in our Discord.