ComfyUI Node

SkinTokens Rig

SkinTokens Rig, the no-Blender rigging step

By stevelittlefish·Created 3 days ago·Updated a day ago· 1
SkinTokens Rig
  • model
  • mesh
  • rigged_glb
filename_prefixskintokens_rigged
relabeltrue
conventionMixamo
relabel_fingerstrue
clean_weightstrue
use_transfertrue
use_postprocesstrue
use_skeletonfalse
top_k5
top_p0.95
temperature1.00
repetition_penalty2.0
num_beams10

Every image-to-3D model worth running gives you the same thing: a static mesh with no rig. TRELLIS and Hunyuan3D are great at surfaces and terrible at skeletons, and the community has been saying so since 2025 - the standard complaint is that generated topology is fine for a static prop and useless for anything you want to animate. Up until now, the fix meant opening Blender, which for a headless GPU box is a non-starter. SkinTokens Rig is the missing middle of that pipeline: a static mesh goes in, and a rigged, skinned .glb comes out, all inside ComfyUI, no bpy anywhere.

It's the star node of the SkinTokens-NoBlender pack, and it exists to feed exactly one downstream dream: Trellis.2 (mesh) → SkinTokens Rig (rig) → Kimodo (text-to-motion), the whole thing on a LAN server. Kimodo wants a rigged character to animate, and a rigged character is precisely what this node produces.

How it works

Under the hood is VAST-AI's TokenRig model (the successor to UniRig), which is autoregressive: it reads your mesh and emits a skeleton plus skin weights as one token sequence. Your SkinTokens Loader result goes in, the model runs its generation loop, and the result is written as a proper skinned glb - translation-only joint nodes, inverse-bind matrices, and top-4 JOINTS_0/WEIGHTS_0 so the file poses correctly in any glTF viewer. Because the model is registered with ComfyUI's model manager, the ~14 GB of weights load to the GPU when this node runs and free up afterwards - not a node you babysit for VRAM.

The inputs that matter

The node looks busy, but most of it you can leave alone.

  • mesh - accepts a native MESH (from a Trellis/remesh chain) or a File3D (FILE_3D_GLB/GLTF/OBJ/STL, from Load3D). This choice matters more than any flag.
  • relabel / convention / relabel_fingers - on by default, and you probably want it on: the raw model names its bones bone_0 … bone_N, and downstream animators match bones by name. Mixamo is the safe default (that's what Kimodo speaks); UE5 renames to pelvis/spine_01/upperarm_l style.
  • clean_weights - on by default. Repairs geometrically impossible weights - a hand vertex leaking onto a toe - right after rigging. Leave it on; it's deterministic and it's what stops the "exploding hand" tearing when you actually animate.
  • use_transfer (on by default) - attaches the rig to your original glb so materials, textures, UVs and scale survive. Only applies when the input is a File3D; a native MESH has no source file to carry over.
  • use_postprocess (on by default) - a voxel-heat pass that sharpens weights around limb boundaries. Cleaner deformation, slower. Turn it off for a faster pass when you're iterating.
  • use_skeleton (off by default) - skin-only mode: keep an armature already in the input glb and just predict weights for it instead of generating a fresh skeleton.
  • The generation params (top_k, top_p, temperature, repetition_penalty, num_beams) are exposed but default to upstream's values (5 / 0.95 / 1.0 / 2.0 / 10). You will almost never touch these; treat them as "if the skeleton comes out weird, you can wiggle these."

What comes out

A single rigged_glb on a FILE_3D_GLB socket. Because it's a file-backed glb, it drops straight into ComfyUI core's Preview3DAdvanced - which has a showSkeleton toggle you'll want to flip to actually see what the rig looks like - or Save3D.

Install

ComfyUI Manager (search SkinTokens-NoBlender), or:

cd ComfyUI/custom_nodes
git clone https://github.com/stevelittlefish/ComfyUI-SkinTokens-NoBlender
pip install -r ComfyUI-SkinTokens-NoBlender/requirements.txt

First run downloads ~14 GB of weights from VAST-AI/SkinTokens via the Loader node - that's the real install, budget for it.

Where people get burned

  • Textures vanish. If you feed it a File3D with use_transfer off, you get the rigged proxy with a flat default material - the original textures never make it into the file. And a native MESH input can't transfer at all (no source file), so if keeping the texture matters, route a Load3D glb in instead of a raw mesh.
  • The hand explodes in motion, not at rest. At rest contaminated weights are invisible; the tear shows up when a far bone animates. That's what clean_weights is for. If you turned it off (or you're rigging something that came from elsewhere), run SkinTokens Clean Weights on the output.
  • Kimodo won't animate it. Kimodo matches Mixamo-named bones, and the handoff is still waiting on a fix in the Kimodo node itself - not this pack. Keep convention on Mixamo so you're ready the day that lands.
CategorySkinTokens

Inputs (15)

NameTypeDefaultDescription
modelSKINTOKENS_MODEL
meshMESH,FILE_3D_GLB,FILE_3D_GLTF,FILE_3D_OBJ,FILE_3D_STL,FILE_3D
filename_prefixSTRINGskintokens_rigged
relabelBOOLEANtrue
conventionCOMBOMixamo2 options: Mixamo, UE5
relabel_fingersBOOLEANtrue
clean_weightsBOOLEANtrueRepair geometrically-impossible skin weights (e.g. a hand vertex leaking onto a toe) after rigging. Fixes 'exploding hand' tearing during animation. Deterministic.
use_transferoptBOOLEANtrue
use_postprocessoptBOOLEANtrue
use_skeletonoptBOOLEANfalse
top_koptINT51–200
top_poptFLOAT0.950–1
temperatureoptFLOAT1.000–5
repetition_penaltyoptFLOAT2.01–5
num_beamsoptINT101–50

Outputs (1)

NameTypeDescription
rigged_glbFILE_3D_GLB