acceptodds
Under review as a conference paper at ICLR 2027

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 and 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.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Automatic Rigging, Skeleton Generation, Flow Matching, Mesh, 3D Character Animation

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_M2mVOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

FlowRig proposes a unified framework for skeleton generation from static meshes and dynamic mesh sequences. A mesh-conditioned flow-matching transformer jointly predicts bone slots across frames, while a temporally pooled graph head predicts shared parent assignments. The framework also incorporates bone-count conditioning, uncertainty-based candidate selection, and masked conditioning for interpolation, forecasting, and backcasting. Training proceeds from static reconstruction to dynamic reconstruction and then partially observed sequence prediction. Validation includes static rigging benchmarks, dynamic reconstruction on a curated TexVerse split, an Objaverse-derived evaluation subset with a RigGS comparison, and ablations of static pretraining and the graph head. The reported results demonstrate improvements in reconstruction accuracy and temporal consistency. Prediction and bone-count control are primarily supported by qualitative examples.

Critical strengths
  1. Meaningful reconstruction improvements across several evaluations. In Table 1, Ours reduces Articulation-XL 2.0 J2J from Puppeteer's 0.0311 to 0.0264, approximately a 15.1% improvement, without uncertainty-based best-of-five selection. In Table 2, at a 24-frame window, B2B-W decreases from 0.0119 for the fine-tuned Puppeteer baseline to 0.0093. Appendix D further includes a per-sequence optimization baseline on a shared 193-instance evaluation subset: Ours* obtains macro J2J of 0.0513 versus 0.0636 for RigGS. These results give the work substantive empirical value beyond its qualitative demonstrations.

  2. A useful unified formulation supported by evidence for static-to-dynamic transfer. Jointly predicting skeletons across time addresses an important limitation of applying static riggers independently to each frame. The same representation accommodates static inputs and partially observed sequences, making the framework potentially useful for animation workflows. Table 3 provides direct evidence for the benefit of static pretraining: dynamic J2J-W improves from 0.0213 to 0.0142. This is consequential given the limited availability of paired dynamic mesh-skeleton supervision.

Critical weaknesses

The distinct benefits of the unified framework are insufficiently established. RigMo already supports rig inference from mesh sequences and masked-frame motion generation, while AniGen combines flow matching with joint-density conditioning and CFG. FlowRig's explicit bone-slot representation and unified tasks may add value, but the evidence mainly establishes reconstruction gains: prediction and count control remain largely qualitative, and Table 3 demonstrates the benefit of static pretraining rather than the specific three-stage curriculum. This leaves the contribution beyond closely related work unclear.

Questions for authors
  1. Contribution: What distinct benefits does FlowRig provide beyond RigMo and AniGen, and which ablations isolate the value of its unified formulation and three-stage curriculum?

  2. Validation: Can you report missing-frame prediction errors against simple interpolation/extrapolation baselines, together with exact bone-count success rates?

5 comments

Thanks so much for your insightful questions and valuable feedback! We address each of them in detail below. Also, the updated supplementary video includes new animations and in-the-wild results, and we sincerely hope the reviewer could take a look.

[W1, Q1] Benefits over RigMo and AniGen, and ablations [Part 1/2]

We are grateful for your insightful question and helpful feedback.

(1) Distinct benefits over RigMo and AniGen. The three methods address different problems: RigMo [A] discovers a rig from the deformation of a mesh sequence without rig labels, AniGen [B] generates a new animatable asset from an image, and FlowRig rigs a given mesh or mesh sequence with an artist-style skeleton. Table C1 lists which capabilities each method supports.

Table C1: Capability comparison of FlowRig, RigMo and AniGen.

capabilityFlowRigRigMo [A]AniGen [B]
feedforward 4D rigging✓✓✗ feedforward on static; 4D rigging requires per-scene optimization of the first-frame rig
no vertex correspondence needed✓✗ needs vertex trajectoriesn/a
artist-style skeleton (joints, one kinematic tree)✓ same joints, count and tree in every frame (Table 2)✗ Gaussian bones (a specialized representation with center, scale, orientation)✓ static only
bone-count control✓✓ number $K$ of Gaussian bonescoarse: 5 density levels (auto, 10, 15, 25, 35 joints)
skeletons of unobserved frames✓ interpolation, forecasting, backcasting; quantified (Tables C3, C2b)✗✗

FlowRig is the only one of the three that supports every row. The main differences:

  • Count control at single-bone granularity. FlowRig takes the bone count itself as the condition, so our model can give fine-grained control with details in Table C4 below. In comparison, AniGen offers five coarse density levels [B].
  • Any given mesh or mesh sequence. FlowRig needs neither a rig nor vertex correspondence, so it applies to single meshes and to sequences re-meshed or reconstructed per frame. RigMo needs vertex trajectories, and AniGen does not take an input mesh.
  • A persistent artist-style skeleton. FlowRig outputs joints and one kinematic tree that persist over the sequence, as used by animation tools and rigging benchmarks; it uses all frames, which lowers its error on a given frame (Table B1 in our reply to Reviewer QgQD), and predicts unobserved frames (Table C3). RigMo's Gaussian bones are not joints in a tree, so J2J, J2B, and B2B do not apply to them, and AniGen's rig is static.

[W1, Q1] Benefits over RigMo and AniGen, and ablations [Part 2/2]

