This is a simplified guide to an AI model called Unirig-Ai maintained by Aaronjmars. If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter.
Overview
unirig-ai automatically generates skeletal rigs and skinning weights for 3D models across diverse categories—humans, animals, and objects—using a unified autoregressive framework. Built by aaronjmars and based on the SIGGRAPH'25 UniRig research from Tsinghua University and Tripo, this model combines skeleton tree tokenization with bone-point cross-attention to predict both topologically valid skeletons and per-vertex skinning weights in a single pipeline. The system handles input formats including .glb, .obj, .fbx, and .vrm files, making it immediately compatible with standard 3D content creation workflows. The core innovation lies in its ability to maintain skeleton hierarchy validity through a specialized tokenization scheme and achieve 215% improvement in rigging accuracy and 194% improvement in motion accuracy compared to prior commercial and academic methods.
Best use cases
Animation production acceleration for diverse character types. UniRig eliminates the tedious manual skeleton creation step that traditionally consumes hours per character. A studio rigging humanoid characters, quadrupeds, and non-organic props can now process all asset types through a single model rather than maintaining specialized rigs or relying on manual animation artists. This works particularly well when you have batches of similar models (100+ anime-style characters, creature variants, or environmental props with articulation) where the time savings compound significantly.
Rapid iteration in AI-powered 3D content pipelines. If your workflow generates 3D assets algorithmically—whether through generative models, procedural systems, or third-party asset libraries—UniRig provides immediate rigging without bottlenecking on manual work. Game studios using procedural world generation or character customization systems can automatically rig variations instantly, enabling dynamic content creation at scale.
Custom mesh rigging from Objaverse and similar databases. The model trains on data from Objaverse and understands diverse topology variations. When working with downloaded or scraped 3D models that lack proper rigging information, UniRig infers plausible skeleton structures and weights automatically, making unrigged library assets immediately usable in animation pipelines.
Physics simulation preparation and secondary motion setup. The framework's skeleton predictions provide the foundation needed for physics engines to calculate secondary motion (hair, cloth, loose parts). By producing valid hierarchies with proper bone positioning, it enables downstream physics solvers to work immediately without manual skeleton refinement, accelerating the path from static model to fully simulated character.
Design-to-animation workflows for product visualization. E-commerce and product teams can rig furniture, mechanical objects, and other non-organic items to create animated product previews. The model's ability to identify articulation points in diverse geometries (opening doors, rotating wheels, articulating arms on robotic products) makes product animation accessible to non-specialist teams.
Limitations
Skeleton prediction quality degrades on exotic or deformed topologies. While the model handles diverse categories, it performs best on relatively standard anatomical structures. Highly unusual proportions, fused body parts, or non-standard morphologies may receive skeletons that miss important articulation points (such as missing tail or wing bones). The README explicitly warns that "results may degrade significantly if the skeleton is inaccurate" when this feeds into the skinning stage.
Skinning quality depends directly on skeleton accuracy. The two-stage pipeline means that skeleton errors propagate to skinning. If the skeleton prediction misses important joints, the skinning stage cannot recover that information. You must inspect and manually edit skeletons before running skinning to achieve production-quality results, contradicting the "fully automatic" promise for complex models.
No iterative refinement or user control in the current API. This Replicate endpoint exposes skeleton and skin prediction as batch operations only. There is no mechanism to provide hints, adjust predicted bones, or run interactive refinement loops. The commercial workflow requires exporting predictions, editing in external tools (like Blender), and reimporting—eliminating some time savings compared to fully manual rigging.
Limited control over skeleton topology and style. The model predicts a single skeleton variant based on learned priors. You can vary results using different random seeds, but there is no way to request a specific skeleton style (e.g., game-engine conventions vs. motion capture conventions) or enforce application-specific bone naming and hierarchy requirements. Post-processing always requires manual adjustment.
Performance unvalidated on production-scale model batches. The README emphasizes this is a research release. No information exists about API latency, throughput, cost scaling, or VRAM requirements when processing large batches. The GitHub installation requires specific CUDA versions, PyTorch >=2.3.1, flash_attn, spconv, torch_scatter, and torch_cluster—a complex dependency stack that may not match your inference infrastructure.
Successor model available but not yet released. The README announces SkinTokens, which claims 98–133% improvement in skinning accuracy and 17–22% improvement in bone prediction. The current UniRig release may become obsolete quickly, making it uncertain whether learning this model is worth investment if its replacement is imminent.
License and commercial use restrictions unclear. While the repository has a LICENSE file, the README and schema provide no explicit statement on whether commercial use is permitted, whether datasets require attribution, or whether there are any restrictions on derivative works.
How it compares
UniRig by VAST-AI on Hugging Face is the same underlying model but accessed through Hugging Face's inference API rather than Replicate. Choose the Replicate version if you already use Replicate's infrastructure or need managed hosting; choose the Hugging Face version for lower latency if you self-host or prefer direct model access.
openpose by aiunivers performs 2D pose estimation from images, not 3D skeleton rigging. OpenPose detects human body keypoints in photographs or videos for motion capture or pose analysis, while UniRig generates 3D skeletal structures from 3D mesh geometry. They solve different problems—OpenPose extracts pose from video, UniRig creates rigs for 3D models—so there is no direct tradeoff.
Skywork-UniPic-1.5B by Skywork is a multimodal vision-language model handling image understanding, text-to-image generation, and image editing. It operates on 2D images, not 3D geometry, so it cannot rig 3D models. UniRig is the only option if you need skeletal rigging; Skywork UniPic is irrelevant for 3D animation workflows.
UNO by bytedance-research is a diffusion-based image generation and manipulation model focused on visual consistency and controllability. It works with 2D images and cannot process 3D mesh files. If your task involves 2D image synthesis or manipulation, UNO is applicable; if you need 3D rigging, only UniRig fits.
consisti2v by wren93 converts images to video with visual consistency enhancement, working in 2D temporal space. UniRig works in 3D geometric space to create articulated skeletons. These models address entirely different domains—video synthesis vs. 3D rigging—with no meaningful comparison.
Technical specifications
UniRig implements a two-stage autoregressive transformer architecture optimized for skeleton and skinning prediction. The skeleton prediction stage uses a novel Skeleton Tree Tokenization scheme that efficiently encodes hierarchical bone relationships, allowing the model to predict topologically valid structures autoregressively. The skinning stage employs a Bone-Point Cross Attention mechanism that maps predicted skeleton bones to input mesh vertices, computing per-vertex skinning weights that control how geometry deforms during animation.
The model trains on Rig-XL, a large-scale dataset of over 14,000 rigged 3D models spanning diverse categories. Rig-XL includes detailed annotation with joint positions, skinning weights, bone hierarchies, and local bone axes aligned to Y-up coordinates (Blender standard). The dataset also includes the VRoid anime character subset and models from Objaverse-XL, covering humans, animals, and objects with varied topology and complexity.
Key technical details:
- Architecture: GPT-like autoregressive transformer with skeleton tree tokenization and bone-point cross-attention
- Training data: 14,000+ rigged 3D models from Rig-XL and VRoid datasets
-
Input formats:
.glb,.obj,.fbx,.vrm - Output formats: FBX (skeleton and rigged mesh with skinning weights)
- Mesh representation: Vertices (N, 3), faces (F, 3), per-vertex skinning weights (N, J) where J is joint count
- Skeleton representation: Joint positions (J, 3), parent hierarchy, local transformation matrices, joint names
- Python version required: 3.11
- PyTorch version: >=2.3.1
- GPU dependencies: CUDA-compatible, requires spconv, flash_attn, torch_scatter, torch_cluster
- Data format: Dataset stored in float16 for compression
- World space: All models converted to world space coordinates
- Random seed control: Skeleton prediction supports seed variation for generating multiple skeleton candidates
- Model checkpoint: Available on Hugging Face (VAST-AI/UniRig)
Model inputs and outputs
Inputs
-
input_mesh (string, URI format): A 3D model file path or URL in one of the supported formats:
.glb,.obj,.fbx, or.vrm. Required.
Outputs
- Output (string, URI format): A file URL pointing to the generated rigged 3D model in FBX format, containing both skeleton and skinning weights.
Getting started
import replicate
# Generate a skeleton and skinning weights for a 3D model
output = replicate.run(
"aaronjmars/unirig-ai:9ee496eafcc6ab9789a110a6357e43e5ee8b93cee9ab653bdc6f06a29341ee86",
input={
"input_mesh": "https://example.com/path/to/model.glb"
}
)
print(output)
# Output: URL to the rigged FBX file
To use a local file, upload it to a cloud storage service first, or use Replicate's file handling if your client supports it. The returned output is a file URL that you can download and import into Blender, Maya, or any 3D animation software that supports FBX.
Frequently asked questions
Q: What file formats does UniRig accept as input?
A: The model accepts .glb, .obj, .fbx, and .vrm files. These cover most standard 3D model formats used in game engines, animation software, and asset libraries.
Q: Can I generate multiple skeleton variations for the same model?
A: Yes, the skeleton prediction stage supports random seed variation. Different seeds produce different skeleton hierarchies, allowing you to generate alternatives and select the best one. The shell scripts in the repository show how to pass --seed parameters.
Q: What do I do if the predicted skeleton is missing important bones (like a tail or wing)?
A: The README recommends manual refinement before proceeding to skinning. Export the skeleton to FBX, open it in Blender or Maya, add missing bones, adjust positions, and save. Then run the skinning stage on the corrected skeleton. This is a required step for non-standard or exotic topologies.
Q: Is this model suitable for production animation pipelines?
A: For standardized, common asset types (humanoid characters, quadrupeds, standard mechanical rigs), it can significantly accelerate production by automating the skeleton creation step. For complex or custom rigs, expect to spend time on manual refinement and editing. It reduces work rather than eliminating it for production-quality results.
Q: What is the difference between the skeleton prediction and skinning prediction stages?
A: Skeleton prediction generates the bone hierarchy and joint positions from the input mesh geometry. Skinning prediction takes that skeleton and the original mesh, then computes per-vertex weights that control how each vertex moves when bones rotate. Both stages are needed for a fully rigged model.
Q: How does UniRig compare to hiring a rigger or using traditional software like AdvancedSkeleton or RigifyFlex in Blender?
A: UniRig is dramatically faster for initial skeleton generation, especially across diverse asset types. However, riggers add subtle deformations, control rigs for animation, corrective shapes, and domain-specific optimizations that UniRig does not provide. UniRig is best viewed as a high-quality starting point that eliminates repetitive skeleton creation, reducing rigger time from hours to minutes for asset-specific refinement.
Q: What is SkinTokens and should I wait for it instead of using UniRig?
A: SkinTokens is the successor to UniRig (announced for SIGGRAPH'25), claiming 98–133% improvement in skinning accuracy and 17–22% improvement in bone prediction by unifying skeleton and skinning into a single autoregressive sequence with learned discrete tokens. If production-grade results are critical, waiting for SkinTokens release may be worthwhile. Current UniRig release is stable but likely to be superseded.
Q: Can I use this for commercial projects or is there a license restriction?
A: The repository includes a LICENSE file, but the Replicate schema and README do not explicitly state commercial use terms. Check the GitHub repository's LICENSE file directly or contact the maintainers for clarification on commercial use, dataset attribution requirements, and derivative work restrictions.
Top comments (0)