WorksComputer Science
FlowRig: Unified Skeleton Generation for 3D and 4D Meshes via Flow Matching
Abstract
Automatic rigging is a fundamental task for both static 3D and dynamic 4D mesh animation, yet existing methods do not provide a unified feedforward solution for these two settings. While static 3D riggers achieve strong quality, they often provide limited control over bone count and become temporally unstable when applied frame by frame to dynamic meshes. Existing 4D methods, in contrast, typically rely on expensive per-sequence optimization. We propose FlowRig, a template-free, data-efficient framework for unified 3D and 4D skeleton generation. Built on flow matching, FlowRig generates temporally aligned skeletons for an entire sequence in a single feedforward pass, while naturally handling single-mesh 3D rigging. The model further supports explicit skeleton-count control, uncertainty estimation for candidate selection, and masking-based interpolation, forecasting, and backcasting. To address limited paired 4D rigging data, we adopt a curriculum that initializes from large-scale 3D rigging data and adapts to mid-scale 4D mesh-skeleton data. Experiments show that FlowRig achieves strong static 3D rigging performance with controllable bone complexity, as well as high-quality and temporally consistent 4D reconstruction and prediction results.
https://tamu-visual-ai.github.io/FlowRig/

Figure 1. FLOWRIG unifies rigging for both 3D and 4D meshes. Compared with prior methods such as Puppeteer [34] and UniRig [56], our model delivers accurate 3D rigging, preserves 4D temporal consistency, supports controllable bone count, achieves faster inference, and enables 4D skeleton prediction, including interpolation, forecasting, and backcasting.
Introduction
Automatic rigging is a core problem in computer graphics, which turns raw geometry into animatable assets. This need spans both static 3D and dynamic 4D meshes: 3D assets require high-quality, controllable skeletons for downstream animation workflows, while 4D assets additionally require temporal consistency across time. At the same time, temporally coherent 4D meshes are becoming increasingly available from modern reconstruction and generation pipelines. Recent systems can recover or synthesize dynamic 4D geometry directly from videos or generative models, making 4D meshes a practical representation rather than a niche output [33 Zhang et al.,] 2025b; Xie et al., [43]). However, geometry alone is not enough for downstream animation, editing, simulation, and control. To make these assets truly useful, we need a unified feedforward rigging model that works for both 3D and 4D meshes, produces informative skeletons, supports controllable bone complexity, and remains stable across diverse poses and motions.
Unfortunately, this capability is still missing. On one side, existing rigging methods are predominantly designed for static 3D inputs, ranging from classical optimization systems (Baran & Popović, [3]) to modern feedforward and autoregressive models (Xu et al., [46]; Zhang et al., [56]; Liu et al., [23]; Sun et al., [36]; Song et al., [34]; Zhang et al., [55]). These methods have substantially improved 3D rigging quality and efficiency, but they are fundamentally static, and many of them provide limited control over skeleton density or bone count for downstream applications. When applied frame by frame to dynamic meshes, they also typically fail to maintain temporal consistency (Wang et al., [39]). On the other hand, existing 4D methods mainly focus on per-sequence optimization, reconstruction, or motion transfer (Li et al., [17]; Yao et al., [48]; Wang et al., [38]; Dabhi et al., [7]; Muralikrishnan et al., [27]; Kim et al., [16]). While these methods are valuable, they do not provide a unified feedforward rigging solution that bridges controllable 3D rigging, dynamic 4D reconstruction, and predictive temporal reasoning within one framework.
Building such a unified model is challenging for two reasons. First, many strong static rigging methods are autoregressive, which makes explicit bone-count control less natural and global temporal reasoning inefficient for dynamic sequences. Second, paired 4D mesh-skeleton data remains far scarcer than static 3D rigging data, so a practical model must learn temporal consistency from limited 4D supervision while preserving strong 3D rigging quality.
In this work, we propose FLOWRIG, a data-efficient feedforward framework for unified skeleton generation on 3D and 4D meshes. Built on flow matching, FLOWRIG predicts temporally aligned skeletons for an entire sequence in one pass, while naturally handling 3D rigging with explicit skeleton-count control. The model also includes a graph head for temporally consistent topology prediction and an uncertainty head for confidence estimation. The masking-based training further enables 4D prediction including interpolation, forecasting, and backcasting. To address limited 4D supervision, we initialize from large-scale 3D rigging data and then adapt to mid-scale 4D rigging data. Experiments show that FLOWRIG achieves strong static 3D rigging performance with controllable bone complexity, as well as high-quality, temporally consistent 4D reconstruction and prediction.
Our main contributions are as follows:
We propose FLOWRIG, a unified flow-matching model for controllable 3D/4D skeleton generation.
We introduce a 3D-to-4D curriculum for data-efficient training under limited 4D supervision.
We achieve strong 3D rigging, high-quality 4D reconstruction, and flexible 4D prediction.
Related Work
Static Automatic Rigging and Skinning. Automatic rigging has been studied extensively in the static 3D setting. Early methods relied on template fitting and per-shape optimization, as in Pinocchio (Baran & Popović, [3]), while later data-driven approaches improved both speed and generalization. RigNet (Xu et al., [46]) introduced graph neural networks for direct skeleton and skinning prediction from meshes. Subsequent methods such as UniRig (Zhang et al., [56]), RigAnything (Liu et al., [23]), ARMO (Sun et al., [36]), Puppeteer (Song et al., [34]), and Skin Tokens (Zhang et al., [57]) further improved structural validity through autoregressive or language-model-style generation (Song et al., [35]). These methods are strong baselines for static 3D rigging, but not for general-purpose 4D rigging. In particular, autoregressive generation is less suitable for 4D sequences, where one must reason jointly over skeletal slots and time; applying static models per-frame often leads to temporal flickering and inconsistent topologies (Wang et al., [39]). Their discrete formulation can also make skeleton density control harder for downstream 4D use.
Dynamic and 4D Rigging. As 4D meshes become more accessible, there is growing interest in rigging dynamic assets directly from videos or mesh sequences. Existing 4D rigging-related methods mainly fall into two categories. The first consists of per-sequence optimization methods, such as AKD (Li et al., [17]), RigGS (Yao et al., [48]), AniMimic (Xie et al., [43]), GaussiAnimate (Wang et al., [38]), and RAT4D (Dabhi et al., [7]), which align articulated structure to multi-frame observations or dynamic 3D representations. These methods can achieve high fidelity, but their reliance on per-scene optimization makes them computationally expensive and less suitable for scalable deployment. The second involves consistency-oriented extensions of static riggers, such as SPRig [39], which improve cross-frame consistency through additional self-supervision. While promising, these methods do not yet provide a unified feedforward framework for raw 4D mesh sequences that supports both reconstruction and prediction. Related animation methods, including Gaussian bone representation, zero-shot pose transfer and morphology-aware motion transfer [13, 27, 16, 55], are complementary rather than direct solutions to general-purpose 4D rigging.
4D Mesh Availability and Upstream Geometry Models. Our work is motivated in part by the increasing availability of temporally coherent 4D meshes from upstream reconstruction and generation systems. The field has seen rapid expansion, ranging from text- and image-to-4D generation (Yin et al., 2023; Ling et al., 2024; Bahmani et al., 2024a; Miao et al., 2024; Yuan et al., 2024; Chen et al., 2024; Zeng et al., 2024a; Bahmani et al., 2024b; Sun et al., 2025b; Lin et al., 2025a;b; Zhao et al., 2023a; Gao et al., 2024; Wang et al., 2024; Dai et al., 2025; Nag et al., 2025)} to video-based dynamic reconstruction (Jiang et al., 2024; Zeng et al., 2024b; Wu et al., 2024; Zhang et al., 2024b;a; Li et al., 2024; Fu et al., 2024; Zhu et al., 2026; Yao et al., 2025a; Xie et al., 2025; Chen et al., 2025; Ren et al., 2024; 2023; Liang et al., 2024). In particular, recent methods such as ActionMesh {citep}[33] and AniMimic {citep}[43]` show that high-quality dynamic geometry can now be derived from monocular videos and learned priors. While these systems expand the supply of dynamic geometry, they do not solve the downstream rigging problem. Instead, they highlight the need for a feedforward 4D rigging model that converts temporally aligned geometry into informative and animation-ready skeletons. In this sense, our method is complementary: upstream models provide the dynamic geometry, while FLOWRIG provides the rigging for downstream animation and control.
Generative Models for 3D and 4D Assets. A separate line of work studies the co-generation of geometry and rigging information. AniGen [14] generates animatable 3D assets together with rigging information, while AKD [17] uses score distillation to generate articulated 4D assets from images or text. Related directions include skeleton-guided 3D generation [45], creative articulated asset generation [25], sketch-based rigging [59], and rig-based generative synthesis of dynamic 3D Gaussians [41]. However, these works are not for general-purpose feedforward rigging of raw 4D mesh sequences. Instead, our focus is to take 3D or 4D geometry as input and produce temporally consistent skeletons with controllable complexity and prediction capability, making our setting complementary to asset generation.
Proposed Method
Problem Formulation
Let denote a observation sequence of mesh , where each frame is represented as a sampled point cloud with normals and is the size of the point cloud. Our goal is to predict a corresponding skeleton sequence , where each is a set of bones with 3D endpoints and a tree topology. We consider static and dynamic tasks below.
Static skeleton reconstruction. When , we generate a skeleton set conditioned on a single mesh observation . Formally, we model the conditional distribution .
Dynamic skeleton reconstruction and prediction. Given observed frames and observations , we generate the full skeleton sequence using . Reconstruction corresponds to , while prediction corresponds to .
Flow Matching on An Optimal-Transport Path
Instead of learning a reverse denoising process as in diffusion models, flow matching learns a continuous-time vector field that transports noise to data. Let denote a clean sample and be Gaussian noise. We use the optimal-transport straight-line path for , whose target velocity is constant: . Given mesh-derived conditioning tokens , the network predicts the velocity field and is trained to match with mean-squared error, together with our matching and auxiliary losses. At inference time, we start from and integrate the learned ODE from to with an Euler solver:
yielding the clean sample .
4D Skeleton Flow Matching Model
Figure 2 shows an overview of FLOWRIG. Given a static mesh or a mesh sequence, we encode each frame with the frozen Michelangelo encoder (Zhao et al. [61]) to obtain mesh conditioning tokens . In parallel, we initialize a fixed set of noisy skeleton slots and optionally inject a target skeleton-count condition to control the number of generated bones. We set to cover all training instances, similar to prior slot-based methods such as Puppeteer (Song et al. [34]), and allow to vary by sampling different window lengths during training. The DiT embeds the skeleton slots into -dimensional tokens, concatenates them with the mesh tokens, and processes the resulting sequence of length with temporal rotational positional encoding (RoPE) using the frame index as the shared temporal reference. It then performs slot-based set prediction over the full sequence and predicts a velocity tensor , which is decoded into up to bones per frame as 7D slot states , where each slot is with an existence indicator and two 3D endpoints . After the transformer predicts the aligned skeleton slots, a graph head infers the kinematic tree and an uncertainty head estimates confidence, producing the final controllable 3D or 4D rigging result.
Figure 2. FLOWRIG overview. We encode meshes into conditioning tokens, and initialize noisy skeleton slots, which are processed by a flow matching transformer to predict temporally aligned skeleton representations. The predicted features are decoded by the skeleton, graph, and uncertainty heads to recover 3D/4D rigging outputs, with uncertainty used for sample selection. denotes the skeleton count, and denotes the unconditional token.
Besides the skeleton head, we use two additional lightweight heads: a graph head and an uncertainty head. A naive way to build a skeleton tree is to connect bones by distance, but this can lead to unstable topology over time as the joints move. Instead, the graph head predicts parent indices from the hidden features and the predicted skeletons , yielding a more temporally consistent tree structure. The uncertainty head takes the hidden features as input and predicts per-frame per-bone uncertainty . Intuitively, it estimates how reliable each generated bone is, so we can use uncertainty as a score when drawing multiple samples and select the most confident result.
Skeleton-count conditioning and classifier-free guidance (CFG). In addition to mesh tokens, we condition the model on a scalar skeleton or bone count , which serves as a guidance label. During training we apply classifier-free guidance by randomly dropping the condition with probability , that is, replacing with an unconditional token in the embedding layer. The conditional and unconditional predictors share parameters and differ only in the presence of :
During inference, we form the guided velocity with CFG scale as , and integrate the ODE with .
Training Objective
Our training objective combines flow matching with the auxiliary supervision terms.
One-to-one supervision via sequence Hungarian matching. To handle variable ground-truth bone counts while preserving a fixed tensor interface, we follow the DETR-style one-to-one supervision (Carion et al. [4]). Each is represented using permutation-invariant skeleton slots, and model is trained with hungarian matching for each predicted and ground-truth skeleton pair. For each frame we extract raw endpoints and pad them to a fixed tensor size. Since slot indices are permutation-invariant, we compute a single assignment per sequence, shared across frames, using the Hungarian algorithm. We first recover a predicted clean state by
and build a cost matrix between slot endpoints and and the ground-truth endpoints . To align the static and dynamic training objectives, we set the anchor frame for hungarian matching in all training stages. The matching cost is a weighted sum of endpoint Euclidean distance. The resulting assignment maps each ground-truth bone to one slot, producing matched targets .
Flow matching loss. The primary objective is a weighted flow-matching mean-squared error on the matched optimal-transport velocity:
where per-slot weights upweight matched slots and control supervision on empty slots with less focus. Intuitively, we set the unmatched slot endpoints with zero weight since they have no contribution to the final results, thus forcing the model to focus on the matched pairs.
Uncertainty loss. To quantify the confidence of skeletons, we add a Gaussian negative log-likelihood (NLL) term to estimate the uncertainty of bone existence and the joint positions. Following ID-DPM [29], we stop gradients through the mean prediction in the NLL branch:
where is a small value and denotes the stop-gradient operator. This way, can guide without affecting the training of transformer backbone and skeleton head.
Graph head loss. To build the kinematic tree for the generated skeleton, we supervise a parent index classifier over slots. Specifically, to handle temporal aggregation and derive a temporal-consistent tree, we pool time by averaging to obtain a single parent distribution per slot for geometry and high-level context , concatenating them to form the input of the graph head . The graph head will output where the additional two channels are used to represent the root and non-existing classes. Targets are constructed from the ground-truth joint graph and the Hungarian assignment, including root, non-root, and non-existing classes. The loss is
where is a hyperparameter to control the denoising-step-aware weight in flow matching. Intuitively, small means the noisy state is still close to a coherent skeleton, so parent index targets (via Hungarian matching on ) are more reliable while large means slots are dominated by noise, so downweighting parent CE reduces conflicting topology gradients. The exponent controls how sharply supervision is concentrated toward .
Total objective. The final objective is a weighted sum:
where are the coefficients for each term and is used to regularize the geometry and temporal smoothness (defined in the Appendix § 7). Overall, the losses in our framework serve three purposes: (1) learns accurate skeleton generation through flow matching, (2) and improve confidence estimation and kinematic topology prediction, and (3) regularizes geometric validity and temporal consistency. Together, these terms improve stability and produce controllable, temporally aligned skeletons for both 3D and 4D inputs.
Curriculum Training from 3D Reconstruction to 4D Prediction
We train the model with a curriculum progressively increasing temporal complexity while keeping the architecture fixed. As shown in Figure 3, we start with static single-frame skeleton generation initializing the model with a strong geometry prior. We then switch to dynamic reconstruction, training on different time windows with full guidance of mesh. Finally, we emphasize dynamic prediction by randomly masking mesh tokens to force the model to simulate missing observations.
Figure 3. Data-efficient curriculum training. We first train on static 3D rigging, then adapt to 4D reconstruction, and finally enable prediction through masked conditioning. During the final stage, we use diverse masking patterns, including interpolation, forecasting, backcasting, and random masking, to expose the model to different temporal prediction settings. This schedule transfers large-scale 3D supervision to the data-scarce 4D setting.
Experiments
We evaluate FlowRig across diverse rigging scenarios, focusing on its ability to maintain 4D consistency and performance as a static rigger. Unless otherwise specified, we use unconditional guidance at inference time, since the ground-truth bone count is unavailable at test time.
Experimental Setup
Datasets. To ensure a comprehensive evaluation, we utilize three primary data sources spanning static and dynamic domains. (1) For static rigging, we follow the protocol established in Puppeteer ([34]) and employ Articulation-XL ([35]), a massive collection of 33,000 high-quality rigged 3D models covering humanoids, animals, and mechanical objects. (2) We also evaluate on the classic ModelsResource dataset ([46]), which contains a curated set of character models with professionally designed skeletons, serving as a standard benchmark for topological accuracy. (3) For dynamic 4D rigging, we utilize a curated dynamic dataset derived from TexVerse ([58]). We manually filtered the TexVerse animated subset to retain around 2,500 object-centric instances where the skeleton and mesh remain strictly aligned across temporal sequences, providing a high-fidelity ground truth for evaluating consistency and predictive forecasting. More details about the curated dataset can be found in Appendix § 6.
Evaluation metrics. We evaluate skeleton quality with three Chamfer Distance (CD) variants: Joint-to-Joint (J2J), Joint-to-Bone (J2B), and Bone-to-Bone (B2B), which measure joint accuracy, joint-to-bone alignment, and structural fidelity, respectively. For 4D tasks, we average these over time. We also evaluate temporal consistency using bone distance deviation (BDD), which measures temporal jitter in bone lengths; Graph Structural Distance (GSD), which measures structural consistency through Hamming distance (HD) ([39]); and bone number deviation (BND), which measures changes in bone count relative to the anchor frame. More details are provided in Appendix § 8.§ 1.
Baselines. We compare FlowRig against both classical and modern rigging baselines. Classical methods include Pinocchio ([3]), a template-fitting optimization-based rigging system, and RigNet ([46]), a graph-neural-network-based feedforward rigger. Among recent generative or transformer-based methods, we consider MagicArticulate ([35]), Anymate ([10]), UniRig ([56]), RigAnything ([23]), and Puppeteer ([34]). These methods cover a broad spectrum from optimization-based pipelines to modern feedforward sequence models. While several of them are strong for static 3D meshes, our results show that FlowRig remains competitive in the static setting while additionally providing the native 4D consistency and predictive capability required for dynamic sequences.
3D Skeleton Reconstruction
FlowRig supports both static and dynamic meshes, and with a single mesh as input it becomes a strong 3D rigging model. As shown in Table 1, our method ranks among the best across all three datasets, clearly outperforming classical baselines such as Pinocchio and RigNet. Among recent methods, Puppeteer [34] and RigAnything [23] are the strongest competitors, but FlowRig achieves the best overall results on Articulation-XL 2.0 and Diverse-Pose and remains competitive on ModelsResource in the zero-shot setting, even if RigAnything is trained directly on that training dataset. Overall, these results show that our unified 3D/4D formulation preserves strong static rigging performance and improves further with uncertainty-based selection in Ours*. Figure 4 shows that our method recovers more detailed and better mesh-aligned skeletons compared with baselines; more results are shown in Appendix § 10 and the demo video.
| Model | Articulation-XL 2.0 | ModelsResource | Diverse-Pose | ||||||
| J2J ↓ | J2B ↓ | B2B ↓ | J2J ↓ | J2B ↓ | B2B ↓ | J2J ↓ | J2B ↓ | B2B ↓ | |
| Pinocchio | 0.0832 | 0.0661 | 0.0549 | 0.0685 | 0.0482 | 0.0409 | 0.0797 | 0.0641 | 0.0515 |
| RigNet | 0.0762 | 0.0608 | 0.0528 | 0.0722 | 0.0599 | 0.0433 | 0.0775 | 0.0639 | 0.0571 |
| MagicArt. | 0.0326 | 0.0250 | 0.0212 | 0.0411 | 0.0314 | 0.0269 | 0.0438 | 0.0346 | 0.0296 |
| Anymate | 0.0409 | 0.0301 | 0.0294 | 0.0370 | 0.0261 | 0.0258 | 0.0342 | 0.0255 | 0.0272 |
| UniRig | 0.0331 | 0.0261 | 0.0218 | 0.0396 | 0.0302 | 0.0257 | 0.0325 | 0.0257 | 0.0208 |
| RigAnyth. | 0.0489 | 0.0379 | 0.0306 | 0.0343 | 0.0244 | 0.0204 | 0.0397 | 0.0308 | 0.0241 |
| Puppeteer | 0.0311 | 0.0237 | 0.0198 | 0.0377 | 0.0280 | 0.0241 | <u>0.0251</u> | 0.0199 | <u>0.0160</u> |
| Ours | <u>0.0264</u> | <u>0.0188</u> | <u>0.0163</u> | 0.0358 | 0.0259 | 0.0234 | 0.0252 | <u>0.0188</u> | <u>0.0160</u> |
| Ours* | 0.0259 | 0.0184 | 0.0160 | <u>0.0354</u> | <u>0.0256</u> | <u>0.0233</u> | 0.0245 | 0.0182 | 0.0155 |
Table 1. Table 1: Static skeleton reconstruction comparison. Our methods achieves strong reconstruction fidelity across diverse out-of-domain static datasets. Ours utilizes uncertainty as selection score to select the best candidate from the 5 samples and outperforms all baselines on Articulation-XL 2.0 and Diverse-Pose. On ModelsResource, its zero-shot performance approaches that of RigAnything trained directly on the same dataset. See the "Baselines" paragraph for citations of these models.

Figure 4. Figure 4: Static Reconstruction. Numbers from top to bottom are J2J, J2B, and B2B for each instance. Compared with baselines, our model preserves finer geometric details and achieves more accurate mesh alignment.
4D Skeleton Reconstruction and Prediction
Our model naturally handles 4D reconstruction and prediction. For dynamic meshes, we study two settings. In 4D reconstruction, the full mesh sequence is observed with the goal of recovering a temporally consistent skeleton for every frame. In 4D prediction, only part of the sequence is observed and the model must infer the missing skeletons for interpolation, forecasting, or backcasting. Table 2 shows that FLOWRIG consistently outperforms the fine-tuned Puppeteer baseline Puppeteer-D* on both reconstruction accuracy and 4D consistency. As the temporal window increases, our model achieves lower J2J-W, J2B-W, and B2B-W errors, where W represents averaging over the time window, indicating more accurate per-frame skeleton reconstruction with stronger temporal context. More importantly, FLOWRIG maintains perfect structural consistency across the full sequence, with zero BND, GSD, and HD for all reported settings, meaning that the predicted bone count and kinematic topology remain stable over time. In contrast, Puppeteer-D* exhibits clear temporal degradation as grows, with increasing BND, BDD, GSD, and HD, indicating both geometric drift and topological flickering. The uncertainty-based selection in Ours* further improves reconstruction quality while preserving the same structural behavior, showing that FLOWRIG produces not only accurate per-frame skeletons but also temporally coherent 4D rigs. Figure 5a provides qualitative examples showing that our model preserves 4D consistency over time while also recovering finer skeletal details, such as the structure of the human hand. In addition, FLOWRIG supports 4D prediction, enabling interpolation, forecasting, and backcasting within a unified framework. Figure 5b presents qualitative evaluations of these settings and demonstrates FLOWRIG’s flexibility for downstream tasks. More qualitative results are shown in Appendix § 10 and the demo video.

Figure 5. Dynamic reconstruction and prediction. Blue indicates reconstruction with mesh guidance, while yellow indicates predictions without mesh guidance. In (b), from top to bottom, it shows interpolation, forecasting, and backcasting, respectively. Refer to the demo video for a clearer comparison.
| Method | J2J-W ↓ | J2B-W ↓ | B2B-W ↓ | BND ↓ | BDD ↓ | GSD ↓ | HD ↓ | |
| Puppeteer-D* | 4 | 0.0161 | 0.0130 | 0.0118 | 2.8279 | 0.0075 | 0.1189 | 6.2173 |
| Puppeteer-D* | 8 | 0.0162 | 0.0131 | 0.0118 | 2.8753 | 0.0091 | 0.1575 | 8.3745 |
| Puppeteer-D* | 24 | 0.0163 | 0.0132 | 0.0119 | 3.1763 | 0.0150 | 0.2654 | 14.1894 |
| Ours | 4 | 0.0161 | 0.0125 | 0.0104 | 0 | 0.0021 | 0 | 0 |
| Ours | 8 | 0.0152 | 0.0119 | 0.0099 | 0 | 0.0026 | 0 | 0 |
| Ours | 24 | 0.0142 | 0.0112 | 0.0093 | 0 | 0.0038 | 0 | 0 |
| Ours* | 4 | 0.0144 | 0.0112 | 0.0093 | 0 | 0.0019 | 0 | 0 |
| Ours* | 8 | 0.0144 | 0.0113 | 0.0094 | 0 | 0.0025 | 0 | 0 |
| Ours* | 24 | 0.0136 | 0.0107 | 0.0089 | 0 | 0.0037 | 0 | 0 |
Table 2. Dynamic quantitative comparisons on TexVerse dynamic dataset. is time window length. Puppeteer-D means we finetuned Puppeteer-diverse model (Song et al. [34]) on TexVerse training dataset. Ours utilizes uncertainty as selection score to select the best candidate from the 5 samples.
Further Analysis and Ablation Studies
Efficient Training Curriculum. We apply curriculum training: pre-train on large-scale static assets and fine-tune on dynamic sequences. Table 3 shows that static pre-training improves accuracy and reduces temporal instability compared with training on dynamic data alone. This suggests that large-scale static supervision provides a strong geometric prior for learning skeletal dynamics.
| Static | Dynamic | J2J-W | J2B-W | B2B-W | BDD | GSD |
| 0.0213 | 0.0173 | 0.0147 | 0.0049 | 0 | ||
| 0.0142 | 0.0112 | 0.0093 | 0.0038 | 0 |
Table 3. Ablation studies on data sources. Metrics are evaluated on the TexVerse test set with .
Ablation of the Graph Head. The graph head is introduced to maintain a temporally consistent kinematic hierarchy across the full 4D sequence. We evaluate its effect by replacing it with a simple 1-Nearest Neighbor tree-building heuristic. As shown in Table 4, removing the graph head significantly increases Hamming distance, indicating frequent topological changes and unstable parent assignments over time. The corresponding rise in GSD further shows that the graph head is essential for preserving structural coherence and avoiding topological flickering in dynamic rigging.
| Graph Head | GSD | HD |
| 0.0375 | 2.2844 | |
| 0 | 0 |
Table 4. Ablation studies on graph head. The metrics are evaluated on the TexVerse test set with time window .
Controllable Skeletal Complexity. A unique advantage of our flow-matching framework is the ability to explicitly control skeletal density via Classifier-Free Guidance. While our model can autonomously determine a plausible bone count through unconditional generation, it also supports bone-count conditioning as a user-defined input. This allows FLOWRIG to synthesize skeletons with arbitrary bone counts ranging from 1 to 128, providing direct and flexible control over the output granularity that is absent in existing autoregressive methods. As illustrated in Figure 6, FLOWRIG can adapt the skeletal detail to satisfy specific animation requirements, varying from sparse armatures for background characters to high-density rigs for complex manual dexterity, whereas other baselines remain restricted to a single, uncontrolled output density.

Figure 6. Analysis of bone count control. Our model can freely control the number of bones to adjust skeletal detail, while existing baselines do not provide this level of controllable output granularity.
Additional Notes. We report inference speed in Appendix § 8.§ 2, where FLOWRIG is faster than all baselines. We also develop a feedforward skinning model for downstream use in Appendix § 11, which is competitive with prior baselines.
Conclusion and Future Works
We propose FLOWRIG, a unified framework for 3D and 4D skeleton rigging from static meshes and dynamic mesh sequences. Built on flow matching, FLOWRIG generates temporally aligned skeletons while maintaining strong static reconstruction quality. By combining mesh-conditioned skeleton generation with a graph head for consistent topology and an uncertainty head for confidence-based sample selection, the model achieves competitive 3D performance and clear gains in 4D consistency and controllability. For future work, we plan to build stronger benchmarks for dynamic prediction under partial observations, extend the framework to jointly predict skinning weights and deformation, and introduce richer user controls such as semantic constraints or text-guided rig specification. We hope FLOWRIG serves as a step toward a more general and controllable rigger for 3D and 4D content.
Curated Dataset
TexVerse provides a large-scale collection of animated mesh-skeleton pairs (Zhang et al. [58]). However, the raw dataset is not limited to clean object-centric motions, and many sequences exhibit quasi-static motion, inconsistent temporal alignment, or incorrect skeleton annotations. To construct a reliable evaluation set, we first use Qwen3.5 (Qwen Team [30]) for preliminary filtering and then perform additional manual verification, resulting in 2,500 clean object-centric animated instances with correct mesh-skeleton alignment. The bone count distribution is shown in Figure S1. For training and evaluation, we divide into a train set with 2000 instances and a test set with 500 instances.

Figure S1. Bone Count Histogram of the filtered TexVerse dataset.
Training and model details
Mesh-to-token conditioning. We first sample surface points and normals from each input mesh to form point-cloud frames . We encode each frame independently using a off-the-shelf Michelangelo point-cloud VAE to obtain a compact set of mesh tokens [61]. Concretely, we flatten the sequence to and pass independently through the point cloud encoder. The resulting conditioning tokens are reshaped to . For partially observed sequences, we mask the tokens of unobserved frames and replace with a learnable token for all masked frames.
Model architecture. We use a DiT-L backbone with depth 24, hidden size , and 16 attention heads. Following the notation in the main method section, for each frame , the input token sequence concatenates (a) skeleton-slot tokens obtained by linearly projecting the 7D state to and (b) mesh conditioning tokens produced by the Michelangelo point-cloud VAE encoder. Here is the maximum number of skeleton slots, is the number of mesh tokens per frame, and is the sequence length. This yields a per-frame token set of size and a packed transformer stream of length . We employ an alternating attention schedule, denoted frame-global alternating, that interleaves frame-wise attention on frame-indexed sequences with global attention on the packed sequence, and we apply temporal RoPE using the frame index across the concatenated token stream.
Training auxiliary loss. The auxiliary loss includes geometry loss and temporal smooth loss. First, we apply the geometry loss to regularize the joints outside the mesh by including a signed distance (SD) penality term:
where is another hyperparameter for denoising-step-aware weight.
Second, to encourage coherent dynamics and reduce temporal jitter, we additionally apply lightweight temporal regularizers on slot sequences, including bone-length consistency across adjacent frames and velocity smoothness across frame triplets:
where denotes the slot tensor at frame , and and are the bone length and velocity smoothness coefficients. As a result, the total auxiliary loss is:
Curriculum training. In the first stage, we set and optimize the full objective with one-to-one matching. In the second stage, we train on variable-length windows and apply full-frame conditioning. In the third stage, we apply masked-conditioning mechanism: for each training sample we draw an observed index set and replace mesh tokens for unobserved frames with a mask token while injecting an observed-frame pooled summary into those positions. In practice, we increase the frequency of structured masks such as biasing the masking distribution toward structured patterns corresponding to forecasting and backcasting, including forecast masks with , backcast masks with , both-ends masks with , and full observation with . These strategies align the training distribution with inference-time use cases without changing the underlying objective.
Optimization and guidance. We optimize the model with AdamW under mixed precision using bf16, together with cosine learning-rate decay and warmup. We set the starting learning rate to , , for the three training stages of static reconstruction, dynamic reconstruction, and dynamic prediction. Skeleton-count conditioning is trained with classifier-free guidance by dropping the count label with probability , which forces the model to predict the reasonable skeleton count when no bone count guidance is provided. At inference time we apply CFG with scale to control the trade-off between fidelity and diversity.
Evaluation Details
Evaluation Metrics
Temporal topological consistency. We evaluate temporal topology with graph structure distance (GSD). Following the notation in the main method, each sequence contains frames and each frame is represented by at most skeleton slots. For methods without persistent slots, we first recover per-frame predicted skeletons and use the sequence-level Hungarian assignment defined in § 3 to establish bone correspondence across time. Let denote the set of matched and existing bones in the anchor frame , and let .
For each frame , let denote the parent index of matched bone . We compare the predicted topology at frame against the anchor-frame topology using the Hamming distance
and normalize it to obtain the per-frame graph structure distance
We then report the sequence-level averages
For fixed-slot methods, the same definition applies directly because slot correspondence is given by the slot index.
Bone displacement deviation (BDD). We evaluate temporal geometric stability with bone displacement deviation (BDD). Using the same correspondence set , let denote the length of matched bone at frame . We measure how much each corresponding bone deviates from its anchor-frame length and average over all matched bones and non-anchor frames:
This correspondence-based definition ensures that BDD is computed on aligned bones rather than unmatched slots.
Inference Details
To accurately evaluate the model performance, we sample 5 times for each instance and report the average evaluation metrics to reduce the variance of the metrics.
Inference Time. We compare average inference times among baselines. FLOWRIG requires 1.1s for single-mesh inference. As shown in Table S1, it is 3.5× faster than Pinocchio, 4.1× faster than RigNet, 2.6× faster than UniRig, 2.2× faster than MagicArticulate, and 1.4× faster than Puppeteer. Table S2 further shows how inference time scales with the temporal window size. These results indicate that FLOWRIG remains efficient for single-frame 3D rigging while scaling reasonably to longer 4D windows.
| Method | Pinocchio | RigNet | UniRig | MagicArti. | Puppeteer | Ours |
| Inference time (s) | 3.9 | 4.5 | 2.9 | 2.4 | 1.5 | 1.1 |
Table S1. Comparison of inference time of skeleton generation on static mesh.
| Time window size | 1 | 2 | 4 | 8 | 16 | 24 |
| Inference Time (s) | 1.1 | 1.7 | 2.2 | 4.4 | 11.9 | 23.4 |
Table S2. Inference time performance across different frame counts.
More Quantitative Rigging Results
Generalization and Per-Sequence Optimization Comparison
Data. To evaluate the generalization capability of FlowRIG in dynamic reconstruction, we built a second dynamic evaluation set from Objaverse Deitke et al. [9], a different source from the TexVerse data the model trains on, using the same VLM pre-filter, manual verification, and quality predicates detailed in Appendix § 6. This new dataset contains 1,656 verified animated instances across ten categories. Details of the per-category breakdown can be seen in Table S3.
| Category | Share | |
| bipedal mammal | 453 | 27.4% |
| fish | 301 | 18.2% |
| bird | 204 | 12.3% |
| dinosaur | 193 | 11.7% |
| quadruped mammal | 183 | 11.1% |
| insect | 154 | 9.3% |
| crustacean | 62 | 3.7% |
| arachnid | 58 | 3.5% |
| amphibian | 35 | 2.1% |
| mollusk | 13 | 0.8% |
| Total | 1,656 | 100% |
Table S3. Category composition of the new Objaverse-derived 4D evaluation set. No instance of this set is used for training; the model is trained only on the TexVerse split described in Appendix § 6.
Per-Sequence Optimization Baseline. To perform a more comprehensive evaluation of FlowRIG in dynamic reconstruction, we include a per-sequence optimization 4D baseline, RigGS Yao et al. [48]. This model takes video as input and produces a skeleton together with 3D Gaussians, so we render each mesh sequence to video and supply the ground-truth masks its pipeline requires. Additionally, its output lives in its own coordinate frame, so we align the generated skeleton to the ground truth in scale, position, and orientation before computing metrics. Both steps are concessions in RigGS’s favour.
Experiment Setup. RigGS optimizes every sequence from scratch and takes 17 minutes per 8-frame instance on an H200, so running it on the full 1,656-instance Objaverse set of W3 would cost 469 H200 GPU hours, against about 2 GPU hours for FlowRIG. We therefore sample up to 20 instances per category, giving 193 instances across the ten categories and roughly 57 H200 GPU hours. All methods are evaluated on the same subsample at .
Results. We conclude the following based on the results in Table S4, Table S5, and Table S6:
| Category | Puppeteer-D* | RigGS | Ours | Ours* | |
| amphibian | 20 | 0.0524 | 0.0675 | 0.0389 | 0.0361 |
| arachnid | 20 | 0.0503 | 0.0567 | 0.0474 | 0.0468 |
| bipedal mammal | 20 | 0.0291 | 0.0536 | 0.0238 | 0.0222 |
| bird | 20 | 0.0759 | 0.0699 | 0.0627 | 0.0646 |
| quadruped mammal | 20 | 0.0722 | 0.0686 | 0.0564 | 0.0540 |
| crustacean | 20 | 0.0695 | 0.0637 | 0.0560 | 0.0558 |
| dinosaur | 20 | 0.0644 | 0.0653 | 0.0554 | 0.0619 |
| fish | 20 | 0.0733 | 0.0513 | 0.0515 | 0.0525 |
| insect | 20 | 0.0692 | 0.0632 | 0.0591 | 0.0571 |
| mollusk | 13 | 0.0784 | 0.0758 | 0.0663 | 0.0623 |
| MACRO (mean of 10) | 193 | 0.0635 | 0.0636 | 0.0517 | 0.0513 |
| MICRO (instance-weighted) | 193 | 0.0629 | 0.0631 | 0.0512 | 0.0509 |
Table S4. Per-category J2J on the Objaverse ([9]) 4D evaluation set. Stratified subsample, . Bold is best in the row, underlined second best. MACRO averages the ten categories equally, MICRO weights by instance count.
| Category | Puppeteer-D* | RigGS | Ours | Ours* | |
| amphibian | 20 | 0.0439 | 0.0535 | 0.0289 | 0.0272 |
| arachnid | 20 | 0.0406 | 0.0423 | 0.0323 | 0.0316 |
| bipedal mammal | 20 | 0.0233 | 0.0391 | 0.0183 | 0.0171 |
| bird | 20 | 0.0647 | 0.0560 | 0.0507 | 0.0520 |
| quadruped mammal | 20 | 0.0594 | 0.0558 | 0.0432 | 0.0400 |
| crustacean | 20 | 0.0573 | 0.0475 | 0.0416 | 0.0408 |
| dinosaur | 20 | 0.0553 | 0.0525 | 0.0461 | 0.0523 |
| fish | 20 | 0.0589 | 0.0379 | 0.0385 | 0.0381 |
| insect | 20 | 0.0583 | 0.0476 | 0.0469 | 0.0444 |
| mollusk | 13 | 0.0640 | 0.0589 | 0.0535 | 0.0484 |
| MACRO (mean of 10) | 193 | 0.0526 | 0.0491 | 0.0400 | 0.0392 |
| MICRO (instance-weighted) | 193 | 0.0522 | 0.0487 | 0.0395 | 0.0388 |
Table S5. Per-category J2B. Same protocol and conventions as Table S4.
| Category | Puppeteer-D* | RigGS | Ours | Ours* | |
| amphibian | 20 | 0.0399 | 0.0467 | 0.0258 | 0.0237 |
| arachnid | 20 | 0.0368 | 0.0369 | 0.0276 | 0.0268 |
| bipedal mammal | 20 | 0.0203 | 0.0367 | 0.0150 | 0.0138 |
| bird | 20 | 0.0588 | 0.0496 | 0.0437 | 0.0440 |
| quadruped mammal | 20 | 0.0506 | 0.0511 | 0.0372 | 0.0348 |
| crustacean | 20 | 0.0506 | 0.0421 | 0.0384 | 0.0372 |
| dinosaur | 20 | 0.0480 | 0.0455 | 0.0388 | 0.0453 |
| fish | 20 | 0.0453 | 0.0314 | 0.0320 | 0.0307 |
| insect | 20 | 0.0529 | 0.0424 | 0.0413 | 0.0383 |
| mollusk | 13 | 0.0563 | 0.0521 | 0.0473 | 0.0422 |
| MACRO (mean of 10) | 193 | 0.0459 | 0.0435 | 0.0347 | 0.0337 |
| MICRO (instance-weighted) | 193 | 0.0456 | 0.0431 | 0.0343 | 0.0334 |
Table S6. Per-category B2B. Same protocol and conventions as Table S4.
FlowRIG leads in 28 of the 30 category-metric cells. In aggregate, Ours* is 19.3% below RigGS and 19.2% below Puppeteer-D* on MACRO J2J, 20.2% and 25.5% below on J2B, and 22.5% and 26.6% below on B2B; MICRO gives the same picture. The two exceptions are fish on J2J and J2B, where RigGS leads by 0.4% and 0.5%, plausibly because fish motion is smooth and low in degrees of freedom, which suits per-sequence fitting.
Per-sequence optimization is not uniformly stronger than a fine-tuned static rigger. RigGS and Puppeteer-D* are level on MACRO J2J (0.0636 vs. 0.0635), and RigGS leads only on J2B and B2B (6.7% and 5.2%). Optimizing each sequence individually does not by itself buy joint accuracy.
The cost gap is over two orders of magnitude. RigGS needs 17 minutes per 8-frame instance where FlowRIG needs 4.4s in a single feedforward pass (Table S2), roughly 230 times faster, which is what makes evaluation at the scale of the full set practical at all.
More Qualitative Rigging Results
More static and dynamic instances are shown in Figure S2 and Figure S3, respectively.

Figure S2. More comparsion on static reconstruction.

Figure S3. More dynamic reconstruction results.
Skinning Model
To animate mesh by the generated skeleton, we additionally train an attention-based skinning network, denoted SkinningTransformer, to predict soft skinning weights from a mesh observation and its associated skeletal rig. Given a mesh and a rig with joints, our goal is to predict, for each queried surface point , a categorical distribution over valid joints. Each sample contains sampled query points with normals, a padded bone tensor storing parent and child joint coordinates for each bone slot, a validity mask over joint slots, and a ground-truth skinning distribution over valid joints. Formally, for a query point we model
where is the queried point-and-normal feature, denotes the frozen mesh encoders, and denotes the skeletal graph structure.
Frozen geometry encoders. We condition the skinning model on two frozen geometry pathways. First, a Michelangelo shape encoder (Zhao et al., [61]) produces a compact set of global shape tokens . Second, the PartField encoder (Liu et al., [24]) produces dense query features on sampled surface locations, , where is the number of sampled surface queries and denotes the frozen part-aware field encoder. When skeleton-side part features are enabled, we also evaluate this field at the parent and child joint locations of bone and average them per bone,
These encoders remain frozen throughout training.
Shape-skeleton fusion encoder. All conditioning features are projected into a shared transformer width . Let denote the padded bone tensor, where each row stores the concatenated parent and child joint coordinates of one bone. The learned projection matrices satisfy , , , and . We form projected shape and bone tokens as
where is a learnable positional embedding for bone slots and the last term is optional. The encoder input is then
A stack of transformer encoder blocks updates , while invalid joint slots are masked so that padded joints do not participate in attention.
Topology-aware joint attention. To encode skeletal structure explicitly, we inject a topology-aware bias into self-attention over the bone tokens [34]. Let denote the pairwise graph-distance matrix on the skeleton. Distances are clamped into a small set of buckets and projected into per-head biases. The attention score for head , with query/key head dimension , becomes
for bone-token indices and . This topology-aware joint attention encourages joints that are nearby in the kinematic tree to exchange information more strongly.
Point-wise cross-attention decoder. Surface query tokens are initialized from projected part-aware point features,
Optionally, Fourier positional encodings of the queried coordinates and normals are added to these tokens. The decoder then refines point tokens purely through cross-attention to the encoder memory. There is no decoder self-attention; interaction among queries is mediated through the shared shape-skeleton memory.
Scaled cosine prediction head. The final logits are computed by cosine similarity between normalized point embeddings and normalized joint embeddings, scaled by a learnable factor , where is the logit for assigning query point to joint .
Invalid joint logits are masked before normalization, and skinning probabilities are obtained by
This design makes the prediction explicitly probabilistic and naturally handles variable valid-joint sets through masking.
Training objective. We optimize the skinning network with a masked soft cross-entropy objective together with an loss in probability space. Let denote the target weight distributions and let denote the predicted logits. The overall loss is
where is the joint-validity mask, denotes the row-wise softmax operation, and is the weight on the probability-space loss. Only the SkinningTransformer parameters are updated during training; all mesh encoders remain frozen.
Evaluation protocol. At test time, predictions on sampled query points are transferred to mesh vertices through nearest-neighbor interpolation or Gaussian-weighted -NN blending. Optional post-processing suppresses low-confidence weights and enforces a sparse set of active joints per vertex. This produces the final per-vertex skinning weights used for downstream deformation and evaluation.
Experiments. Table S7 shows that our skinning model achieves the strongest overall performance across the evaluated datasets. On Articulation-XL2.0 and Diverse-pose, it obtains the best precision, recall, and L1 error, indicating more accurate and more complete skinning weight prediction. On ModelsResource, our method achieves the best precision and remains competitive in L1 error. Overall, these results suggest that the proposed skinning model generalizes well across diverse object categories and preserves strong prediction quality in both in-domain and out-of-domain settings. Figure S4 shows qualitative results.
| Method | Articulation-XL2.0 | ModelsResource | Diverse-pose | ||||||
| Prec. ↑ | Rec. ↑ | L1 ↓ | Prec. ↑ | Rec. ↑ | L1 ↓ | Prec. ↑ | Rec. ↑ | L1 ↓ | |
| RigNet | 73.7% | 66.1% | 0.729 | 65.7% | 80.2% | 0.707 | 74.7% | 65.4% | 0.746 |
| MagicArti. | 74.6% | 71.3% | 0.451 | 68.1% | 80.7% | 0.642 | 74.9% | 68.4% | 0.479 |
| Puppeteer | 87.6% | 74.0% | 0.335 | 79.7% | 81.6% | 0.443 | 83.6% | 72.2% | 0.405 |
| Puppeteer-D | 87.9% | 73.8% | 0.333 | 79.8% | 81.5% | 0.442 | 86.4% | 72.8% | 0.353 |
| Ours | 89.7% | 75.0% | 0.311 | 81.8% | 76.2% | 0.449 | 88.3% | 73.6% | 0.348 |
Table S7. Quantitative comparison of skinning weight prediction. Precision (Prec.) and Recall (Rec.) quantify the accuracy and coverage of joint influence regions, respectively, where higher values (↑) denote superior performance. Numerical fidelity is assessed via the mean error, where lower values (↓) indicate closer alignment with the ground truth.

Figure S4. Qualitative results of our skinning model.
References
- [3]Ilya Baran and Jovan Popović. Automatic rigging and animation of 3d characters. ACM Transactions on graphics (TOG), 26(3):72–es, 2007.
- [4]Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European conference on computer vision, pp. 213–229. Springer, 2020.arxiv.org/abs/2005.12872
- [7]Mosam Dabhi, Simon Lucey, and László A Jeni. Rat4d: Rig and animate objects without surface templates in 4d. In 2026 IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), pp. 393–401. IEEE, 2026.DOI
- [9]Matt Deitke, Dustin Schwenk, Jordi Salvador, Luca Weihs, Oscar Michel, Eli VanderBilt, Ludwig Schmidt, Kiana Ehsani, Aniruddha Kembhavi, and Ali Farhadi. Objaverse: A universe of annotated 3d objects. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 13142–13153, 2023.
- [10]Yufan Deng, Yuhao Zhang, Chen Geng, Shangzhe Wu, and Jiajun Wu. Anymate: A dataset and baselines for learning 3d object rigging. In Proceedings of the Special Interest Group on Computer Graphics and Interactive Techniques Conference Conference Papers, pp. 1–10, 2025.
- [13]Zhiyang Guo, Ori Zhang, Jax Xiang, Alan Zhao, Wengang Zhou, and Houqiang Li. Make-it-poseable: Feed-forward latent posing model for 3d humanoid character animation. arXiv e-prints, pp. arXiv–2512, 2025.
- [14]Yi-Hua Huang, Zi-Xin Zou, Yuting He, Chirui Chang, Cheng-Feng Pu, Ziyi Yang, Yuan-Chen Guo, Yan-Pei Cao, and Xiaojiao Qian. Anigen: Unified S³ fields for animatable 3d asset generation. arXiv preprint arXiv:2604.08746, 2026.
- [16]Taeyeon Kim, Youngju Na, Jumin Lee, Sebin Lee, Minhyuk Sung, and Sung-Eui Yoon. Morphgs: Morphology-adaptive articulated 3d motion transfer from videos. In European Conference on Computer Vision, pp. 210–229. Springer, 2026.
- [17]Xuan Li, Qianli Ma, Tsung-Yi Lin, Yongxin Chen, Chenfanfu Jiang, Ming-Yu Liu, and Donglai Xiang. Articulated kinematics distillation from video diffusion models. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 17571–17581. IEEE, 2025.arxiv.org/abs/2504.01204
- [23]Isabella Liu, Zhan Xu, Wang Yifan, Hao Tan, Zexiang Xu, Xiaolong Wang, Hao Su, and Zifan Shi. Riganything: Template-free autoregressive rigging for diverse 3d assets. ACM Transactions on Graphics (TOG), 44(4):1–12, 2025a.DOI
- [24]Minghua Liu, Mikaela Angelina Uy, Donglai Xiang, Hao Su, Sanja Fidler, Nicholas Sharp, and Jun Gao. Partfield: Learning 3d feature fields for part segmentation and beyond. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pp. 9704–9715. IEEE, 2025b.arxiv.org/abs/2504.11451
- [25]Hexiao Lu, Xiaokun Sun, Zeyu Cai, Hao Guo, Ying Tai, Jian Yang, and Zhenyu Zhang. Muses: Designing, composing, generating nonexistent fantasy 3d creatures without training. arXiv preprint arXiv:2601.03256, 2026.arxiv.org/abs/2601.03256
- [27]Sanjeev Muralikrishnan, Niladri Shekhar Dutt, and Niloy J Mitra. Smf: Template-free and rig-free animation transfer using kinetic codes. arXiv preprint arXiv:2504.04831, 2025.DOI
- [29]Alexander Quinn Nichol and Prafulla Dhariwal. Improved denoising diffusion probabilistic models. In International conference on machine learning, pp. 8162–8171. PmLR, 2021.arxiv.org/abs/2102.09672
- [30]Qwen Team. Qwen3.5: Towards native multimodal agents, February 2026. URL https://qwen.ai/blog?id=qwen3.5.
- [33]Remy Sabathier, David Novotny, Niloy J Mitra, and Tom Monnier. Actionmesh: Animated 3d mesh generation with temporal 3d diffusion. arXiv preprint arXiv:2601.16148, 2026.arxiv.org/abs/2601.16148
- [34]Chaoyue Song, Xiu Li, Fan Yang, Zhongcong Xu, Jiacheng Wei, Fayao Liu, Jiashi Feng, Guosheng Lin, and Jianfeng Zhang. Puppeteer: Rig and animate your 3d models. Advances in neural information processing systems, 38:72152–72184, 2025a.
- [35]Chaoyue Song, Jianfeng Zhang, Xiu Li, Fan Yang, Yiwen Chen, Zhongcong Xu, Jun Hao Liew, Xiaoyang Guo, Fayao Liu, Jiashi Feng, et al. Magicarticulate: Make your 3d models articulation-ready. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 15998–16007. IEEE, 2025b.arxiv.org/abs/2502.12135
- [36]Mingze Sun, Shiwei Mao, Keyi Chen, Yurun Chen, Shunlin Lu, Jingbo Wang, Junting Dong, and Ruqi Huang. Armo: Autoregressive rigging for multi-category objects. In 2025 IEEE/CVF International Conference on Computer Vision (ICCV), pp. 7721–7730. IEEE, 2025a.arxiv.org/abs/2503.20663
- [38]Jiaxin Wang, Dongxin Lyu, Zeyu Cai, Zhiyang Dou, Cheng Lin, Anpei Chen, and Yuliang Xiu. Gaussianimate: Reconstruct and rig animatable categories with level of dynamics. arXiv preprint arXiv:2604.08547, 2026a.arxiv.org/abs/2604.08547
- [39]Ruipeng Wang, Langkun Zhong, and Miaowei Wang. Sprig: Self-supervised pose-invariant rigging from mesh sequences. arXiv preprint arXiv:2602.12740, 2026b.arxiv.org/abs/2602.12740
- [41]Lifan Wu, Ruijie Zhu, Yubo Ai, and Tianzhu Zhang. Skeletongaussian: Editable 4d generation through gaussian skeletonization. arXiv preprint arXiv:2602.04271, 2026.arxiv.org/abs/2602.04271
- [43]Tianyi Xie, Yunuo Chen, Yaowei Guo, Yin Yang, Bolei Zhou, Demetri Terzopoulos, Ying Jiang, and Chenfanfu Jiang. Animimic: Imitating 3d animation from video priors. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 40266–40276, 2026.arxiv.org/abs/2512.14133
- [45]Yuanyou Xu, Zongxin Yang, and Yi Yang. Skdream: Controllable multi-view and 3d generation with arbitrary skeletons. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 314–325. IEEE, 2025.DOI
- [46]Zhan Xu, Yang Zhou, Evangelos Kalogerakis, Chris Landreth, and Karan Singh. Rignet: Neural rigging for articulated characters. arXiv preprint arXiv:2005.00559, 2020.arxiv.org/abs/2005.00559
- [48]Yuxin Yao, Zhi Deng, and Junhui Hou. Riggs: Rigging of 3d gaussians for modeling articulated objects in videos. In 2025 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 5592–5601. IEEE, 2025b.arxiv.org/abs/2503.16822
- [55]Hao Zhang, Jiahao Luo, Bohui Wan, Yizhou Zhao, Zongrui Li, Michael Vasilkovsky, Chaoyang Wang, Jian Wang, Narendra Ahuja, and Bing Zhou. Rigmo: Unifying rig and motion learning for generative animation. arXiv preprint arXiv:2601.06378, 2026a.arxiv.org/abs/2601.06378
- [56]Jia-Peng Zhang, Cheng-Feng Pu, Meng-Hao Guo, Yan-Pei Cao, and Shi-Min Hu. One model to rig them all: Diverse skeleton rigging with unirig. ACM Transactions on Graphics (ToG), 44(4):1–18, 2025a.arxiv.org/abs/2504.12451
- [57]Jia-peng Zhang, Cheng-Feng Pu, Meng-Hao Guo, Yan-Pei Cao, and Shi-Min Hu. Skin tokens: A learned compact representation for unified autoregressive rigging. arXiv preprint arXiv:2602.04805, 2026b.DOI
- [58]Yibo Zhang, Li Zhang, Rui Ma, and Nan Cao. Texverse: A universe of 3d objects with high-resolution textures. arXiv preprint arXiv:2508.10868, 2025b.arxiv.org/abs/2508.10868
- [59]Ruisi Zhao, Haoren Zheng, Zongxin Yang, Hehe Fan, and Yi Yang. Stroke3d: Lifting 2d strokes into rigged 3d model via latent diffusion models. arXiv preprint arXiv:2602.09713, 2026.arxiv.org/abs/2602.09713
- [61]Zibo Zhao, Wen Liu, Xin Chen, Xianfang Zeng, Rui Wang, Pei Cheng, Bin Fu, Tao Chen, Gang Yu, and Shenghua Gao. Michelangelo: Conditional 3d shape generation based on shape-image-text aligned latent representation. Advances in neural information processing systems, 36:73969–73982, 2023b.arxiv.org/abs/2306.17115