(2) Ablations of the curriculum and of the unified formulation. In the paper, Table 3 isolates static pretraining, the step that transfers the geometric prior from large static data to the limited 4D data. As suggested, Tables C2a and C2b now isolate each stage, each evaluated on the capability it adds: Stage 1 on static rigging, Stage 2 on consistent 4D reconstruction, Stage 3 on predicting unobserved frames.

Table C2a: Curriculum ablation under full observation, TexVerse test set (T=24). IDret as defined in Appendix I. FlowRig rows use slots as identity; the frame-by-frame row links bones across frames by Hungarian matching. Lower is better, except IDret.

trainingJ2J-WBDDIDret (%) bones / fingers
Stage 1 only (static model), frame by frame0.02760.010480.9 / 57.4
Stage 2 only (no Stage 1)0.02130.005299.3 / 85.2
Stage 1 -> 2 (Table 2 model)0.01420.004199.8 / 95.8

Table C2b: Curriculum ablation for prediction: J2J on the unobserved frames, TexVerse test set (T=24). Interp. 1/k: every k-th frame observed; forecast / backcast: the first / last half of the clip observed. Zero-shot: masks applied at test time to a model never trained with masks. Lower is better.

trainingJ2J: interp. 1/2J2J: interp. 1/4J2J: interp. 1/8J2J: forecastJ2J: backcast
Stage 2 only (no Stage 1), zero-shot0.03180.04340.05170.05040.0487
Stage 1 -> 2 (Table 2 model), zero-shot0.03160.04340.04980.04740.0454
Stage 1 -> 2 -> 30.01930.02330.03680.03850.0373

Each stage adds one capability.

  • Stage 1 gives the geometric prior. Without it, the 4D model's J2J-W is 50% higher, as shown in Table C2a.
  • Stage 2 gives a consistent 4D skeleton. Without it, the bone length (BDD) drifts and identity (IDret) is not well learned, as shown in Table C2a. Additionally, skeleton generation conditioned on a full motion sequence improves the rigging of a single frame as seen in Tables A1 and A2 under the reply to pXUc.
  • Stage 3 gives prediction. With masked training, Stage 3 lowers the error in interpolation, forecasting and backcasting tasks, as shown in Table C2b.

We are happy to discuss any further questions on these comparisons or ablations.

[A] Zhang et al. RigMo: Unifying Rig and Motion Learning for Generative Animation. arXiv:2601.06378, 2026.
[B] Huang et al. AniGen: Unified S^3 Fields for Animatable 3D Asset Generation. arXiv:2604.08746, 2026.

[Q2] Prediction baselines and exact bone-count success rates

We appreciate your question and valuable suggestions! As suggested, we report both.

(1) Prediction. We compare with the standard naive baseline of motion in-betweening, interpolation [C], applied to the strongest baseline of Table 2: Puppeteer-D* rigs every observed frame, and the unobserved frames are filled by interpolating between the two nearest keyframes (constant-velocity extrapolation for forecasting and backcasting).

Table C3: Skeleton error on unobserved frames (4D prediction), TexVerse test set; the same as Table A5 in our reply to Reviewer pXUc. J2J-P / B2B-P; lower is better. Interp. 1/k: every k-th frame of a T=24 clip observed; forecast / backcast: the first / last 4 frames of a T=8 clip observed. "w/o Stage 3": the same model before masked training.

settingPuppeteer-D* + interpolation: J2J-P / B2B-PFlowRig w/o Stage 3: J2J-P / B2B-PFlowRig: J2J-P / B2B-P
Interp. 1/20.0200 / 0.01460.0307 / 0.02390.0181 / 0.0125
Interp. 1/40.0253 / 0.01880.0426 / 0.03240.0220 / 0.0157
Interp. 1/80.0370 / 0.02840.0491 / 0.03720.0357 / 0.0267
Forecast0.0374 / 0.02860.0461 / 0.03440.0365 / 0.0272
Backcast0.0368 / 0.02860.0441 / 0.03350.0349 / 0.0263

FlowRig is the most accurate predictor in every setting compared with Puppeteer-D* and the same model before masked training.

(2) Exact bone-count success. We report how often the generated skeleton has exactly the requested number of bones, with the ground-truth count as target.

Table C4: Bone-count control accuracy, on Articulation-XL2.0 (AX) / ModelsResource (MR) / Diverse-Pose (DP). Target: the ground-truth count.

CFG scale sexact (%) AX / MR / DPwithin ±1 bones (%)within ±2 bones (%)MAE (bones)
191.5 / 87.1 / 95.095.0 / 95.2 / 97.696.5 / 98.1 / 98.90.35 / 0.23 / 0.12
393.5 / 87.4 / 95.996.8 / 96.4 / 98.198.3 / 99.1 / 99.60.17 / 0.17 / 0.07
590.9 / 83.1 / 93.396.0 / 95.3 / 97.298.2 / 99.0 / 99.00.20 / 0.23 / 0.11

At these common guidance scales, 83% to 95% of skeletons have exactly the ground-truth count on the three test sets and at least 95% are within one bone. In comparison, AniGen controls the joint count indirectly, through a density condition with five coarse levels [B].

We hope these results answer the question, and we are open to further discussion.

[B] Huang et al. AniGen: Unified S^3 Fields for Animatable 3D Asset Generation. arXiv:2604.08746, 2026.
[C] Harvey et al. Robust Motion In-betweening. ACM TOG 39(4), 2020.

