Skeletal Morphemes: Tokenizing Character Rigs Into Reusable Sub-Tree Units

Turning a static 3D character into something an animator can pose needs two things: an internal skeleton (joints and their parent-child links) and skinning weights that say how each surface point follows each bone. The newest automatic riggers write the skeleton out one joint at a time, the way a language model writes text one token at a time. Every finger, vertebra and tail segment is spelled out from scratch as absolute coordinates. This is the geometric version of a known NLP failure. When a tokenizer cuts words by substring frequency instead of meaning, rare words turn into long runs of meaningless fragments. Models then get those words wrong, and the cost rises with the number of fragments.

We propose to give skeleton generators a vocabulary of skeletal morphemes. A skeletal morpheme is a small connected piece of skeleton, such as a three-joint finger, a two-joint digitigrade foot, or a repeated spine segment. Each piece is stored in its own local coordinate frame, so the same finger is the same token wherever it attaches. The vocabulary is learned from data with the same likelihood-based method that works well for morpheme segmentation in text. The generator then emits a skeleton as a short sequence of these units plus attachment pointers, and a small head predicts continuous corrections for each joint. The bet is that shorter sequences built from meaningful units will improve topology accuracy most on the characters current systems handle worst: long chains, many limbs, and fine hands.

Core Claim

Autoregressive riggers pay a "fertility tax", meaning the number of tokens spent per joint. That tax is a measurable cause of their failures on long-tail anatomy. Re-tokenizing skeletons into learned, position-independent sub-tree units should reduce the tax and the failures together.

The key word is position-independent. Applying ordinary byte-pair merging to coordinate tokens produces units that are frequent but meaningless. A left index finger and a right index finger have different absolute coordinates, so they never merge into the same unit. This is the skeletal counterpart of WordPiece splitting superbizarre into superb+##iza+##rre. Defining units in local frames, with boundaries at branch points, is what lets the reuse that morphology provides in language appear in skeletons.

Where This Sits

The three input directions play different roles here. Rigging is the application. Subword-tokenization research supplies the diagnosis. Morphological decomposition supplies the mechanism.

On the rigging side, four recent systems serialize skeletons for an autoregressive transformer:

  • Puppeteer emits one token group per joint in breadth-first order. It shows that sorting joints spatially breaks topology, and that joint tokens rather than bone tokens cut sequence length by 33%.
  • Auto-Connect adds end-of-branch and end-of-level delimiter tokens. It then uses preference optimization with a tree-edit-distance reward to repair disconnected limbs. It reports degradation on snakes, tails and other elongated chains, which it attributes to biped and quadruped data bias.
  • UniRig flattens the tree into a sequence for an OPT-125M generator.
  • ARMO compresses skeletons with an autoregressive autoencoder and generates in its latent space. Its stated limitations include a fixed joint density.

All four keep the atomic joint as the unit of generation. Puppeteer's 33% saving is evidence that token design matters. Auto-Connect's failures on long chains are the gap we target. We keep their breadth-first ordering and their training recipes, and change only what a token is.

Two NLP results motivate the diagnosis:

  • The Token Tax finds that tokens per word explains up to 50% of the variance in multilingual model accuracy on AfriMMLU, with up to 18 points lost per extra token per word.
  • Superbizarre Is Not Superb shows that segmenting along true morpheme boundaries beats frequency-based segmentation on rare complex words (DelBERT .701 vs. BERT .664 F1 on Reddit topicality).

We borrow the hypothesis from the first: per-asset error should rise with per-asset fertility. We borrow the design rule from the second: frequency alone is not enough, and units must align with meaningful boundaries.

Beyond Characters supplies the method. Its DeepSPIN-3 system runs a transformer over Unigram-LM subwords with stochastic segmentation during training and wins the SIGMORPHON 2022 word-level segmentation task at 97.29 F. It also reports that character-level transformers do poorly. That result constrains us against the "go fully atomic" alternative.

Arabic Preprocessing Schemes contributes a nuance we take seriously. Deep decomposition nearly doubled BLEU at 1% data (17.5 vs. 9.4), but simpler schemes caught up at full data. We therefore expect gains to concentrate in rare categories and small-data regimes, and we design the evaluation to test exactly that.

The research file contains no prior work that treats skeleton sub-trees as linguistic morphemes.

Research Program

The units. A skeletal morpheme is a connected sub-tree of up to $k$ joints, with $k$ around 6. Its geometry is the bone lengths and relative joint rotations, expressed in the frame of its own root joint and normalized by the length of its root bone. These values are quantized to form a discrete key.

Building the vocabulary. We enumerate candidate sub-trees from all training skeletons in Articulation-XL2.0. Candidates whose boundaries cut through a chain at an arbitrary point are discouraged: boundaries are allowed at branch points, at leaves, or wherever the angle between consecutive bones changes sharply. This boundary rule is the explicit "morphological" constraint that separates our units from frequency merges. We then prune the candidate set with the Unigram-LM objective used by DeepSPIN. Given a vocabulary $V$ and unit probabilities $p$, the procedure chooses them to maximize

$$\sum_{s} \log \sum_{z \in Z_V(s)} \prod_{u \in z} p(u),$$

where $s$ ranges over training skeletons, $Z_V(s)$ is the set of ways to cover skeleton $s$ with units from $V$, and $u$ is a unit. The procedure repeatedly drops the units whose removal costs the least likelihood until it reaches a target vocabulary size.

Generation. The generator emits units in breadth-first order over the coarse unit tree. Each unit token is followed by three things: a pointer to the joint it attaches to among those already emitted, a coarse placement rotation and scale, and, for each of its joints, a small continuous residual predicted by a separate regression head. The residuals keep quantization from capping joint precision.

