Organizations: Alaya Lab · The University of Tokyo · University of California, Merced · National Yang Ming Chiao Tung University · Institute of Science Tokyo
Image-to-3D generative models now produce asset-quality textured meshes, but at minutes per asset they remain slow to iterate with and costly to deploy. Prior work has mostly accelerated the sampling of the networks, and where it also optimizes the mesh processing, it trains its own generators. We instead start from a publicly released pipeline and ask how much of its end-to-end time can be saved. Profiling the public Pixal3D pipeline shows that its latency is dominated by what happens after the networks: the four rectified flows take 14% of the wall-clock time and mesh post-processing takes 85%, most of it in CPU-based UV unwrapping. We therefore first rebuild the mesh post-processing on the GPU and take it off the critical path, then cut the per-evaluation overhead of the flows and distill them from 76 to 8 network evaluations. The resulting pipeline, Sprint3D, reduces the median time per asset from 133 s to 4.05 s on one H200 GPU at the same export settings (33×). At the same time, on 2,653 held-out Toys4K objects it improves every input-view normal metric of the Pixal3D protocol, with a slightly lower mean silhouette IoU, lower point-cloud alignment scores and less fine texture detail. The rebuilt post-processing alone also speeds up TRELLIS.2, which uses the same export code, by 6.7× without a detectable change in the evaluated metrics.
Figures & tables
Figure 1: Image-to-3D assets from our pipeline. Twenty-eight assets, each generated from one image (validation objects; about 1M faces and a 40962 texture per asset), rendered in Blender. Bottom: median end-to-end time, split by stage in proportion to the mean critical path.
Figure 2: Our pipeline. The four flows of Pixal3D in three panels, with their sampling steps (Base (Pixal3D) → Ours) and the changes we apply.
Figure 3: Three ways to build the UV atlas. (a) Base (Pixal3D); (b) the tiled mesh path, an intermediate step; (c) Sprint3D, with the GPU chart segmentation. Top: mean time per stage, two lanes for concurrent work (Appendix Table 7 ). Bottom: the atlas of one validation object, charts in random tones, with chart count, texel coverage and seam length (object diagonals).
Optimization
Stage
Class
Effect (s)
Trade-off
(1) Mesh post-processing (Section 3.2 )
Tiled mesh path (16-tile atlas)
mesh post-proc.
⧫
− 116.1 [ − 141.3, − 94.4]
16-tile UV layout; superseded
Mesh pre-processing on a worker thread
mesh ∥ texture
=
− 0.20 [ − 1.46, +1.08]
scheduling only
Fixed bake-kernel launch configuration
bake
=
− 1.91 [ − 3.19, − 0.66]
identical in a unit test
Faster GPU simplification and charting
simplify, charts
≈
− 0.71 [ − 2.10, +0.69]
non-deterministic, in spread
GPU BVH build
BVH
≈
− 1.66 [ − 2.79, − 0.52]
ties change nearest face
Table 1: The adopted optimizations , in the order of the cumulative measurement; a later row can replace an earlier one. Class: = output-identical, ≈ near-identical, ⧫ output-changing. Effect: paired mean change of the E2E time when the row is added [95% CI over the inputs]. Verification of the = and ≈ rows: Appendix 6 .
Critical path (s)
Δ normal map
Configuration
Steps
E2E (s)
flows
post-processing
Speed-up
PSNR (full)
Mean ( ∘ )
Base (Pixal3D)
12/12/12/12
133.0
17.3
108.8
–
reference
reference
Base (Pixal3D), re-run
12/12/12/12
138.4
17.2
118.1
–
−0.03 [ −0.11 , +0.05 ]
+0.13 [ −0.07 , +0.32 ]
+ mesh path rebuilt
12/12/12/12
19.0
17.2
1.32
7.26× [5.85, 9.00]
+0.09 [ −0.01 , +0.20 ]
+0.03 [ −0.17 , +0.24 ]
+ flow optimizations
12/12/12/12
15.4
13.8
1.32
1.24× [1.20, 1.27]
+0.09 [ −0.00 , +0.20 ]
+0.04 [ −0.16 , +0.25 ]
+ distilled students ( Ours )
4/1/1/2
4.00
2.38
1.35
3.84× [3.58, 4.31]
+0.44 [ +0.27 , +0.61 ]
−1.47 [ −1.98 , −1.01 ]
Table 2: Progressive design analysis. Base (Pixal3D): dedicated timing run; other rows: the first row and the ends of the three groups of the cumulative measurement. Steps: structure / coarse-shape / fine-shape / texture; critical path: medians of the per-input sums; speed-up: ratio of medians to the row above; Δ : paired difference to Base (Pixal3D).
Δ normal map
Δ color
Configuration
E2E (s)
Post-processing (s)
Speed-up
PSNR (full)
Mean ( ∘ )
PSNR
TRELLIS.2 (official)
112.7
91.4
–
reference
reference
reference
+ rebuilt mesh path, full-resolution remesh
16.9
2.2
6.7× [5.4, 8.6]
+0.00 [ −0.00 , +0.01 ]
+0.00 [ −0.01 , +0.02 ]
−0.00 [ −0.02 , +0.01 ]
+ adaptive half-resolution remesh
16.5
2.1
6.8× [5.4, 8.5]
−0.07 [ −0.18 , +0.00 ]
+0.02 [ −0.07 , +0.11 ]
−0.06 [ −0.09 , −0.04 ]
Table 3: The rebuilt mesh path in TRELLIS.2. TRELLIS.2-4B at its released settings on the 40-object subset; only the mesh post-processing is carried over, not the flow engineering (Section 3.3 ) or the distilled students (Section 3.4 ). Speed-up and Δ : against TRELLIS.2 (official); Δ color: input-view base-color PSNR against the input image.
Figure 4: Cumulative measurement. Each row adds one change to the row above, grouped as in Section 3 (left: group factors). Bars: median critical-path time per stage (shape flows: structure, coarse- and fine-shape flows); gray: remainder to the median E2E time; hatched: the released export, timed as one call. Lower panel: row 9 on a 0–20 s axis.
Method
IoU (pt) ↑
PSNR (overlap) ↑
SSIM (overlap) ↑
LPIPS (overlap) ↓
Mean ( ∘ ) ↓
Median ( ∘ ) ↓
Mean B ( ∘ ) ↓
11.25 ∘ (pt) ↑
22.5 ∘ (pt) ↑
30 ∘ (pt) ↑
E2E (s) ↓
TRELLIS.2
79.55
17.15
0.577
0.033
25.06
18.97
27.56
48.27
64.47
70.80
–
TripoSG
59.87
14.22
0.504
0.051
38.87
34.31
40.88
22.74
35.89
42.98
–
Hunyuan3D-2.1
59.82
14.31
0.505
0.049
39.33
35.24
41.80
23.20
36.10
43.17
–
Base (Pixal3D)
96.97
20.87
0.668
0.021
14.25
9.99
15.73
61.35
82.58
88.71
133.0
Ours
96.78
21.56
0.712
0.018
13.00
9.06
14.33
65.53
85.13
90.40
4.05
Table 4: Single-image generation under the Pixal3D protocol. The 2,653 objects of the Toys4K test part, evaluated once after the protocol was frozen; input-view normal maps against the ground truth, metrics as in Section 4.1 . E2E: median of the dedicated timing run on the validation set (baselines: Appendix Table 9 ).
Figure 5: Qualitative comparison. Seven inputs of the 40-object subset, rendered from the input camera: the input image, then the normal maps and the unlit base color of the ground truth, Base (Pixal3D) and Ours . Rows 1–5: typical inputs, in order of increasing angular error of Base (Pixal3D); rows 6–7: the two inputs with the largest error for Ours (selection: Section 4.4 ).
Table 5: One part of Sprint3D changed at a time. First block: students replaced by alternatives; second block: each student replaced by its same-step teacher (Section 3.4 ). Each block is one run, and E2E compares only within a block ( Ours : first / second run). Second block: ∗ / † against the Ours row; CD and [email protected]: Appendix 8 .
(a) Structure stage (400 views of 278 validation objects, true camera; support IoU at 32 3 )
Method
Data
Steps
IoU ↑
Δ vs 12-step teacher [95% CI]
IoU vs 12-step teacher ↑
GPU-h (+cache)
Updates
12-step teacher
—
12, guided
0.597
ref.
1.000
—
—
Consistency
10k set
4
0.596
− 0.002 [ − 0.007, +0.003]
0.797
27.8
12,000
DMD2
10k set
4
0.587
− 0.010 [ − 0.015, − 0.006]
0.785
18.0
3,000 (15,000)
Trajectory (Ours)
5k set
4
0.598
+0.001 [ − 0.002, +0.004]
0.894
0.25 (+3.5)
500
Table 6: Distillation methods per stage. (a) Support IoU against the ground truth and against the 12-step teacher’s support. (b) Agreement with the 12-step teacher (decoded-color L1, relative latent error). Updates: of the student (whole run in parentheses); Stage: texture-stage time; GPU-h: training time × GPUs (+ teacher-trajectory cache; est.: estimated).
Stage (s, mean)
Base (Pixal3D)
Base (Pixal3D), re-run
+ tiled mesh path
Ours
Input pre-processing
0.12
0.23
0.23
0.22
Structure flow
1.12
1.12
1.13
0.35
Coarse-shape flow
1.59
1.64
1.65
0.19
Fine-shape flow
11.76
11.54
11.47
0.71
Texture flow
6.97
7.02
3.80
1.39
Mesh extraction and remesh
11.17
0.47
4.60
0.45
Table 7: Per-stage profile. Mean time per input on the critical path; concurrent work listed as hidden work; shares: mean stage time over mean E2E time. Base (Pixal3D), Ours : dedicated timing run; re-run, + tiled mesh path: cumulative measurement. UV unwrapping: GPU chart clustering, then CPU xatlas ( Ours : GPU chart segmentation).
Table 8: Every step of the cumulative measurement. Δ Mean, Δ PSNR: paired mean difference to Base (Pixal3D) in the mean angular error and the normal PSNR on the full image, CI beneath; first row: the re-run. CD and [email protected]: Appendix 8 . Δ VRAM: request-time peak above the resident weights, maximum over inputs.
End-to-end time (s)
Median seconds (mean share)
Method
Output
median
mean
p90
sampling
post-processing
Base (Pixal3D) a
1M faces, 40962 texture
133.0
156.0
257.4
17.3 (16%)
109.3 (83%)
TRELLIS.2 b
1M faces, 40962 texture
105.3
128.5
197.7
14.3 (16%)
85.8 (84%)
Hunyuan3D-2.1 b,c
40k faces, 20482 texture
62.2
64.1
81.8
13.5 (22%)
48.4 (78%)
TripoSG b
1.2M faces, no texture
7.9
7.8
10.6
2.7 (37%)
4.9 (60%)
Table 9: End-to-end time of the released pipelines. The 77 inputs of the dedicated timing run; shares: means of per-input shares. Sampling: conditioning and flow or diffusion sampling; post-processing: the rest, including latent decoding. a Dedicated timing run. b Timed while generating the baseline outputs. c Sampling includes multi-view diffusion and super-resolution.
Figure 6: Quality against speed-up, paired to Base (Pixal3D). The rows of Figure 4 : mean paired difference to Base (Pixal3D) in Chamfer distance and base-color LPIPS against the speed-up over the re-run, each with its 95% CI. Circles: output-identical (open), near-identical (filled); diamonds: output-changing; squares: Base (Pixal3D) (open), its re-run (filled); triangles: the released flows at 12, 8, 4 and 2 steps.
Figure 7: Two ways to build the UV atlas, step by step. One validation object, shown simplified to 30k faces. Top: the tiled mesh path (not in Sprint3D): charts assigned to 16 groups (a), each unwrapped by xatlas into one tile of a 4×4 atlas (b); GPU pull-push fill (c). Bottom: the single-pass GPU chart segmentation (1–5), replacing (a) and (b).
Method
IoU (pt) ↑
PSNR (overlap) ↑
SSIM (overlap) ↑
LPIPS (overlap) ↓
Mean ( ∘ ) ↓
Median ( ∘ ) ↓
Mean B ( ∘ ) ↓
11.25 ∘ (pt) ↑
22.5 ∘ (pt) ↑
30 ∘ (pt) ↑
E2E (s) ↓
(a) Validation set (400 objects, one view each)
TRELLIS.2
71.88
15.80
0.521
0.084
28.92
21.07
34.00
42.13
56.97
64.18
–
TripoSG
60.35
13.39
0.477
0.105
40.45
34.57
45.59
17.18
34.95
45.35
–
Hunyuan3D-2.1
64.90
14.47
0.499
0.093
34.56
27.87
40.75
28.47
45.11
54.56
–
Base (Pixal3D)
96.60
19.20
0.613
0.053
17.22
11.68
19.42
53.36
77.32
84.63
133.0
Ours
96.33
19.82
0.655
0.048
15.92
10.68
17.96
57.69
80.25
86.55
4.05
Table 10: Table 4 on the validation set and on the Toys4K development part. (a) The 400 validation objects, which also served model selection, one view each; E2E as in Table 4 . (b) The 500 development objects, one fixed view each (Appendix 7 ); E2E not measured on this set.
Table 11: Other metrics of Table 4 . The Toys4K test part. Top: normal map on the full image and single-view 3D metrics; bottom: image–shape alignment with textured renders (CLIP), normal-map renders (CLIP-N) and point clouds with (col.) or without (geo.) vertex colors (ULIP-2, Uni3D). Definitions: paragraph “Metrics beyond the protocol”. TripoSG has no texture. ∗ / † : sign test on the 2,651 objects with both outputs (families: Appendix 7 ).
Metric
Δ (Ours − Base (Pixal3D))
95% CI
better / worse / tie
pHolm
Input-view normal maps (Holm over 13)
IoU (pt) ∗
−0.19
[ −0.29 , −0.11 ]
1555 / 1095 / 1
3.9×10−19
PSNR (overlap) ∗
+0.70
[ +0.66 , +0.73 ]
2212 / 439 / 0
2.7×10−282
SSIM (overlap) ∗
+0.0442
[ +0.0421 , +0.0462 ]
2268 / 383 / 0
<10−300
LPIPS (overlap) ∗
−0.0025
[ −0.0028 , −0.0022 ]
1975 / 676 / 0
9.4×10−146
PSNR (full) ∗
+0.42
[ +0.38 , +0.45 ]
1956 / 695 / 0
3.5×10−137
Table 12: Paired statistics of Table 4 . The 2,651 Toys4K test objects with an output of both pipelines. Ours − Base (Pixal3D): mean difference with 95% CI, objects better / worse / tied, sign-test p Holm-adjusted within each block; ∗ / † : significantly better / worse.
Geometry only
Colored
Method
Uni3D ↑
ULIP-2 ↑
Uni3D ↑
ULIP-2 ↑
TRELLIS.2
30.70
31.38
33.34
36.67
TripoSG
30.42
31.43
30.42
31.43
Hunyuan3D-2.1
26.88
26.88
29.88
32.46
Base (Pixal3D)
29.88
30.23
32.88
35.64
Ours
29.14
29.17
32.58
34.94
Table 13: In-the-wild images, protocol of the Pixal3D paper’s Table 2. Image–shape alignment ( ×100 ) with ULIP-2 and Uni3D, geometry only and colored, on 150 images we collected (100 Internet photographs, 50 generated), scored on the 149 with an output from every method. No ground truth; descriptive. TripoSG has no texture.
Table 14: Shape after the same similarity ICP for every method. Shape against the ground truth in its unit sphere; object means; Δ : Ours − Base (Pixal3D). Metrics: paragraph “Shape after alignment”.
Input view
All views
Distance to GT renders
Method
PSNR ↑
SSIM ↑
LPIPS ↓
PSNR ↑
SSIM ↑
LPIPS ↓
FD ↓ (Inception)
FD ↓ (DINOv2)
CMMD ↓
Base (Pixal3D)
24.34
0.915
0.066
16.50
0.829
0.233
32.37
292.8
0.0557
Ours
24.30
0.920 ∗
0.061 ∗
16.58 ∗
0.835 ∗
0.225 ∗
32.68
313.0 †
0.0624
12-step teacher
24.21
0.920
0.061
16.59
0.834
0.226
31.75
293.5
0.0421
Difference
+0.10
0.000
0.000
−0.01
0.000
0.000
+0.94
+18.7
+0.0202
95% CI
[ −0.05 , +0.20 ]
[ −0.001 , +0.001 ]
[ −0.001 , +0.001 ]
[ −0.13 , +0.06 ]
[ −0.001 , +0.001 ]
[ −0.001 , 0.000]
[ +0.39 , +1.74 ]
[ +14.1 , +26.4 ]
[ +0.0154 , +0.0257 ]
Table 15: Appearance against the ground-truth base color. Unlit base color of the 339 validation objects with exportable materials; metrics: paragraph “Appearance against the ground truth”. ∗ / † : Holm-adjusted over a family of 18 tests fixed in advance (Appendix 7 ). Last rows: the texture flow exchanged alone, in one separate run.
Figure 8: The six failure objects of Section 4.4 . Per row: the input; normal maps of the ground truth, Base (Pixal3D), Ours and Ours with one stage replaced (rows 1–3: structure student trained on the 10k set; rows 4–5: 2-step shape students; row 6: none recovers it), each with its silhouette IoU; silhouette difference to the ground truth (orange: missing; blue: extra).
Structure stage (400 views of 278 validation objects, true camera): support
Method
Data
Updates
Sampler
IoU ↑
P
R
Thin R
IoU vs T
GPU-h
12-step teacher
—
—
Euler
0.597
0.725
0.727
0.476
1.000
—
25-step teacher
—
—
Euler
0.597
0.724
0.727
0.472
0.973
—
12-step teacher, shift 5.0
—
—
Euler
0.598
0.725
0.727
0.480
0.978
—
Consistency
5k (4,993)
15,000
re-noise
0.592 ▼
0.724
0.718
0.460
0.796
n/r (16)
Consistency
10k (19,998)
12,000
re-noise
0.596
0.728
0.722
0.464
0.797
27.8 (4)
Table 16: All structure-stage distillation runs evaluated on the validation set. Columns as in Table 6 (a), plus precision (P), recall (R), thin-part recall (Thin R) and IoU against the teacher’s support (vs T). Data: training views in parentheses. ▼ / ▲ : worse / better than the 12-step teacher, CI excluding zero. GPU-h (GPUs); n/r: not recorded.
While 3D generation is progressing rapidly, recent work has often focused on obtaining high-resolution assets, leaving user experience and deployability as afterthoughts. We present AssetGen, a 3D generator that focuses instead on these two aspects. Given one reference image, in 30 seconds it produces a high-quality mesh with baked normals, a color texture, and a controlled polygon budget suitable for real-time rendering, including mobile use cases. The AssetGen Flash variant further reduces latency to 14 seconds for interactive and agentic creation loops. Our model generates the object geometry with a coarse-to-refine VecSet framework, which implements mesh simplification, cleaning, and normal baking on the GPU, and a fast parallel UV unwrapping. It then generates textures in a multi-view fashion, followed by backprojection and 3D inpainting. Model distillation, kernel optimization, and pipeline parallelization are co-designed to accelerate the system end-to-end. We introduce numerous automated and blind human evaluations and demonstrate competitive visual quality against leading commercial solutions in 30 seconds and preview-quality results in less than 15 seconds. The final result is a system that supports AI-assisted, deployable 3D content creation in interactive workflows.
Polygonal meshes are the standard surface representation of modern 3D pipelines, and generating high-quality meshes with artist-style topology is essential for film, gaming, and interactive 3D applications. Mainstream approaches serialize a mesh into a token sequence and decode it autoregressively, which is slow at inference and sensitive to error accumulation, making them impractical for interactive asset creation. We present Meshy T2, a fast native mesh generation framework built on flow matching. At its core is a vertex-set mesh VAE that encodes a mesh into one continuous latent token per vertex and decodes vertices, edge connectivity, and face winding order in a single pass, preserving high-precision geometry and artist-authored topology without vertex quantization or welding. Generation proceeds as a coarse-to-fine cascade of two flow-matching models: an image-conditioned voxel flow first sketches the overall shape as a coarse occupancy scaffold, and a mesh flow then populates the scaffold with per-vertex latent tokens, conditioned on the image, the scaffold, and a requested vertex budget. This design delivers three practical capabilities: interactive generation speed through parallel flow-based synthesis; effective face-count control through the requested vertex budget; and native support for multi-part assets, whose components emerge directly from the generated connectivity. In our experiments, Meshy T2 achieves state-of-the-art geometric fidelity and completes end-to-end image-to-mesh generation within a median of 6 seconds, over an order of magnitude faster than autoregressive baselines. Code and weights will be available at https://github.com/meshy-dev/meshy-t2.
Recent native 3D generators achieve high-quality asset creation by modeling structured 3D latents with flow-based transformers, but their high-resolution generation remains computationally expensive due to costly iterative sampling. In this work, we introduce a few-step distillation framework for native 3D generation, enabled by continuous self-consistency training with a custom JVP FlashAttention kernel and an analytic velocity regression objective for sparse structured 3D latents. To stabilize joint optimization, we further introduce an adaptive loss weighting strategy that automatically balances them without manual tuning. Beyond acceleration, we reveal a previously overlooked failure mode of few-step native 3D generation: sampling-induced latent distribution drift preserves geometric correctness but disrupts downstream PBR texture synthesis, causing texture artifacts on geometrically valid assets. To address this issue, we propose Channel Match, a training-free adaptive per-channel latent calibration method that restores the latent distribution without modifying either generator. We validate our approach on TRELLIS.2 at the 10243 resolution setting. Our two-step model achieves 4.5× faster geometry sampling while maintaining geometry quality comparable to the many-step teacher, and Channel Match further improves rendering quality by recovering the latent interface between geometry and appearance generation.