Reviewer_QgQDOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces FlowRig, a unified flow-matching framework for 3D and 4D skeleton generation. The framework incorporates graph and uncertainty heads to support skeleton prediction, with a shared graph intended to maintain consistent connectivity across frames. To address the scarcity of 4D supervision, the authors construct a medium-scale 4D rigging dataset from large-scale 3D rigging data. Experiments demonstrate competitive static 3D rigging performance, controllable skeletal complexity, and promising results on temporally consistent 4D skeleton reconstruction and prediction.

Critical strengths
  1. The flow-matching formulation is a reasonable alternative to autoregressive skeleton generation, offering potential benefits in inference efficiency and control over skeletal complexity.

  2. Sharing a graph across frames is a sensible design for enforcing consistent skeletal connectivity throughout a sequence. Sequence-level Hungarian matching provides a reasonable mechanism for establishing correspondences across the sequence.

  3. Controlling the number of bones supports skeleton generation at different levels of detail, which is useful for applications with different complexity requirements.

Critical weaknesses
  1. The practical motivation for directly rigging 4D meshes requires further clarification. Conventional graphics pipelines typically rig and skin a static mesh in an A- or T-pose, then animate it to produce mesh sequences and the corresponding skeletons. The paper should explain how FlowRig relates to this workflow and identify applications in which the input is an unrigged mesh sequence rather than an already rigged character. This would help establish the specific value of the proposed 4D task.

  2. Consistent joint counts and connectivity do not necessarily imply consistent joint identities. For example, exchanging the identities of structurally similar finger chains can preserve the number of joints and graph topology while producing incorrect temporal correspondences. Although sequence-level matching is a relevant design choice, the paper lacks a direct evaluation of joint-identity consistency. Such errors could substantially affect downstream skinning-weight estimation and motion transfer.

  3. The methodological novelty appears relatively incremental. The transport-based formulation for skeleton generation is interesting, but the paper would benefit from a clearer explanation of which technical components are new and why they are specifically necessary for dynamic skeleton generation. Stronger evidence of the practical value of this task would also strengthen the contribution.

Questions for authors

See Weaknesses.

4 comments

We appreciate your thoughtful questions and suggestions! We answer them in detail below. Also, we updated the supplementary video with new animations and in-the-wild results, and we sincerely hope the reviewer could take a look.

[W1] Why rig mesh sequences

Thank you for this helpful comment and suggestions. Sec. 1 of the paper motivates 4D rigging by the growing number of 4D meshes produced by reconstruction and generation pipelines. As suggested, we relate FlowRig to the conventional workflow and name applications whose input is an unrigged mesh sequence in (1) and (2). Also, (3) adds an experiment on the value of motion in the context of rigging.

(1) Relation to the conventional workflow. FlowRig includes the rest-pose workflow rather than replacing it. With a single input mesh ($N=1$), it is a static rigger for an A- or T-pose model. Static rigging has also moved beyond canonical poses, since image-to-3D generators and other 3D foundation models produce meshes in arbitrary poses; recent riggers, including the Table 1 baselines Puppeteer and RigAnything, target such meshes. In this static setting, FlowRig is the most accurate method in Table 1 on Articulation-XL2.0 and Diverse-Pose.

(2) Inputs that are unrigged mesh sequences. Recent video-to-4D and 4D generation models output entire mesh sequences: ActionMesh generates animated meshes [A], and Mesh4D reconstructs a mesh and its motion from a monocular video [B]. These outputs have a consistent topology but no rig, and re-animating or editing them requires one. Recovering bones and skinning weights from a mesh sequence is an established graphics problem for this reason, and the resulting rig supports efficient rendering, editing, and collision detection [C].

The conventional workflow does not directly apply to these inputs, since there is no rigged rest pose to start from, and rigging each frame independently results in rigs that change over time. For example, in Table 2 at $N=24$, Puppeteer-D*'s bone count differs from that of the first frame by about three bones (BND 3.18), and more than a quarter of its parent assignments change. FlowRig instead rigs the whole sequence in one feedforward pass, inferring one skeleton topology and the motion of every joint from all frames, so its bone count and tree stay constant and one rig fits every frame. All frames also inform each skeleton: a single mesh can leave joints ambiguous, while the motion shows where the object bends ((3) below). The same model also predicts the skeletons of unobserved frames (interpolation, forecasting and backcasting; Table A5 in our reply to Reviewer pXUc). A single model thus covers rest-pose meshes, posed meshes and mesh sequences, for both reconstruction and prediction.

In the updated supplementary video, we also include in-the-wild instances whose mesh reconstructed by ActionMesh has artifacts while our framework robustly handles structural mesh defects, such as explicit holes or artifacts.

(3) A motion hint for ambiguous meshes. A single mesh can leave joints ambiguous. For example, in a straight limb, the shape does not show where the elbow or knee is. By providing the mesh in various articulated poses, the motion in a mesh sequence indicates where joints should be placed for rigging. Since FlowRig generates the skeletons of all frames jointly, it uses this motion hint for every frame. To measure the hint, we fix the frame to be rigged (frame 0) and vary how many frames FlowRig observes. The model and the target frame are the same in all rows, so only the observed motion changes.

Table B1: Frame-0 skeleton error vs. number of observed frames (motion hint), TexVerse test set. FlowRig observes frames 0 to N-1; Puppeteer-D rigs frame 0 alone. Lower is better.*

methodobserved framesJ2JJ2BB2B
Puppeteer-D*00.01610.01300.0116
FlowRig0 to 30.01590.01230.0103
FlowRig0 to 70.01500.01170.0097
FlowRig0 to 150.01410.01100.0092
FlowRig0 to 230.01410.01110.0092