Training. We sample among alternative segmentations during training, as DeepSPIN does with subword regularization. This should make the model robust to how a skeleton happens to be cut into units.

Optional mirror token. One additional component is cautiously motivated by root-and-pattern morphology. A mirror token copies an earlier unit reflected across a predicted plane. This targets bilateral limbs, which are coupled in shape but far apart in a breadth-first sequence. It is ablated separately and is not part of the core claim.

Granularity control. Because a single skeleton has many valid segmentations, and joints can be dropped from or kept in a unit at decode time, the same model can be conditioned on a target joint budget. This is a partial answer to ARMO's fixed-density limitation, and we evaluate it as a secondary result.

What stays fixed. Skinning is not the focus. We reuse the bone-point cross-attention skinning head from UniRig, unchanged, so that any differences in skinning error come only from the skeleton.

Baselines

Naive reference. Atomic joint tokenization in breadth-first order, following Puppeteer, trained with our exact backbone, mesh encoder, data and number of optimizer steps. This is the "do nothing" point: the field's current token design under identical conditions.

Strongest existing method. Auto-Connect's RigFormer, with its delimiter tokens and preference fine-tuning. It is the only system that directly attacks topology errors, and its reported weakness on elongated chains is our target. Auto-Connect reports +4.2% IoU, +5.2% precision and a 15% reduction in CD-J2J over Magic-spatial on Articulation-XL2.0. Absolute values for these metrics are not available on Lacuna, so we will retrain it ourselves on our split.

Further reference points. UniRig reports a 215% rigging-accuracy gain over RigNet and NBS on Rig-XL. ARMO reports a 13.2% IoU gain on OmniRig. RigNet reports 61.6% joint IoU on ModelsResource, against 36.5% for Pinocchio, which bounds the template approach from below.

Fairness. Every baseline gets the same mesh encoder, the same parameter count within 5%, and the same compute. Each also gets the same hyperparameter search of 12 configurations, selected on a shared validation split. Because preference optimization is orthogonal to tokenization, we run our tokenizer both with and without Auto-Connect's preference stage. This keeps "better tokens" separate from "better fine-tuning".

Ablations of the key ingredient.

  • Plain byte-pair merging over the baseline's absolute-coordinate tokens, with a matched vocabulary size. This tests frequency without meaning.
  • Our units in absolute rather than local frames. This tests whether position independence matters.
  • Our units without the boundary rule. This tests whether meaningful boundaries matter.
  • Our units without segmentation sampling.

What counts as beating the baselines. We claim success if three conditions hold over three seeds. First, the full model beats retrained Auto-Connect in topology IoU on the held-out long-tail split by more than the seed variance. Second, it matches or beats Auto-Connect's CD-J2J on the common split. Third, plain byte-pair merging recovers less than half of the gain.

Why not just…?

Why not just apply ordinary byte-pair encoding to the existing joint tokens? This is the most serious alternative, and it is the central ablation. Our prediction is that absolute-coordinate merges mostly capture frequent rest-pose positions on bipeds. That would shorten common skeletons but not rare ones, which is the Superbizarre failure in 3D. If plain byte-pair merging matches our long-tail gains, the morphology argument is wrong. We would then report the simpler method as the contribution.

Why not just use a bigger model or longer context? The Token Tax shows that extra capacity at inference time, in the form of reasoning models, recovers only 8–12 points of a fertility-driven gap. It also shows that cost grows quadratically with sequence length. We test this directly. We scale the atomic baseline to twice its parameters, and give it the compute our model saves through shorter sequences. Then we check whether the slope of error against per-asset fertility flattens. If it does, our gain is a compute effect and not a representation effect.

Why not just rely on preference optimization, as Auto-Connect does? Preference optimization repairs disconnections after training but still generates joint by joint. Auto-Connect itself reports long-chain failures even after preference tuning. Running our tokenizer with and without that stage shows whether the two effects add up or overlap.

Why not just retrieve and fit part templates? Fixed templates are already known to fail on unusual anatomy: Pinocchio reaches 36.5% IoU against RigNet's 61.6%. Our vocabulary is a learned and data-sized version of part reuse, placed inside a model that can also generate unseen arrangements. A retrieve-and-fit baseline over our own unit vocabulary, with nearest-neighbor assembly and no generator, will show how much the generator contributes.

Proposed Experiments and Decisive Checks

Data and splits. We train on Articulation-XL2.0 and test both in-distribution and on ModelsResource-RigNetv1, which is a cross-dataset transfer. We also build a long-tail split of held-out categories with more than 40 joints, chains longer than 8 joints, or more than 4 limbs, drawn from OmniRig and Rig-XL where licensing allows.

Metrics. Topology quality is measured by joint IoU, precision, recall and tree edit distance. Geometric accuracy is measured by CD-J2J and CD-B2B. We also report the rate of disconnected skeletons, skinning L1 error, generation time, and fertility, defined as $f = T/J$, where $T$ is the number of tokens emitted and $J$ is the number of joints.

Check 1: does fertility drive error? Following The Token Tax, we regress per-asset IoU on per-asset fertility for the atomic baseline. If fertility explains little variance even on the long-tail split, the motivation fails and we stop.

Check 2: does the fix work for the right reason? Our tokenizer should lower fertility most on long-tail assets. It should also reduce the slope of error against fertility, not merely shift error down. The plain byte-pair ablation should not do the same.

Check 3: does the gain shrink with data? Following the Arabic translation result, we expect the advantage to shrink as training data grows. We train every method on 10%, 30% and 100% of the training data and report per-category curves.

Check 4: granularity control. We condition the model on a joint budget and measure how closely it hits that budget, and at what accuracy, compared with ARMO's fixed-density behavior.