The error on frame 0 decreases as FlowRig observes more of the motion. With 4 frames, it sees a small part of the motion and is close to Puppeteer-D* rigging frame 0 alone (J2J 0.0159 vs 0.0161). With 16 frames, the motion hint lowers J2J, J2B and B2B by about 11% compared with 4 frames, to 12%, 15% and 21% below Puppeteer-D*. The error levels off between 16 and 24 frames. Since the weights and the target frame are fixed, this gain comes from the observed motion.

We hope this clarifies the motivation, and we are open to further questions and discussion.

[A] Sabathier et al. ActionMesh: Animated 3D Mesh Generation with Temporal 3D Diffusion. CVPR 2026.
[B] Jiang et al. Mesh4D: 4D Mesh Reconstruction and Tracking from Monocular Video. CVPR 2026.
[C] James and Twigg. Skinning Mesh Animations. ACM TOG 24(3), 2005.

[W2] Direct evaluation of joint identity

We appreciate your insightful comment and suggestion! In the paper, Table 2 reports count and topology consistency (BND, GSD and HD), which are zero for FlowRig by design (one slot set and one tree per sequence). Identity is learned: training uses one Hungarian assignment per sequence, anchored at the first frame, so slot $j$ targets the same ground-truth bone in every frame and a swap is penalized. As suggested, we now evaluate identity directly. Chamfer-type metrics are not suitable for this, since they re-match points in every frame and can hide such errors, as noted in [D].

We measure identity with IDF1 [E], the identity measure of multi-object tracking, computed on bones. Unlike a per-frame switch count, it matches each predicted bone to one ground-truth bone for the whole clip, so an identity swap, such as an exchange of two finger chains, lowers the score. Since IDF1 also counts missing and extra bones, we add IDret, the share of matchable bone-frames that stay on the bone's clip-level partner (100% = no identity error). Please refer to Appendix I in the updated draft for more details.

Table B2: Bone-identity consistency over time, TexVerse test set (T=24). IDF1 and IDret in %, with a matching tolerance of 5% of the bounding-box diagonal for all bones and 1% for finger bones. Higher is better.

methodIDF1IDretIDF1 fingersIDret fingers
Puppeteer-D*79.584.646.569.7
FlowRig (T=24)92.199.870.695.9

IDret is not affected by offsets or near-ties that leave identity unchanged, where a per-frame switch count reports false switches, and it detects the exchange of two finger chains that the reviewer describes. On the predictions (Table B2), FlowRig keeps 99.8% of the matchable bones on one ground-truth bone for the whole clip, against 84.6% for Puppeteer-D*, and 95.9% against 69.7% on finger bones. With the same frame-to-frame matching as Puppeteer-D*, FlowRig still leads (92.3% and 87.9%), which validates the identity consistency of our model against the baseline.

Identity matters downstream because skinning weights are bound to bones: a bone that changes identity moves the vertices of another part. Because FlowRig keeps its bones on the same parts, one set of weights serves the whole sequence; FlowRig's rigs reproduce the second half with lower error than Puppeteer's rig (Tables A1 and A2 in our reply to Reviewer pXUc).

We are happy to answer any further questions about the identity evaluation.

[D] Huang et al. AniGen: Unified S^3 Fields for Animatable 3D Asset Generation. arXiv:2604.08746, 2026.
[E] Ristani et al. Performance Measures and a Data Set for Multi-Target, Multi-Camera Tracking. ECCV, 2016.

[W3] What is novel, and why 4D needs it

Thanks for your comments. We appreciate the opportunity to clarify this point. Our main contribution is (1) a unified framework for 3D and 4D rigging, where 4D needs the same bones and topology in every frame; (2) a model built for it, which generates the skeleton of a whole sequence as one set of persistent bone slots over all frames; and (3) the training curriculum this model enables, which learns from limited 4D data and extract the motion cue to improve the rigging performance. As suggested, we now separate it from the preliminaries (including Flow matching, classifier-free guidance, and etc.) in Sec. 3.2 in the updated draft. Autoregressive riggers emit a token sequence per mesh, so the bone order and bone count of two frames are not tied together, and consistency has to be imposed afterwards; in FlowRig it is part of the representation. Table B3 lists each component with the evidence.

Table B3: Components of FlowRig, adopted vs. new. Adopted parts are cited in the revised Sec. 3.

componentadopted / newwhy neededevidence
Flow matching over one slot set for the whole sequence (frame / global attention, temporal RoPE)FM adopted; joint formulation newsame bones in every frame by construction; frames inform each otherTable 2 (BND 0 vs 3.18 at $N=24$); Table A5; Table B1 (motion cue)
One Hungarian assignment per sequence, anchored at frame 1matching adopted (DETR); sequence-level anchoring newslot $j$ targets one ground-truth bone in all frames (identity signal)Table B2 (identity)
Graph headnewone kinematic tree per sequence; distance-based trees flicker as joints moveTable 4 (GSD 0.0375 -> 0, HD 2.28 -> 0)
Bone-count conditioning with CFGCFG adoptedthe same requested count in every frame; density controlreply to M2mV, Table C4 (count success rates)
Uncertainty head (NLL) for sample selectionNLL adopted; selection newpicks a sample without ground truthOurs vs Ours* in Tables 1, 2
Masked conditioning (interp. / forecast / backcast)new for riggingframes with sparse or missing meshes; forecast or backcast animationreply to pXUc, Table A5
3D-to-4D curriculumnew for this taskData-efficient trainingTable 3; reply to M2mV, Tables C2a and C2b

Concerning the practical value of this task, as mentioned in reply to W1: unrigged mesh sequences increasingly come from 4D generation and reconstruction, motion improves the rig of a given frame (Table B1), and FlowRig's rigs, fitted to the motion, reproduce frames not used for fitting with lower error than Puppeteer's (Tables A1 and A2 in our reply to Reviewer pXUc). FlowRig also needs one feedforward pass of under half a minute for 24 frames (Table S2), compared with 17 minutes per 8-frame clip for the per-sequence optimization of RigGS (Appendix D). In addition, we highly recommend referring to the updated supplementary video for new animations and in-the-wild results.

We hope this makes the contribution clearer, and we welcome any further questions or discussion.

I appreciate the authors’ efforts during the rebuttal, but their responses have not resolved my concern about the paper’s core motivation: why is it necessary to rig an entire 4D mesh sequence? The authors argue that reconstruction and generation methods produce 4D mesh sequences, and that reanimating or editing these sequences requires rigging them. However, in a conventional rendering pipeline, we only need to rig a mesh from a single frame and assign skinning weights to enable reanimation and editing. Furthermore, the authors state that 4D mesh sequences can facilitate learning skeletons and skinning weights, but this appears inconsistent with the paper’s central functionality, which “generates temporally aligned skeletons for an entire sequence in a single feedforward pass.” If the rationale is that a 4D mesh sequence provides useful information for learning skeletons and skinning weights, should its motion information not be used to predict a skeleton and skinning weights for the mesh in the first frame, or another selected frame, rather than to rig every mesh in the sequence? The response therefore does not clarify the motivation for rigging an entire 4D mesh sequence.

Second, regarding rigging consistency across a 4D mesh sequence, the authors’ response indicates that rigging the entire sequence also introduces inconsistencies in joint identity. This further complicates both skinning-weight learning and animation.

Overall, I believe that the core motivation of the current version of FlowRig—generating temporally aligned skeletons for an entire mesh sequence in a single feedforward workflow—needs to be revised. I suggest that the authors consider how information from a 4D mesh sequence could improve skeleton prediction and skinning-weight learning for a single mesh, thereby supporting higher-quality animation and, in turn, the creation of additional 4D mesh sequences.

Reviewer_pXUcOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents FlowRig, a flow-matching model for skeleton generation from static 3D meshes and dynamic mesh sequences. It combines mesh features with bone slots to jointly generate skeletons across frames. A graph head predicts a shared hierarchy, while an uncertainty head supports candidate selection. The model is first trained on static rigging data, then adapted to dynamic reconstruction and prediction with partially masked observations. Experiments report competitive static reconstruction and improved dynamic reconstruction over the evaluated baselines.

Critical strengths

The method handles both static meshes and mesh sequences in one framework. Using information across frames helps it predict more accurate skeletons with a consistent structure over time than previous rigging methods whose inputs are static meshes.

Critical weaknesses
  1. The paper focuses on skeleton generation, as in its title and main method, but some claims in the Abstract and Introduction suggest a complete rigging solution with animation-ready outputs. The proposed model generates skeletons without skinning weights, which are necessary for rigging and animation. Although Appendix F provides a separate skinning model, the introduction should distinguish skeleton generation from complete rigging and qualify the animation-readiness claims accordingly.

  2. The main difference from earlier static rigging methods seems to be the use of mesh sequences to predict skeletons over time. However, the skinning model in appendix still appears to use a single mesh and its skeleton, without directly using the motion in the sequence. Better skeleton predictions alone cannot be used for animation. Using the mesh sequence to estimate both skeletons and skinning weights, and showing that they can reproduce the observed deformation and are ready for novel animation, would make the practical benefit clearer.

  3. Section 3.2 mainly introduces standard flow-matching concepts without any reference. Its presentation may suggest that they are contributions of this paper. It would be clearer to present it as “Preliminaries,” cite the relevant prior work, and distinguish it from the proposed method.

  4. The curated 4d rigging dataset is small compared with previous methods. The paper selects only 2,500 instances from TexVerse and uses 2,000 for training. Puppeteer's diverse-pose subset filters 7k+ data with both high-quality rigging and animation, while the most recent paper UniMate collects around 7k data, and SP4D collects around 20k rigged animated objects. Appendix A describes the basic filtering process, but does not show how many examples were removed at each step. What makes the selected data different from these existing datasets?

  5. The dynamic prediction claims lack quantitative support. Interpolation, forecasting, and backcasting are presented as important capabilities in the paper, but their evaluation is primarily qualitative in Figure 5(b).

Minor weaknesses:

  1. The “Datasets” paragraph mixes training and evaluation data, but its opening refers only to evaluation. Please clearly distinguish the datasets and splits used for training and testing. The paper mentions Articulation-XL here, but it uses Articulation-XL 2.0 in Table 1. And Puppeteer uses Articulation-XL 2.0 with 48k data rather than Articulation-XL.

  2. For skeleton visualization, I highly recommend highlighting the position of root joint.

Questions for authors

Please refer to the weaknesses.

6 comments

Thank you for the thoughtful questions and constructive suggestions! We address each of them in detail below. Also, we updated the supplementary video with new animations and in-the-wild results, and we sincerely hope the reviewer could take a look.

[W1] Complete rigging: FlowRig skeletons plus the skinning model of Appendix F

Thank you for this helpful comment. We appreciate the opportunity to clarify this point. The paper provides both stages of a rig: FlowRig generates the skeleton, and the skinning model of Appendix F predicts the skinning weights from the mesh and that skeleton. We placed the skinning model in the appendix because of the main contribution of unified 3D/4D skeleton generation, but our skinning model is also competitive compared with baseline and support animation. Further clarification of the scope of the paper as well as an additional evaluation of the full rig is below.

(1) The skeleton changes over time, so rigging is 4D. In a mesh sequence, the bone needs to align with that frame's mesh, and their number and the kinematic tree stay the same in all frames. For an unrigged sequence, these per-frame skeletons, i.e. the motion, are unknown. With one input mesh, FlowRig is a static rigger; with a sequence, it generates the skeletons of all frames jointly, each aligned with its frame's mesh and all sharing one topology.

(2) The skinning weights do not change over time, so skinning follows the established design of input and output. In linear blend skinning only the bone transforms change from frame to frame; one set of weights is shared by all frames. The skinning model therefore predicts one set of weights from a bind mesh and its skeleton. As in RigNet [A], RigAnything [B] and Puppeteer [C], the weights are predicted after the skeleton and conditioned on it; the architecture follows Puppeteer's, including its topology-aware attention between joints.

(3) Skeleton first, then skinning. This order is the convention of the riggers above and of manual rigging, where artists place the skeleton before binding the mesh and painting the weights. Since weights are defined per bone, they can be predicted only once the bones exist.

(4) Each stage is more accurate than or competitive with the baselines.

  • 3D rigging (Table 1). FlowRig is the most accurate method on Articulation-XL2.0 and Diverse-Pose in J2J, J2B and B2B. On ModelsResource, evaluated zero-shot, it is second only to RigAnything, which is trained on that dataset.
  • 4D rigging (Table 2, N=24). Compared with Puppeteer-D*, i.e. Puppeteer fine-tuned on our 4D training set, FlowRig has lower error and a quarter of the bone-length drift, and its bone count and tree do not change over the sequence.
  • Skinning (Appendix F, Table S3). Against baselines, our skinning model has the best precision, recall and L1 error on Articulation-XL2.0 and Diverse-Pose. On ModelsResource it has the best precision, with an L1 error within 0.007 of the best.

(5) Animation results. In the paper, each stage is evaluated on its own benchmark (Tables 1, 2 and S3). As suggested, we now also evaluate the full rig on animation in Tables A1 and A2 below (reply to W2). The revised supplementary video also shows the rig animating frames that FlowRig did not observe.

We hope this clarifies the scope of the paper, and we are happy to answer any further questions.

[A] Xu et al. RigNet: Neural Rigging for Articulated Characters. SIGGRAPH 2020.
[B] Liu et al. RigAnything: Template-Free Autoregressive Rigging for Diverse 3D Assets. ACM TOG, 2025.
[C] Song et al. Puppeteer: Rig and Animate Your 3D Models. NeurIPS 2025.

[W2] The predicted rig reproduces the observed deformation

We appreciate your insightful comment and suggestion. In the paper, the sequence is used to infer the skeleton of every frame, and the skinning model predicts one set of weights from the bind mesh and its skeleton, because skinning weights do not change over time ((1) below). As suggested, we now test whether this full rig reproduces the observed deformation ((2) below).

(1) How the sequence enters the rig. FlowRig infers the skeleton of every frame jointly from all frames, and observing more frames lowers its error on a fixed frame (Table B1 in our reply to Reviewer QgQD). The skinning weights are predicted from one bind mesh and its skeleton for two reasons. First, the weights of linear blend skinning (LBS) are shared by all possible downstream animations, not just those found in subsequent frames of input mesh sequence, so they are predicted from the bind mesh and its skeleton, which is also applied in RigNet, RigAnything and Puppeteer [A, B, C]. Second, the same skinning model then serves both a single mesh ($N=1$) and a mesh sequence. The motion still informs the weights through the bind skeleton, which FlowRig places using all frames.

(2) Reproducing the observed deformation, and new poses. We follow the evaluation setup of RigMo [D] to evaluate the deformation error between the GT mesh sequence and animated mesh sequences by the models. The error $E$ is MoRig's animation error [E]: the mean distance between posed and observed vertices, in % of the object's size.

Table A1: Deformation error. Each method rigs frame 1. Frame 1 is the bind frame (error 0) where we apply a skinning model. Lower is better; bold: best predicted rig.

ModelMesh observed frames$E$, frames 2-12$E$, frames 13-24
Puppeteer [C]10.0980.218
FlowRig, 4D model10.0540.176
FlowRig, 4D model1-40.0520.155
FlowRig, 4D model1-120.0480.147
FlowRig, 4D model1-240.0470.145

Table A2: Deformation error. 193 Objaverse-derived clips (detailed in Appendix D). Protocol and columns as in Table A1.

ModelMesh observed frames$E$, frames 2-12$E$, frames 13-24
Puppeteer [C]10.2530.471
FlowRig, 4D model10.0640.238
FlowRig, 4D model1-40.0750.223
FlowRig, 4D model1-120.0600.194
FlowRig, 4D model1-240.0570.203
  • Ready for new poses. On both sets, every FlowRig rig has lower error than Puppeteer's on the both frame ranges.
  • Motion is a rigging cue. The same 4D model builds a better rig when it observes more of the motion than when it sees only the first mesh: a joint that one pose leaves ambiguous, such as the elbow of a straight arm, shows once the part bends. This holds even when the model observes only frames 1-12, so motion it has seen improves the rig on poses it has not seen.
  • Spatio-temporal consistency. FlowRig generates the skeletons of all observed frames jointly, with the consistent topology and mesh-aligned skeleton at each frame. The bind skeleton therefore agrees with every observed pose, and its joints sit where the object actually bends, which is what a frozen rig needs to follow new poses.

We also update the supplementary video for the qualitative comparison in the supplementary material. We hope these results address your concern, and we would be glad to discuss any further questions.

[W4] What makes our 4D data different, the curation funnel, and scaling

We sincerely appreciate your thoughtful feedback and constructive suggestions.

(1) What our 4D supervision requires. 4D skeleton training needs, for every frame, the deformed mesh and the skeleton posed by the same skinning, so that frame $i$'s skeleton lies inside frame $i$'s mesh. The three datasets do not provide this:

  • Puppeteer's diverse-pose subset [C] is static. It releases one frame per animated asset. However, a valid frame does not make a valid clip: when we re-extract the animations from the released frames, we find that roughly one in ten bone lengths changes, despite the corresponding input frame being valid. Recovering the sequences would be a new 4D curation task.
  • UniMate [F] is concurrent work built to generate motion for a given rigged asset. Its rigged meshes, needed to turn its motions into mesh sequences, were released on 5 Oct 2026, after the submission deadline. (We scale up our model with another 4D dataset as mentioned in (3) below.)
  • SP4D's KinematicParts20K [G] is not publicly available: the SP4D release contains code and model weights only.

Our TexVerse 4D set is built for aligned mesh and skeleton sequences. Every frame is checked by automatic scripts and verified manually (Table A3).

(2) The curation funnel. Most TexVerse animations are not suitable for 4D skeleton training, and consequently only a small portion of the assets with both a skeleton and an animation is kept. Table A3 gives the count after each curation step; Appendix A now includes it with the removal reasons.

Table A3: TexVerse 4D curation funnel. Number of assets left after each filtering step, with the main removal reasons.

stepremainingmain removal reasons
TexVerse objects~858,000
with a skeleton~69,000no rigs
with skeleton and animation~35,000no animation clip
rest-pose render classified by a VLM (Qwen3.5)~24,000not a single object or decorated scene (6,830)
automatic skinning check~3,00087.5% fail (1,000 of 8,004 pass in two batches with complete logs)
manual verification of every passing clip~2,70011.3% rejected (113 of 1,000 in the same batches)
split~2500with at least 24 frames

(3) FlowRig works with a small 4D dataset and can scale with more data. We kept the 4D set small and clean because the curriculum transfers the geometric prior from large static data: static pretraining lowers the 4D error by about a third (Table 3). We treat this as a strength because our method can leverage limited 4D data. To test scaling, we also trained FlowRig with about 36k additional animated Objaverse assets (Anymate) and evaluated it on held-out Anymate clips whose assets are not in training.

Table A4: Effect of more 4D training data. Skeleton error (J2J-W, B2B-W) and bone-length drift (BDD) of the model trained on TexVerse alone or with Anymate added, on the TexVerse test set and held-out Anymate clips (T=24). Lower is better.

4D training dataTexVerse J2J-WB2B-WBDDAnymate held-out J2J-WB2B-WBDD
TexVerse (2,000 clips)0.01420.00930.00380.03120.02260.0064
TexVerse + Anymate (+36,000 assets)0.01460.00960.00350.01950.01330.0045

With the additional data, the error on held-out Anymate clips drops by more than a third, while on the TexVerse test set the model stays close to the TexVerse-only model. The curated set thus trains an accurate 4D model, and the same recipe benefits from additional animated assets, in particular on new objects.

We hope this clarifies the role and scale of our 4D data, and we are open to any further questions or discussion.

[D] Zhang et al. RigMo: Unifying Rig and Motion Learning for Generative Animation. arXiv:2601.06378, 2026.
[E] Xu et al. MoRig: Motion-aware Rigging of Character Meshes from Point Clouds. SIGGRAPH Asia 2022.
[F] Mou et al. UniMate: One Unified Model to Animate Diverse Skeletons. arXiv:2609.05415, 2026.
[G] Zhang et al. Stable Part Diffusion 4D: Multi-View RGB and Kinematic Parts Video Generation. NeurIPS 2025.

Comments on the paper

3 comments

Dear Reviewers,

The authors have posted their rebuttal. As the Reviewer-Author discussion period is coming to an end, please review their responses and the comments from your fellow reviewers, and provide any further feedback if you have not done so. Thank you.

The AC

AuthorsOpenReview ↗

Summary of Rebuttal for AC (1/2)

Dear AC,

We provide below a summary that (i) lists the contributions of our paper, (ii) summarizes the reviewers' assessments, and (iii) describes how each reviewer's concerns were addressed in the rebuttal and in the revised paper, where changes are marked in blue.


Contributions

  • A unified model for animation-ready rigging and skinning. FlowRig is a single feedforward model for skeleton reconstruction and prediction on both static 3D meshes and 4D mesh sequences.
  • A 4D consistent representation. The design of persistent bone slots with flow matching, one consistent Hungarian assignment per sequence, and a graph head estimating one kinematic tree per sequence inherently guarantee a persistent topology and help joint identities stay the same over time.
  • Important design for downstream tasks, including fine-grained bone-count conditioning, uncertainty-based candidate selection, and masked conditioning for interpolation, forecasting, and backcasting.
  • Data-efficient training. A 3D-to-4D curriculum transfers the geometric prior from large-scale static rigging data to a curated, mid-scale 4D dataset of aligned mesh and skeleton sequences. Both 3D/4D rigging and skinning reach the SOTA. Besides, the performance can further improve with data scaling.

Positive assessments

The reviewers recognized the value of the unified formulation and its design:

  • Reviewer pXUc noted that FlowRig handles static meshes and mesh sequences in one framework, and that using information across frames gives more accurate skeletons with a consistent structure over time than static riggers.
  • Reviewer QgQD considered flow matching a reasonable alternative to autoregressive skeleton generation, the shared graph and sequence-level Hungarian matching sensible designs, and bone-count control useful.
  • Reviewer M2mV found meaningful reconstruction improvements across several evaluations (Tables 1 and 2, and the RigGS comparison), and a useful unified formulation with evidence for static-to-dynamic transfer (Table 3).

Scores at the time of this summary

  • pXUc: 2, weak rejection (responded in the last day and have not had a complete discussion)
  • QgQD: 2, weak rejection (has not yet responded to the rebuttal)
  • M2mV: 3, weak acceptance (responded that the new results strengthen the evidence for the contributions, and kept weak acceptance)

Addressing reviewer concerns

[Reviewer pXUc, score 2]

Concerns raised:

  • The paper generates skeletons, while some claims suggest a complete, animation-ready rig.
  • The skinning model uses a single mesh; asked to show that the rig reproduces the observed deformation and supports new animation.
  • Sec. 3.2 presents standard flow matching without references.
  • The curated 4D dataset is small; asked what distinguishes it and how many assets each filtering step removes.
  • Prediction (interpolation, forecasting, backcasting) is shown only qualitatively.
  • Minor: the Datasets paragraph and the Articulation-XL version; marking the root joint in figures.

How we addressed them:

  • Clarified that the submission already provides a complete and animation-ready rig (Table S3, supplementary video).
  • Explained why the weights are predicted from the bind mesh: one set of skinning weights serves every frame and every new animation. Added a full-rig evaluation: FlowRig's rig has lower deformation error than Puppeteer's in every setting and the rig improves as FlowRig observes more of the motion (rebuttal Tables A1, A2; supplementary video).
  • Sec. 3.2 is now "Preliminaries: Flow Matching", with citations, and Sec. 3.3 separates the adopted tools from our contributions.
  • Explained that 4D training needs aligned mesh and skeleton sequences; reported the full curation funnel (Table A3); and showed that FlowRig scales with more data (Table A4).
  • Added quantitative prediction results against Puppeteer-D* with interpolation where FlowRig is the most accurate in all five settings (Appendix G).
  • Revised the Datasets paragraph (training vs. evaluation data; Articulation-XL2.0) and marked the root joint in all skeleton figures.
AuthorsOpenReview ↗

Summary of Rebuttal for AC (2/2)

Addressing reviewer concerns (continued)

[Reviewer QgQD, score 2]

Concerns raised:

  • Practical motivation for rigging 4D meshes, and relation to the conventional rest-pose workflow.
  • Consistent bone counts and topology do not imply consistent joint identities; no direct evaluation.
  • Novelty: which components are new, and why they are needed for 4D.

How we addressed them:

  • Clarified that the 4D mesh foundation model needs rigging and skinning for building animation-ready assets, and FlowRig's 4D rigging can further leverage 4D motion cues to reduce joint ambiguity from a single static mesh and help motion-aligned rigging (Appendix H). The supplementary video adds in-the-wild 4D rigging results.
  • Added a direct identity evaluation with IDF1 and IDret to demonstrate the consistent joint identities of FlowRig outputs (Appendix I).
  • Introduce the novelties from model design (replace Language model with Flow Matching), capabilities (fine-grained bone count control, uncertainty-based sampling, 4D support, and prediction), and inference speed.

[Reviewer M2mV, score 3]

Concerns raised:

  • Distinct benefits beyond RigMo and AniGen, and ablations that isolate the unified formulation and the three-stage curriculum.
  • Prediction errors against simple interpolation/extrapolation baselines, and exact bone-count success rates.

How we addressed them:

  • Added a capability comparison (Table C1): FlowRig is the only one of the three methods that provides feedforward 4D rigging without vertex correspondence, a persistent artist-style skeleton, bone-count control in one-bone steps, and skeletons of unobserved frames.
  • Added a stage-wise curriculum ablation (Tables C2a, C2b): Stage 1 lowers the 4D error by a third, Stage 2 gives stable bone lengths and identities, and Stage 3 enables prediction.
  • Added prediction results against interpolation and extrapolation baselines (Appendix G, supplementary video), and bone-count success rates (Appendix J).
  • Reviewer M2mV responded that these results strengthen the evidence for the contributions and kept the recommendation of weak acceptance.

Summary and final remarks

All three reviewers acknowledged the value of handling static meshes and mesh sequences in one framework. The main concerns were requests for further quantitative evidence and for clarification of scope, motivation, and novelty. We addressed each of them with new experiments and revisions: prediction (Appendix G), the motion hint (Appendix H), joint identity (Appendix I), bone-count success rates (Appendix J), full-rig deformation, curriculum and data-scaling experiments, and the revised Sec. 3.2, 3.3 and 4.1. Several points were already covered in the original submission, including the skinning model (Appendix F), the comparison with per-sequence optimization and its runtime (Appendix D, Table S2), and the benefit of static pretraining (Table 3).

We believe FlowRig offers a practical way to rig the growing number of unrigged mesh sequences produced by 4D generation and reconstruction, with one model for static and dynamic inputs. We hope this summary provides a useful reference for the AC. Thank you for your time and consideration.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.