Vision2025~106 minarXiv:2506.16504

Hunyuan3D 2.5: Towards High-Fidelity 3D Assets Generation with Ultimate Details

score 3Zeqiang Lai, Yunfei Zhao, Haolin Liu +23↑ 31★ 226Jun 19, 2025cs.CVhttps://github.com/zeqiang-lai/lattice

🎯 Pitch

A new 10B-parameter 3D shape model trained at scale suddenly closes the realism gap with handcrafted meshes, producing crisp details and clean surfaces without the usual trade-offs. Meanwhile, its companion texture stage jointly generates albedo, roughness, and metallic maps—turning generated assets into physically based, re-lightable 3D objects for the first time in an open-source pipeline.

1. Executive Summary

Hunyuan3D 2.5 introduces a two-stage 3D diffusion suite that generates high-fidelity textured assets from images, advancing shape generation via a new 10B-parameter foundation model called LATTICE — trained with scaled data and compute to produce sharp, detailed meshes with smooth surfaces — and upgrading texture generation to physical-based rendering (PBR) through a multi-view architecture that jointly synthesizes albedo, metallic, and roughness maps with a shared-attention mechanism for spatial alignment. In evaluations on diverse in-the-wild images, Hunyuan3D 2.5 achieves a 72% win rate in user studies against commercial models and records the best CLIP-FID of 23.97 and FID of 165.8 among texture baselines, while LATTICE attains top ULIP-T (0.07853) and Uni3D-T (0.2542) scores for shape generation, establishing that a scaled native 3D diffusion pipeline with dedicated PBR material modeling can close the gap between generated and handcrafted assets only when both shape and texture stages are independently optimized for detail fidelity rather than treated as a monolithic generation problem.

2. Context and Motivation

The Core Problem: Closing the Detail Gap Between Generated and Handcrafted 3D Assets

The paper tackles a specific, concrete deficiency in the current state of 3D generative modeling: existing models cannot reliably produce 3D shapes and textures with the level of fine-grained detail, surface quality, and material realism expected of professional-grade, handcrafted assets. This is not merely a matter of incremental improvement. As Figure 2 demonstrates, current methods — including the authors' own prior state-of-the-art, Hunyuan3D 2.0 — exhibit systematic failures that render them unsuitable for production pipelines: missing or deformed fine structures (e.g., incorrect finger counts, simplified mechanical parts like bicycle spokes), surfaces that lack sharp edges when needed or appear rough when smoothness is required, and textures that fail to properly model physical material properties (incorrect PBR behavior).

The gap between generated and handcrafted assets is not just aesthetic. For game development, film VFX, VR/AR, and embodied AI simulation, assets must satisfy multiple constraints simultaneously: geometric accuracy to the specified reference, topological cleanliness for downstream rigging and animation, surface continuity for consistent rendering under varied lighting, and physically correct material parameterization for realistic relighting. A model that generates a shape with smooth surfaces but missing fine details, or with sharp details but noisy surfaces, fails on at least one of these axes. The paper positions this multi-dimensional quality requirement — not just "better-looking 3D" but 3D that is simultaneously detailed, sharp-edged, smooth-surfaced, precisely aligned to reference images, and physically shaded — as the central unsolved challenge.

Why This Problem Matters: Production-Grade 3D Generation as an Economic and Creative Bottleneck

The significance of closing this gap extends across multiple industries at scale. The authors note in Section 1 that 3D generation has "rapidly developed in recent years, becoming a core driver of innovation and growth across various industries," citing game development, embodied AI, film special effects, and virtual reality. Each of these domains imposes distinct but overlapping requirements:

For game development, assets must be detailed enough to withstand close-up inspection in real-time rendering, clean enough topology to deform correctly during animation, and PBR-parameterized to integrate with engine lighting pipelines. The current manual asset-creation workflow (concept art → 3D modeling → UV unwrapping → texturing → material assignment) is measured in artist-days per asset. An automated pipeline that produces almost correct assets — but requires manual cleanup of missing details, surface artifacts, or incorrect material parameters — captures only a fraction of the potential labor savings. The economic case for automated 3D generation is binary: it either produces production-ready output or it produces something that still requires expensive artist intervention.

For embodied AI and simulation, the fidelity requirements are different but equally stringent. Training robots or autonomous systems in simulation requires assets whose physical interaction properties (surface friction, reflectance, geometry) correspond faithfully to real-world counterparts. A generated asset with smoothed-out geometric detail or incorrect material roughness will cause a sim-to-real transfer gap that degrades the trained policy's performance. The paper's emphasis on physical-based rendering (PBR) — producing not just RGB textures but explicit albedo, metallic, and roughness maps derived from a principled BRDF model — directly addresses this need for simulation-grade material parameterization.

For film and VR, the standard is photorealism. Generated assets must hold up under varied lighting conditions, camera angles, and close-up inspection. Surfaces must exhibit correct specular highlights, Fresnel effects, and microsurface scattering behavior that depend on physically accurate roughness and metallic parameters. A model that generates RGB textures without decomposing them into material properties will inevitably produce artifacts when relit in a different environment — the shading baked into the texture will conflict with the new lighting.

The paper's central advancement — simultaneously generating detailed shape and PBR material maps in a single pipeline — is therefore not a feature checklist item but a direct response to the multi-industry requirement for production-grade, relightable, physically accurate 3D assets.

Prior Approaches and Their Specific Failures

The paper situates itself within a rapidly evolving landscape of 3D generation methods, describing both the progress and the remaining gaps with technical specificity.

Shape Generation: The Native 3D Diffusion Revolution — and Its Limits

The authors identify a recent paradigm shift in shape generation: the emergence of native 3D diffusion models operating on learned 3D representations rather than relying on 2D-to-3D lifting. Specifically, they cite the 3dshape2vecset representation (Zhang et al., 2023) as foundational, and name CLAY (Zhang et al., 2024b), their own Hunyuan3D 2.0 (Zhao et al., 2025), and TripoSG (Li et al., 2025) as key works in this trajectory. These models represent a significant advance over earlier approaches:

Score distillation-based methods (e.g., DreamFusion; Poole et al., 2023) use 2D text-to-image diffusion models to guide 3D optimization via differentiable rendering. While flexible, these methods are slow (requiring per-asset optimization) and suffer from the Janus problem (multi-face artifacts because the 2D prior has no explicit 3D consistency constraint).
Feedforward methods (e.g., LRM; Hong et al., 2023, Hunyuan3D 1.0; Yang et al., 2024, LGM; Tang et al., 2024) attempt to predict 3D in a single forward pass, trading quality for speed. These are fast but produce relatively coarse geometry.
Autoregressive mesh generation (e.g., MeshGPT; Siddiqui et al., 2024, BPT; Weng et al., 2024, Meshtron; Hao et al., 2024) generates topology directly, which is valuable for artist-compatible edge flow but struggles to scale to high-resolution geometry with the same detail density as diffusion models.

Native 3D diffusion models bypass both the speed-quality tradeoff of feedforward methods and the inconsistency problems of score distillation. By training directly on 3D data with dedicated 3D representations and denoising objectives, they produce coherent shapes that respect the conditioning signal. The paper's own prior work, Hunyuan3D 2.0, demonstrated that this approach could be scaled to generate high-resolution textured assets in a two-stage pipeline (shape then texture).

However, the paper explicitly identifies that even the latest generation of native 3D diffusion models — including Hunyuan3D 2.0 — falls short on detail fidelity. As shown in Figure 2, existing methods:

Fail to generate fine-grained structures: the bicycle wheel pattern is simplified, the number of fingers is incorrect, large scenes with nested objects (e.g., a bowl within a scene) lose internal detail. These are not marginal defects — they are categorical failures that make the output unusable without manual correction.
Produce surfaces that are either too rough or insufficiently sharp: the paper describes a tradeoff in existing models: "Existing models... often struggle to generate sharp edges while maintaining smooth, clean surfaces, particularly for complex objects" (Section 2.1). A model may produce noise-free surfaces at the cost of losing sharp creases and corners, or preserve edges at the cost of introducing surface artifacts. The paper frames Hunyuan3D 2.5's breakthrough as striking "an excellent balance" between these competing requirements.
Plateau in quality despite compute scaling: the implicit message of introducing a new 10B-parameter foundation model is that existing architectures and training recipes were not effectively utilizing additional scale. The authors state they "found that this new model exhibits stable improvement when scaling up the model" (Section 1), suggesting that prior models (including their own) did not exhibit such stable scaling behavior — they either did not benefit from additional parameters and data, or had architectural bottlenecks that prevented translating additional compute into proportionally better generation.

The paper's positioning is therefore: native 3D diffusion is the right paradigm, but the specific architecture, representation, and training recipe must be redesigned to unlock scaling benefits that previous models — even those from the same lab — did not achieve. LATTICE is presented as the result of this redesign, not merely as a larger version of an existing architecture.

Texture Generation: From Inpainting Artifacts to Inconsistent Multi-View to Missing PBR

The texture generation landscape receives a similarly detailed critique, organized historically from earlier, more artifact-prone methods to the still-incomplete current state-of-the-art:

Inpainting-based methods (e.g., Text2Tex by Chen et al., 2023a, Paint3D by Zeng et al., 2024a, TexPainter by Zhang et al., 2024a) generate textures by iteratively rendering views, inpainting gaps, and fusing results back onto the mesh. The paper identifies their fundamental limitation as global consistency: because each view is generated or inpainted with only local context, textures exhibit seams, blending artifacts, and inconsistent details where different views meet. The multi-view re-projection and fusion process can smooth over these discontinuities but cannot eliminate them, and repeated inpainting-fusion cycles compound artifacts rather than resolving them. These methods are acknowledged as pioneering but superseded.

Multi-view diffusion methods (the current dominant paradigm, including the authors' own Hunyuan3D 2.0 and 2.1 texture models) address the consistency problem by generating all texture views jointly with cross-view attention mechanisms. The paper cites Zero123++ (Shi et al., 2023a), MV-Adapter (Huang et al., 2024b), Era3D (Li et al., 2024a), MVDiffusion++ (Tang et al., 2025), and others as establishing this approach. The core idea is that by conditioning each view's generation on all other views through attention layers, the model learns to produce globally consistent textures that project onto the mesh without seams.

However, the paper identifies a persistent limitation even within this improved paradigm: multi-view consistency at generation time does not guarantee artifact-free results after texture baking. When the generated multi-view images are projected onto the UV map and fused, small misalignments between views — invisible when viewing each image independently — manifest as blurring, ghosting, or high-frequency artifacts at texture seams. This is particularly severe at corners, edges, and regions of high curvature where view projections overlap with imperfect correspondence. The paper frames this as a texture-geometry coordination problem: the generated textures must not only be internally consistent across views but also precisely aligned with the underlying 3D geometry.

The PBR gap. Perhaps the most critical gap the paper identifies is that existing open-source texture generation methods produce only RGB textures — flat color images that bake in lighting, shading, and material properties into a single representation. A chair generated with an RGB texture might appear correct under the lighting conditions present during training, but will exhibit incorrect specular highlights, shadows that don't move with the light source, and unnatural reflectance behavior when placed in a different scene or rendered from a novel angle. This fundamentally limits reusability: a generated asset is frozen to its generation-time lighting rather than being a relightable, scene-independent 3D object.

The paper explicitly states that "traditional RGB textures can no longer meet the demands for photorealistic 3D asset generation, while PBR material generation solution is not available in open source community" (Section 1). This is a key positioning claim: the field has solved visual plausibility under training conditions but not physical correctness under arbitrary conditions, and the latter is what production pipelines require. PBR material generation — producing separate albedo (base color without lighting), metallic (metalness coefficient), and roughness (microsurface distribution) maps — is the standard for professional 3D workflows but has not been successfully integrated into open-source generative pipelines.

The paper distinguishes three categories of prior PBR work, none of which meets the combined requirement of being open-source, multi-view consistent, and high-quality:

Generation-based approaches (Vainer et al., 2024a; Sartor & Peers, 2023; Vecchio et al., 2024; Chen et al., 2024a; Zeng et al., 2024b) use diffusion models to learn material priors but are either closed-source, single-view, or lack the multi-view consistency needed for mesh texturing.
Retrieval-based approaches (Zhang et al., 2024c; Fang et al., 2024) adapt materials from pre-built libraries — these produce visually consistent results but cannot create novel material appearances beyond what exists in the library, limiting creative flexibility.
Optimization-based methods (Chen et al., 2023b; Zhang et al., 2024d; Wu et al., 2023; Xu et al., 2023; Yeh et al., 2024; Youwang et al., 2024; Liu et al., 2024b) use Score-Distillation Sampling or similar techniques to refine initial textures — these are slow and often fail to fully decouple illumination from material properties, producing albedo maps with baked-in shading.

How This Paper Positions Itself

Hunyuan3D 2.5 positions itself as the integrated solution to three simultaneous, interacting bottlenecks that prior work addressed only partially or in isolation:

Shape detail fidelity at scale: The LATTICE model is explicitly positioned as a scaling-optimized replacement for previous shape generators, including the authors' own. The paper argues not that native 3D diffusion was the wrong approach, but that the specific architectures and training recipes used previously (including in Hunyuan3D 2.0) did not exhibit stable improvement with additional compute and data. LATTICE is presented as rectifying this, achieving — through unspecified but presumably architectural innovations beyond simple parameter scaling — what the paper calls "extreme detail" with "smooth surfaces and sharp edges" simultaneously.
PBR material generation in a multi-view, open-source framework: The texture generation component is positioned as filling the specific gap of "PBR material generation solution is not available in open source community" while also advancing multi-view consistency through novel attention mechanisms. The dual-channel attention (Equations 1–2) — where the albedo branch's attention mask is shared with the metallic-roughness branch — is presented as solving the spatial misalignment problem that would otherwise cause albedo and MR maps to disagree at pixel boundaries, producing artifacts when the maps are composited in a renderer.
Geometry-texture coordination at high resolution: The dual-phase resolution enhancement strategy (Section 2.2) is positioned as solving the specific problem that training on high-resolution multi-view images is memory-prohibitive, but low-resolution training loses geometric detail necessary for precise texture-geometry alignment. By first training at 512×512 with many views to establish consistency, then fine-tuning with a zoom-in strategy on higher-resolution crops, the model achieves the benefits of both without the full memory cost of high-resolution multi-view training from scratch.

The paper's competitive positioning is made explicit in Section 3's evaluation design: it benchmarks against both open-source baselines (Michelangelo, Craftsman 1.5, Trellis, and their own Hunyuan3D 2.0) and closed-source commercial models (designated as Commercial Model 1 and 2), with user studies (Figure 8) showing a 72% win rate — 9× higher than the nearest commercial competitor. The evaluation strategy signals that the paper sees its primary competition not as academic baselines (which it comfortably outperforms on metrics in Tables 1–2) but as production-deployed commercial systems that represent the current practical ceiling for automated 3D asset generation.

A subtle but important positioning choice: the paper does not claim to have invented the two-stage pipeline, the native 3D diffusion paradigm, the multi-view texture generation approach, or the PBR decomposition framework. Each of these is explicitly credited to prior work, including the authors' own Hunyuan3D 2.0 and 2.1. The claimed contribution is the integration and scaling of these components into a single system that achieves, for the first time, simultaneous excellence in shape detail, surface quality, texture consistency, and physical material correctness — closing the gap to handcrafted assets that no prior method, open-source or commercial, had bridged.

3. Technical Approach

3.1 Reader Orientation

Hunyuan3D 2.5 is a two-stage generative system that takes a 2D image as input and produces a fully textured, physically-based 3D mesh as output. What problem does it solve? It addresses the specific failure of existing 3D generative models to simultaneously produce (1) shapes with both sharp geometric details and smooth surfaces, (2) textures with multi-view consistency and precise geometric alignment, and (3) physically-based rendering (PBR) material maps that enable relighting in any environment. The shape of the solution is a pipeline where a 10-billion-parameter shape diffusion model (LATTICE) first generates a detailed mesh from the input image, and then a multi-view PBR texture diffusion model synthesizes albedo, metallic/roughness, and normal maps conditioned on both the reference image and the geometric properties of the generated mesh. Crucially, the paper is not proposing entirely new paradigms — it builds on the established two-stage architecture of Hunyuan3D 2.0 and the native 3D diffusion framework of 3dshape2vecset — but redesigns the internal architectures, training procedures, and material representations to achieve scaling behavior and detail fidelity that prior models (including the authors' own) did not attain.

3.2 Big-Picture Architecture (Diagram in Words)

The Hunyuan3D 2.5 pipeline has five sequential stages, as shown in Figure 3:

Image Preprocessing: Takes a raw input image, removes the background, and resizes it to a canonical format suitable for conditioning the shape generator. This is a standard normalization step that isolates the object of interest.
Shape Generation (LATTICE): A large-scale 3D diffusion model (up to 10B parameters) trained on high-quality 3D datasets. It conditions on either a single input image or four multi-view images (presumably generated from the single input via a multi-view synthesis model, though this is not detailed in the paper). It outputs a 3D mesh — geometry only, without texture — that represents the object's shape.
Mesh Post-Processing: The generated mesh is processed to extract surface properties needed for texturing: normal maps (encoding surface orientation at each point), UV maps (defining the 2D parameterization of the 3D surface for texture projection), and potentially CCM (curvature or coordinate maps).
Texture Generation (Hunyuan3D-Paint-PBR): A multi-view PBR diffusion model that takes as input the reference image, the normal map, and the CCM from the post-processed mesh. It generates multiple views of PBR material maps — albedo (base color without lighting), metallic (metalness coefficient), and roughness (microsurface distribution), with the latter two combined into a single "MR" channel. A dual-channel attention mechanism ensures spatial alignment between albedo and MR maps.
Output: The generated PBR maps are projected back onto the mesh UV coordinates, producing a final textured 3D asset that can be rendered with physically correct lighting in any engine.

Information flows strictly forward: preprocessing → shape → post-processing → texture → output. There is no feedback loop or iterative refinement between stages in the core architecture (the dual-phase training described later is a training-time strategy, not an inference-time loop).

3.3 Roadmap for the Deep Dive

First, the shape generation model (LATTICE), because it produces the geometric foundation that all subsequent stages depend on. I'll explain what "native 3D diffusion" means in the context of the 3dshape2vecset representation, how LATTICE scales this paradigm to 10B parameters, and what "stable improvement when scaling up" implies about the architecture.
Second, the texture generation architecture (Hunyuan3D-Paint-PBR), covering the multi-view conditioning design, the dual-channel attention mechanism for albedo-MR alignment, and the 3D-aware RoPE that enforces cross-view consistency.
Third, the dual-phase resolution enhancement strategy, which addresses the specific memory bottleneck of training on high-resolution multi-view images while achieving precise texture-geometry alignment.
Fourth, the mesh post-processing and the interfaces between components — what geometric signals (normal maps, CCM) are passed from shape to texture and why these particular signals are chosen.
Fifth, the training procedures and inference optimizations (guidance distillation, step distillation, UniPC sampling) that make the whole pipeline computationally feasible.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems engineering paper where the core idea is that scaling up a native 3D diffusion architecture with redesigned components — specifically, a new shape representation optimized for stable scaling behavior, a PBR material decomposition integrated into a multi-view texture diffusion model, and a dual-phase training strategy for high-resolution geometric alignment — produces 3D assets that close the gap to handcrafted quality. The paper does not introduce a single novel algorithm but rather demonstrates that careful architectural choices in representation, attention mechanisms, and training paradigms enable a previously unachieved combination of shape fidelity, surface quality, multi-view consistency, and physical material correctness.

The 3dshape2vecset Representation: The Foundation of Native 3D Diffusion

To understand LATTICE, we must first understand the underlying 3D representation it operates on. The paper explicitly cites 3dshape2vecset (Zhang et al., 2023) as the foundational representation that "pioneered a revolution in the 3D shape generation pipeline." This representation is the data format that the diffusion model processes — analogous to how 2D diffusion models operate on pixel grids or latent feature grids.

A vecset (vector set) represents a 3D shape as an unordered set of feature vectors. Each vector encodes the geometric and structural properties of a local region of the 3D surface. The key property of a vecset is that it is permutation-invariant: the ordering of vectors in the set does not carry geometric meaning, just as shuffling the pixels of an image destroys its spatial structure. This means the diffusion model must learn to generate a set of vectors whose collective configuration implicitly encodes the 3D shape, without relying on a fixed spatial grid or explicit coordinate system.

The vecset is not the final mesh — it is an intermediate latent representation from which a mesh can be decoded. The encoding/decoding process works as follows:

Encoding (3D shape → vecset): A 3D shape (typically represented as a mesh or point cloud) is passed through a learned encoder that produces a set of $N$ vectors, each of dimension $d$ . These vectors collectively represent the shape's geometry. The encoder is trained to ensure that the vecset captures sufficient information for faithful reconstruction.
Diffusion on vecsets: A diffusion model is trained to generate vecsets from noise, conditioned on some input (an image, text, or both). The diffusion process gradually denoises a randomly initialized set of vectors into a coherent vecset representing the target shape.
Decoding (vecset → mesh): The generated vecset is passed through a learned decoder that produces the final 3D mesh — specifically, a triangle mesh with vertices, faces, and surface normals.

The advantages of this representation for diffusion are substantial:

No spatial grid bias: Unlike voxel grids or triplanes, vecsets do not impose a fixed spatial resolution or axis alignment. The model can allocate representational capacity unevenly — more vectors to complex regions (e.g., a detailed face) and fewer to simple regions (e.g., a flat wall).
Native 3D processing: The diffusion model operates directly on the 3D representation, not on 2D projections, which avoids the consistency problems of score distillation methods.
Permutation invariance is architecturally natural: Transformer architectures (which are permutation-equivariant without positional encodings) are a natural fit for processing vecsets, enabling scalable training.

The paper's LATTICE model builds on this vecset foundation. While the paper does not disclose the specific vecset dimensionality $d$ , the number of vectors $N$ , or the decoder architecture used in LATTICE, it states that the model reaches 10B parameters, implying a very large transformer backbone processing a high-dimensional vecset. The critical claim is that LATTICE exhibits "stable improvement when scaling up the model" — meaning that doubling parameters produces consistent quality gains — which presumably required architectural innovations in how the vecset representation interacts with the conditioning signal and how the denoising objective is formulated, preventing the gradient instability or representation collapse that can occur when scaling permutation-invariant architectures.

LATTICE: The 10B-Parameter Shape Diffusion Model

LATTICE is the shape generation component of Hunyuan3D 2.5, described in Section 2.1 as "a large-scale diffusion model capable of producing high-fidelity, detailed shapes with sharp edges and smooth surfaces from either a single image or four multi-view images." The paper frames LATTICE as a shape foundation model — a term borrowed from the language and vision foundation model literature to imply that it is a general-purpose model trained on broad data that can serve as a base for diverse downstream tasks.

Conditioning Modalities. LATTICE accepts two conditioning configurations:

Single image conditioning: The model takes one 2D image as input and generates a 3D shape consistent with that view. This is the standard image-to-3D setting and the most practically useful for end users.
Multi-view conditioning: The model can also accept four images from different viewpoints, which provides richer geometric information and likely improves reconstruction accuracy, particularly for occluded or ambiguous regions.

The paper does not detail how the image conditioning is integrated into the diffusion architecture. Presumably, the input image(s) are encoded via a vision encoder (possibly a CLIP or DINOv2 variant) into a conditioning embedding, which is then injected into the diffusion transformer's denoising process via cross-attention layers — this is the standard approach in conditional diffusion models (e.g., Stable Diffusion, Hunyuan3D 2.0). The multi-view case likely concatenates or averages the four encoded views into a single conditioning signal.

Training Data and Scale. The paper states that LATTICE is "trained on an extensive and high-quality 3D dataset featuring complex objects." This is deliberately vague — no dataset size, source, or curation procedure is disclosed. However, the emphasis on "high-quality" and "complex objects" is significant: the detail fidelity that LATTICE achieves (correct finger counts, detailed bicycle wheel patterns, nested objects in large scenes, as shown in Figure 4) depends critically on training data that contains such details. A model trained on simplified or low-polygon assets would not learn to generate fine structures regardless of scale. The implication is that the authors invested substantial effort in dataset curation and cleaning, which is consistent with the broader trend in generative AI where data quality is often the binding constraint on generation quality.

Architecture and Scaling. The paper reveals only that the "largest model reaches 10B parameters" and that the authors "found that this new model exhibits stable improvement when scaling up the model." This is a deliberate comparison to Hunyuan3D 2.0, which did not exhibit such stable scaling behavior — suggesting that architectural changes in LATTICE were necessary to unlock the benefits of additional parameters and compute. Without architectural details, we can infer several design principles:

Diffusion formulation: The model likely uses either DDPM (Denoising Diffusion Probabilistic Models; Ho et al., 2020) or flow matching (as used in TripoSG; Li et al., 2025) as the generative framework. The paper does not specify which.
Transformer backbone: Given the 10B parameter count and the vecset representation, the architecture is almost certainly a transformer — diffusion transformers (DiTs) are the dominant scalable architecture for both 2D and 3D generation. The transformer processes the vecset vectors as tokens, attending across them to model global shape structure.
Permutation invariance handling: Since vecsets are unordered, the transformer must either operate without positional encodings (relying on self-attention alone to establish geometric relationships) or use 3D-aware positional encodings that are themselves learned from the vector features. The latter approach — where each vector's "position" is inferred from its content — is more common in recent point cloud and vecset models.
Scaling innovation: The "stable improvement when scaling up" claim implies that LATTICE avoids the degradation that often occurs when scaling permutation-invariant architectures. Possible innovations include improved normalization schemes (e.g., LayerScale, adaptive layer normalization), better conditioning injection (to prevent the model from ignoring the image signal at scale), or a hierarchical vecset design where multiple resolutions of vector sets interact to capture both global structure and fine details.

Guidance and Step Distillation. The paper states that LATTICE employs "guidance and step distillation techniques to reduce inference time." These are standard diffusion model acceleration strategies:

Classifier-free guidance (CFG): During training, the model is trained both conditionally and unconditionally. At inference, the prediction is extrapolated away from the unconditional prediction toward the conditional prediction: $\hat{x}_{\text{cfg}} = \hat{x}_{\text{uncond}} + w(\hat{x}_{\text{cond}} - \hat{x}_{\text{uncond}})$ , where $w > 1$ sharpens the conditioning effect. This improves sample quality at the cost of requiring two forward passes per denoising step. The paper does not specify the guidance scale $w$ used.
Step distillation (also called progressive distillation or trajectory distillation): The diffusion model is trained to produce in fewer steps what an un-distilled model produces in many steps. For example, a student model might learn to predict the output of two teacher denoising steps in a single step, halving inference latency. This is trained by running the teacher model to compute the target at the appropriate timestep offset. FlashVDM (Lai et al., 2025), cited in Section 4, specifically accelerates vecset diffusion models and may be the distillation method used here.

Inference Process. At inference, given an input image, the pipeline proceeds as follows:

The image is encoded into a conditioning embedding.
A set of $N$ vectors is initialized as random noise (Gaussian).
The diffusion model iteratively denoises these vectors over $T$ steps (reduced from the training-time number via step distillation), conditioning on the image embedding at each step.
The final vecset is decoded into a 3D mesh (vertices, faces, normals).
The mesh enters post-processing for texture generation.

The model's outputs, as shown in Figure 4, demonstrate specific capabilities that the paper highlights as novel:

"Extreme Detail": Examples show correct finger counts on hands (a notorious failure case for prior models), detailed bicycle wheel spokes (thin, repetitive geometric structures), and a bowl nested within a larger scene (multi-scale object coherence).
"Smooth Surfaces & Sharp Edges": The second and third rows of Figure 4 show objects with simultaneously noise-free surfaces (no bumpy artifacts) and crisp geometric edges (no smoothing out of creases or corners). This balance is described as previously unachievable.

Why a Foundation Model? The term "shape foundation model" implies that LATTICE is intended to serve as a general-purpose base that can be fine-tuned or adapted for specific shape generation tasks, much like how a language foundation model can be fine-tuned for translation or summarization. The paper does not demonstrate such fine-tuning, but the framing suggests the model captures broad shape knowledge that transfers across categories and styles.

The Hunyuan3D-Paint-PBR Architecture: Multi-View Material Generation

The texture generation component of Hunyuan3D 2.5 is built on the multi-view PBR texture generation architecture first introduced in Hunyuan3D 2.1 (Hunyuan3D et al., 2025), but with several novel extensions described in Section 2.2. Figure 5 provides the architectural diagram.

Inputs and Outputs. The model takes three inputs:

Normal map: Rendered from the generated 3D mesh. Each pixel encodes the surface normal vector (the direction the surface faces) at that point, typically visualized as an RGB image where the R, G, B channels encode the X, Y, Z components of the normal. This provides the texture generator with precise geometric information.
CCM (Coordinate/Curvature Map): Also rendered from the mesh. The paper does not define CCM explicitly, but in the context of 3D texturing, this typically refers to either a canonical coordinate map (encoding the 3D position of each surface point in some canonical reference frame) or a curvature map (encoding the local surface curvature — convex vs. concave, degree of bending). Both provide geometric cues that help the texture generator understand surface topology.
Reference image: The original input image that the user provided. This provides the visual appearance target — the generated textures should match the colors, patterns, and material types visible in this reference.

The model outputs three material maps (per generated view):

Albedo map: The base color of the surface — the diffuse reflectance without any lighting, shading, or specular effects. This is what the surface "looks like" under perfectly uniform white illumination.
Metallic map: A scalar value per pixel (0 to 1) indicating whether the surface is dielectric (0, e.g., plastic, wood, fabric) or metallic (1, e.g., steel, gold, aluminum). Metals reflect light differently from dielectrics — they exhibit colored specular highlights and no diffuse component — so this parameter crucially affects rendering.
Roughness map: A scalar value per pixel (0 to 1) indicating the microsurface smoothness. A roughness of 0 produces mirror-like specular reflections; a roughness of 1 produces completely diffuse, blurry reflections.

The metallic and roughness maps are combined into a single "MR" channel (2 channels total, concatenated along the channel dimension). This is a practical design choice: metallic and roughness are both scalar fields that describe surface microgeometry and reflectance type, and processing them jointly through shared attention mechanisms (as we will see) helps maintain alignment between them.

Two-Branch Architecture. Figure 5 shows the model has two parallel branches with shared attention:

Reference Branch: Processes the input reference image. This branch encodes the visual appearance information (colors, textures, material types) that will guide the texture generation.
Generation Branch: Processes the normal map and CCM from the mesh. This branch encodes the geometric information that ensures the generated textures align with the 3D surface.

Both branches contain convolutional input layers ("Conv-In") and transformer blocks with multi-task attention. The key insight of the architecture is that these branches are not independent — they interact through shared attention mechanisms that allow the generation branch to query the reference branch for appearance information while maintaining geometric coherence.

Multi-Task Attention Block. The core computational unit, shown in the lower half of Figure 5, contains three attention operations:

3D-Aware Rotary Position Embedding (RoPE): This is inherited from Hunyuan3D 2.1 and the RoManTex model (Feng et al., 2025). Standard RoPE encodes token positions with sinusoidal functions that preserve relative position information through rotation matrices:

$f_{\text{RoPE}}(x, m) = x \cdot R_m$

where $x$ is the token embedding (in complex or paired representation), $m$ is the token's position index, and $R_m$ is a rotation matrix parameterized by the position $m$ .

What it computes: a position-dependent rotation applied to the query and key vectors before the attention dot product. For a pair of tokens at positions $m$ and $n$ , the attention score becomes $q_m^T R_{m-n} k_n$ , which depends only on the relative distance $m-n$ , not absolute positions.

Why this form: In 3D-aware RoPE, the position $m$ is not a 1D sequence index but a 3D spatial coordinate (e.g., the camera position or the surface point coordinate). This means that tokens corresponding to nearby 3D locations have similar RoPE encodings, encouraging the attention mechanism to focus on spatially proximate views. This directly enforces cross-view consistency: when generating the texture for one view, the model attends more strongly to other views of the same surface region, reducing the seam artifacts that plague view-independent texture generation.
Multiview Attention: An attention mechanism that specifically models interactions between different generated views. In standard multi-view diffusion, multiple views are generated simultaneously, and cross-view attention allows each view's features to attend to all other views, ensuring that textures are consistent when projected onto the mesh from different angles.
Self Attention: Standard self-attention within each branch (reference and generation), allowing tokens to attend across spatial positions within a single view or within the reference image.

The Reference Block (Figure 5, lower section) contains a residual block (ResBlock) followed by self-attention and cross-attention. The cross-attention allows the generation branch to query the reference branch's features, injecting appearance information from the reference image into the texture generation process.

Multi-Channel Material Generation with Learnable Embeddings. A key innovation over Hunyuan3D 2.1 is the mechanism for generating three distinct but spatially aligned material maps. The paper introduces learnable embeddings for each material channel:

$E_{\text{albedo}}, E_{\text{mr}}, E_{\text{normal}} \in \mathbb{R}^{16 \times 1024}$

where each embedding is a 16-token sequence of 1024-dimensional vectors.

What this represents: Each embedding is a learned "query" that the model uses to extract channel-specific information from the shared feature representations. The 16 tokens per embedding provide enough capacity to encode the distribution characteristics of that material channel (e.g., that albedo maps have rich color variation, that MR maps are mostly smooth scalar fields, that normal maps encode surface orientation patterns).

How they are used: These embeddings are injected into the generation process via cross-attention layers — the shared image features serve as keys and values, while the channel-specific embeddings serve as queries. This allows the same underlying multi-view feature maps to be decoded into three different material maps, each with its own characteristics, without requiring entirely separate generation networks.

Why 16 tokens: Sixteen tokens provide a compact but expressive summary of the channel's expected behavior. Too few tokens would not capture channel-specific statistics; too many would add unnecessary parameters and risk overfitting to training-set material distributions. The dimensionality of 1024 matches the internal feature dimension of the diffusion transformer, allowing direct integration without projection layers.

Dual-Channel Attention for Albedo-MR Alignment. This is the most technically novel contribution in the texture generation section and solves a specific, concrete problem: when generating albedo and metallic-roughness maps independently, the two maps can become spatially misaligned — the albedo texture might place a wood pattern in a slightly different location than the roughness map's grain pattern, producing obvious artifacts when the maps are composited in rendering.

The paper identifies the root cause through "systematically examining the reference attention module": misaligned attention masks. The reference attention mechanism uses attention scores to decide which regions of the reference image to copy appearance from. If the albedo and MR branches compute different attention masks — attending to different parts of the reference for the same output pixel — the resulting maps will disagree spatially.

The solution is deliberately simple and elegant: share the attention mask across channels while computing separate value transformations.

Step 1: Compute the attention mask from the albedo (basecolor) channel only:

$M_{\text{attn}} = \text{Softmax}\left(\frac{Q_{\text{albedo}} K_{\text{ref}}^T}{\sqrt{d}}\right) \quad (1)$

where:

$Q_{\text{albedo}}$ is the query matrix from the albedo channel's features (what each output pixel in the albedo map is "looking for" in the reference)
$K_{\text{ref}}$ is the key matrix from the reference image features (what each reference image pixel can provide)
$d$ is the feature dimension (1024), used as a scaling factor to prevent the dot products from growing too large
Softmax normalizes the scores into a probability distribution over reference pixels for each output pixel

What it computes: For each output pixel position in the texture, a probability distribution over all spatial positions in the reference image. The distribution indicates which reference pixels are most relevant for determining the appearance at that texture location. The softmax ensures these weights are non-negative and sum to 1.

Why the albedo channel specifically: The paper states that "the basecolor branch contains the most semantically similar information to the reference image (both exist in the common RGB color space)." In other words, because albedo and reference images are both color images representing surface appearance (just under different illumination), the attention that successfully transfers reference colors to albedo colors is likely the correct attention for determining which part of the reference corresponds to which part of the surface. The MR channels, by contrast, represent material properties (metalness, roughness) that have no direct analog in the RGB reference, so their independently computed attention masks might be noisier or less semantically grounded.

Step 2: Apply the same attention mask to compute new features for both channels using separate value matrices:

$\begin{aligned} z_{\text{albedo}}^{\text{new}} &= z_{\text{albedo}} + \text{MLP}_{\text{albedo}}[M_{\text{attn}} \cdot V_{\text{albedo}}] \\ z_{\text{MR}}^{\text{new}} &= z_{\text{MR}} + \text{MLP}_{\text{MR}}[M_{\text{attn}} \cdot V_{\text{MR}}] \end{aligned} \quad (2)$

where:

$z_{\text{albedo}}$ and $z_{\text{MR}}$ are the feature maps for the albedo and metallic-roughness channels before the attention update
$V_{\text{albedo}}$ and $V_{\text{MR}}$ are the value matrices from the reference image, computed separately for each channel (these are what the attention mechanism "reads out" from the reference)
$M_{\text{attn}} \cdot V_{\text{channel}}$ is the attention-weighted sum of reference values — for each output pixel, it combines reference information weighted by how relevant each reference pixel is
$\text{MLP}_{\text{albedo}}$ and $\text{MLP}_{\text{MR}}$ are channel-specific multi-layer perceptrons that transform the attended features into the appropriate feature space for each channel
The addition to $z$ is a residual connection — the attended features are added to the original features rather than replacing them

What this computes: For each output pixel and each channel, a summary of reference image information relevant to that pixel's location, transformed into the appropriate feature representation for that channel's material map.

Why this form: The crucial innovation is that $M_{\text{attn}}$ — the selection of which reference pixels to attend to — is shared between albedo and MR, while $V$ and MLP — the interpretation of what that reference information means — are channel-specific. This enforces spatial coherence: both channels base their features on the same reference regions, so the resulting albedo and MR maps are spatially aligned by construction. If the independently computed attention masks were misaligned by even a few pixels, the resulting maps would place material transitions at different spatial positions, causing visible seams or ghosting in the rendered output.

Illumination-Invariant Consistency Loss. The paper briefly mentions incorporating "an illumination-invariant consistency loss during training to enforce the disentanglement of material properties and illumination components," referencing He et al. (2025) for details. This addresses a fundamental problem in PBR material generation from images: the reference image contains both the intrinsic material properties of the object AND the lighting conditions under which it was photographed (directional light casts shadows and creates specular highlights; ambient light fills in shadows). The generator must learn to separate these — to produce an albedo map that contains only the surface color without any shading, even though the reference image has shading baked in.

The illumination-invariant consistency loss likely works as follows:

Generate PBR maps for the same object under different synthetic lighting conditions.
Render the object under those lighting conditions using the generated PBR maps and a differentiable renderer.
Compute a loss that penalizes changes in the generated PBR maps when the lighting changes — the material properties (albedo, metallic, roughness) should be intrinsically the same regardless of how the object is lit.
This forces the model to push lighting-dependent variation into the rendering process and keep the generated maps lighting-independent.

The paper's decision to reference He et al. (2025) rather than detailing the loss suggests this is a complex component with nuanced implementation choices that are not the primary contribution of Hunyuan3D 2.5 but are necessary for correct PBR behavior.

3D-Aware RoPE: Enforcing Cross-View Consistency

The RoManTex model (Feng et al., 2025), cited as the source of the 3D-aware RoPE, represents a specific approach to the cross-view consistency problem that the paper inherits directly. Standard rotary position embeddings (RoPE) encode 1D sequence positions. 3D-aware RoPE extends this to 3D spatial coordinates:

Each token (representing a patch of a generated view) is associated with a 3D coordinate — specifically, the 3D position of the pixel on the object's surface that this patch corresponds to, derived from the mesh geometry and camera parameters for that view.
The RoPE encoding uses this 3D coordinate (or a projection of it) as the "position" in the rotation formula.
The result is that the attention mechanism naturally favors tokens that are spatially proximate on the 3D surface, regardless of which view they come from. Two tokens from different views that both correspond to the same spot on the 3D model (e.g., the tip of the nose, seen from two different camera angles) will have similar RoPE encodings and will attend strongly to each other.

This is a geometry-conditioned inductive bias: rather than forcing the model to learn from data that different views should be consistent (which works imperfectly, leaving seam artifacts), 3D-aware RoPE architecturally encourages consistency by making cross-view attention depend on 3D proximity. The model can still override this bias if necessary (for example, to model view-dependent effects like Fresnel reflections that genuinely vary with viewing angle), but the default behavior is consistency.

The paper's contribution here is not the invention of 3D-aware RoPE but its integration into the PBR texture generation pipeline as the mechanism that enables multi-view PBR maps to project onto the mesh without seams or misalignment — a problem that prior multi-view RGB texture methods (including Hunyuan3D 2.0) only partially solved.

The Dual-Phase Resolution Enhancement Strategy

This is described in Section 2.2 as the solution to a specific training bottleneck: how to achieve high-resolution texture-geometry alignment without running out of GPU memory during training.

The Problem. The paper identifies a critical dependency: "higher-resolution images preserve richer high-frequency geometric details while mitigating VAE compression losses, thereby significantly enhancing geometric conditioning." In plain language: if you train the texture generator on low-resolution images (e.g., 256×256), the VAE encoder's compression smooths over fine geometric details, and the model never learns to align textures with those details. But training on high-resolution multi-view images requires memory proportional to (resolution² × number_of_views), which for, say, 768×768 images with 6 views is prohibitively expensive on current hardware. The direct approach — reducing the number of views to fit higher resolution — "deteriorates the model's capability for dense-view inference" because the multi-view attention has fewer views to enforce consistency from.

Phase 1: Foundation Training (Low Resolution, Many Views). The first phase follows the methodology of Hunyuan3D 2.0, training on "6-view 512×512 images." The 512×512 resolution is high enough to capture major geometric features while keeping memory manageable with 6 views. This phase establishes:

Multi-view consistency: The cross-view attention and 3D-aware RoPE learn to produce textures that are consistent across different viewpoints.
Basic texture-geometry correspondence: The model learns the fundamental mapping from normal/CCM maps to texture appearance at medium resolution.
Reference image conditioning: The dual-channel attention learns to transfer appearance from the reference image to the generated views.

This training is conventional multi-view diffusion training, not fundamentally different from Hunyuan3D 2.0's training recipe except for the PBR material output.

Phase 2: Zoom-In Fine-Tuning (High Resolution, Fewer Effective Views). The second phase introduces the novel "zoom-in training strategy." The key idea is to train the model to handle high-resolution detail without ever constructing a full high-resolution multi-view batch in GPU memory. Here's how it works:

For each training sample, randomly crop and zoom into a region of both the reference image and the multi-view generated images. The crop is resized to the same training resolution (presumably 512×512), so the model sees a magnified version of a local region.
Because the crop is local, the model learns to generate textures at what is effectively higher resolution — the 512×512 crop corresponds to, say, a 1024×1024 or 1536×1536 equivalent resolution for the full image, depending on the zoom factor.
The zoom is applied randomly during training, so the model sees both full-frame context (when the crop is large or the zoom factor is 1) and zoomed-in detail (when the crop is tight and the zoom factor is high).

What this achieves computationally: The model processes the same number of tokens per batch during Phase 2 as during Phase 1 (since the resolution is identical after resizing), but each token now represents a smaller spatial region of the original image — effectively a higher-resolution sample. The GPU memory cost is identical to Phase 1, yet the model learns to represent fine details.

What this achieves for quality: The model learns to generate textures that are not just consistent across views at coarse scale but also precisely aligned with high-frequency geometric features. At inference time, the model can be run at up to 768×768 resolution (higher than the training resolution) because the zoom-in training taught it the mapping from geometry to texture at a finer scale than would be possible with only full-frame 512×512 training.

Inference Resolution. The paper states that during inference, the model uses "multi-view images at up to 768×768 resolution, accelerated by the UniPC sampler (Zhao et al., 2023) for efficient high-quality generation." UniPC is a predictor-corrector sampler for diffusion models that achieves high-quality samples in fewer steps than standard DDIM or DPM-Solver samplers, making the memory and time cost of 768×768 generation more manageable. The key point is that the model generalizes to higher resolution at inference than it saw during training because the zoom-in phase taught it to handle fine-scale geometric conditioning — the model essentially learns an internal upsampling capability.

Mesh Post-Processing: The Interface Between Shape and Texture

Between shape generation and texture generation, the generated mesh undergoes post-processing to extract the geometric signals that the texture generator requires. The paper mentions this step briefly in the pipeline description (Figure 3): "The mesh is further processed to extract normal, UV map, and etc."

Normal Map Extraction. For each view that will be generated, the mesh is rendered from that camera angle to produce a normal map — an image where each pixel's RGB value encodes the surface normal vector at the corresponding point on the 3D mesh. Mathematically, if the surface normal at a point is $\mathbf{n} = (n_x, n_y, n_z)$ (a unit vector), the pixel value is typically $(\frac{n_x+1}{2}, \frac{n_y+1}{2}, \frac{n_z+1}{2})$ , mapping the $[-1, 1]$ range to $[0, 1]$ for image storage.

Normal maps are the primary geometric conditioning signal for the texture generator because they encode:

Surface orientation: Which direction the surface faces, which determines how light interacts with it and thus constrains plausible texture patterns.
Fine geometric detail: Even details too small to be efficiently represented as explicit mesh vertices (e.g., wrinkles, pores, fabric weave) appear in the normal map as high-frequency variations.
Occlusion boundaries: Regions where the normal vector changes sharply (edges, corners, creases) signal to the texture generator where texture seams and material transitions are appropriate.

CCM Extraction. The paper mentions CCM (Coordinate/Curvature Map) without definition. In practice, this could be either:

Canonical coordinate map: For each rendered pixel, the 3D position of the corresponding surface point in some canonical coordinate system (e.g., normalized object coordinates where the object fits in a $[-1, 1]^3$ box). The RGB channels encode the X, Y, Z coordinates. This provides the texture generator with absolute spatial position information — knowing that a pixel corresponds to the "left arm" rather than the "right arm" of the mesh helps maintain texture consistency.
Curvature map: For each rendered pixel, the local surface curvature — mean curvature (average of principal curvatures) and/or Gaussian curvature (product of principal curvatures). This highlights edges, ridges, valleys, and flat regions, providing geometric information complementary to normals.

Given the context, CCM likely refers to a coordinate map, since the paper emphasizes the importance of precise geometry-texture alignment and knowing the absolute position on the mesh helps the model produce consistent textures. The "C" might stand for Canonial or Coordinate.

UV Map Generation. The mesh must be UV-unwrapped — a process of mapping the 3D surface onto a 2D plane so that textures can be stored as 2D images. The paper does not detail how UV unwrapping is performed; standard approaches involve automatic unwrapping algorithms (minimizing distortion and seam length) or learned UV parameterization models. The quality of the UV unwrapping significantly affects texture quality: poorly placed seams cause visible discontinuities; high distortion squashes/stretches the texture.

Interface Implications. The post-processing stage is a critical interface that determines whether shape generation errors propagate to texture quality. If the shape generator produces a mesh with degenerate triangles, non-manifold edges, or inconsistent normals, the rendered normal and CCM maps will contain artifacts that the texture generator receives as conditioning and may amplify. The paper does not discuss robustness to shape artifacts, but this is presumably addressed through mesh cleanup operations in post-processing (e.g., removing degenerate faces, recomputing smooth normals, fixing non-manifold vertices).

Training Procedures and Inference Optimizations

The paper is sparse on training details for the shape model but provides specific information for the texture and overall optimization strategies.

LATTICE Training. The paper states only that LATTICE is "trained on an extensive and high-quality 3D dataset featuring complex objects" at scale (10B parameters). No training hyperparameters (optimizer, learning rate, batch size, number of diffusion timesteps, loss function details) are disclosed. This is a notable gap: reproducing the scaling behavior that the paper claims would require knowing the training recipe, but the paper focuses on the architectural contributions and treats the training as infrastructure rather than method.

Hunyuan3D-Paint-PBR Training. The texture model training is described in more detail:

Phase 1 (foundation): Multi-view training with 6 views at 512×512 resolution, following Hunyuan3D 2.0's methodology. The views are presumably arranged with fixed camera positions (e.g., at 60-degree azimuth intervals around the object, with a fixed elevation). The training loss is the standard diffusion denoising objective (predicting the noise added to the latent representation of the PBR maps) plus the illumination-invariant consistency loss from He et al. (2025).
Phase 2 (zoom-in): The same 512×512 resolution is maintained, but random zooms are applied to both the reference image and the multi-view generated images before input. The zoom transform presumably includes random cropping, scaling, and possibly rotation to prevent the model from overfitting to specific zoom levels.
Multi-channel training: The three material maps (albedo, MR, generated normal — note that "generated normal" here is distinct from the input normal map; the model also generates a refined normal map as part of the texture to capture surface detail beyond the geometric mesh resolution) are trained jointly, with the dual-channel attention mechanism applied to the albedo and MR channels as described.

Inference Optimizations.

Guidance distillation (shape model): The diffusion model is trained to produce in fewer steps what an un-distilled model produces in many steps. This is likely progressive distillation, where a teacher model (with, say, 1000 denoising steps) trains a student model to match its output in half the steps, and the process is repeated. The paper does not specify the final number of inference steps.
Step distillation (shape model): A similar acceleration technique, likely combined with or equivalent to the guidance distillation.
UniPC sampler (texture model): The UniPC sampler (Zhao et al., 2023) is a unified predictor-corrector framework that accelerates diffusion sampling by adaptively choosing step sizes based on the predicted trajectory curvature. The predictor step estimates the next sample using a high-order ODE solver; the corrector step refines the estimate using the score function. This achieves higher quality at very low step counts (e.g., 5–10 steps) compared to standard samplers like DDIM or DPM-Solver.

Hardware and Throughput. The paper does not disclose training or inference hardware, training time, or GPU memory consumption. Given the 10B parameter shape model and multi-view texture generation at 768×768, inference likely requires multiple high-end GPUs (e.g., A100-80GB or H100-80GB) with tensor parallelism or pipeline parallelism to fit the model in memory, though the step distillation and UniPC sampling reduce the total FLOPs per generation.

Design Choices and Their Justifications: A Summary

The paper makes several deliberate architectural and training choices, each with an identifiable justification:

Two-stage pipeline (shape then texture) over end-to-end generation: Decoupling geometry from appearance allows each stage to be optimized independently for its specific requirements — the shape model can focus purely on 3D reasoning without the additional burden of material and color generation, and the texture model can assume a fixed, correct geometry as conditioning rather than having to simultaneously infer shape and appearance. This also allows the stages to be scaled and improved independently, as demonstrated by upgrading the shape model to LATTICE while the texture model is extended from Hunyuan3D 2.0/2.1.
Vecset representation over voxel grids, point clouds, or triplanes: Vecsets provide an unordered set representation that naturally handles the permutation invariance of 3D shape (there is no canonical ordering of surface points), supports variable resolution (more vectors for complex regions, fewer for simple ones), and is compatible with transformer architectures that scale well with compute.
PBR material decomposition over RGB-only textures: RGB textures bake lighting into the color channels, making generated assets unusable in relightable scenes. PBR decomposition into albedo, metallic, and roughness maps follows the industry-standard Disney/GGX BRDF model and ensures the generated assets can be used in any rendering engine with arbitrary lighting.
Dual-channel shared attention over independent channel generation: Sharing the attention mask from the albedo channel to the MR channel prevents spatial misalignment that would arise if each channel independently decided which reference regions to attend to, while still allowing each channel to interpret reference information differently through separate value projections and MLPs.
Dual-phase resolution enhancement over direct high-resolution training: Training on 6-view 768×768 images from scratch would exceed GPU memory limits. The two-phase approach achieves the benefits of both multi-view consistency (from the 6-view foundation phase) and high-resolution detail (from the zoom-in phase) without the memory cost. The zoom-in strategy is a clever form of data augmentation that teaches the model to handle fine-scale geometric conditioning without requiring the model to process more tokens per batch.
3D-aware RoPE over learned positional embeddings: Learned embeddings would need to generalize to unseen 3D positions and view configurations, which is difficult. RoPE provides a principled geometric inductive bias — attention naturally decays with 3D Euclidean distance between surface points — that is architecture-level rather than data-dependent.
Guidance and step distillation over full-step sampling: The 10B-parameter shape model running a full 1000-step diffusion process would be impractically slow for interactive use. Distillation amortizes the cost of many inference steps into training time, and while there is typically a small quality tradeoff, the paper's results demonstrate that distilled models maintain sufficient quality for production use.

4. Key Insights and Innovations

Innovation 1: Scaling Laws for 3D Shape Diffusion Require Architectural Redesign, Not Just Bigger Models

The most consequential conceptual move in Hunyuan3D 2.5 is not that LATTICE is a 10B-parameter model — it is the paper's implicit claim that scaling 3D shape diffusion models is not a simple matter of adding parameters and data to existing architectures. The paper states that the authors "found that this new model exhibits stable improvement when scaling up the model" (Section 1), positioning LATTICE against their own prior work, Hunyuan3D 2.0, which did not exhibit such stable scaling behavior despite also being a native 3D diffusion model operating on the 3dshape2vecset representation.

This is a diagnostic insight with implications beyond raw performance. The field has largely imported the "bigger model + more data = better results" scaling narrative from language and 2D image generation without interrogating whether 3D representations obey the same smooth scaling laws. The Hunyuan3D 2.0-to-2.5 trajectory suggests they do not — at least not without architectural innovations that the paper points to but does not fully specify. The implication is that permutation-invariant set representations (vecsets) pose unique scaling challenges that grid-based representations (pixels, voxels) do not. Specifically, when scaling a transformer that processes unordered vectors, the model must learn to establish geometric relationships purely through content-based attention rather than spatial proximity priors that are built into convolutional architectures. At small scale, the model can learn these relationships from data; at large scale, the optimization landscape may become pathological — gradient interference between the competing demands of modeling local surface detail and global shape structure, or attention collapse where all vectors attend to the same few dominant vectors, losing the representational diversity that makes vecsets powerful.

The paper does not diagnose the exact failure mode, but the framing — "stable improvement when scaling up" as a discovery rather than an assumption — reframes the 3D generation scaling problem from an engineering challenge (acquire more GPUs, larger datasets) to an architectural research problem (design representations and attention mechanisms that admit smooth scaling). This is analogous to the insight that led from RNNs to Transformers in language: LSTMs technically scale but exhibit diminishing returns; the self-attention mechanism was necessary to unlock the scaling curve we now take for granted. LATTICE may represent a similar inflection point for 3D diffusion, though the paper's lack of architectural detail makes it impossible to identify exactly which change enabled the scaling.

Evidence and limitations. The claim of stable scaling is supported by output quality in Figure 4 — generated shapes exhibit both "extreme detail" (correct finger counts, detailed bicycle spokes, multi-scale scenes) and "smooth surfaces with sharp edges" simultaneously — capabilities that prior models at smaller scale (including Hunyuan3D 2.0, shown in Figure 2) did not achieve. However, the absence of scaling curves (performance vs. parameter count at multiple model sizes) means this insight is inferred from a single data point (10B vs. presumably smaller prior models) rather than empirically demonstrated. The paper's contribution here is the framing of scaling as a problem requiring architectural co-design, not the empirical proof of a scaling law.

Innovation 2: Shared Attention Mask as a Lightweight Solution to Multi-Material Map Alignment

The dual-channel attention mechanism (Equations 1–2) solves a specific, previously unarticulated problem in multi-material generation: how to generate multiple spatially aligned PBR maps without introducing an explicit correspondence loss or architectural complexity. The insight is conceptual, not mechanical — it identifies the root cause of albedo-MR misalignment (independently computed attention masks attending to different reference regions) and addresses it through a minimalist intervention (sharing the mask, not the values or the post-attention processing).

Prior work on multi-channel image generation — including standard approaches like generating RGB channels jointly through a single decoder — provides implicit alignment because all channels are produced from shared features. But in the Hunyuan3D-Paint-PBR architecture, the albedo and MR channels are decoded via separate learnable embeddings $(E_{\text{albedo}}, E_{\text{mr}} \in \mathbb{R}^{16 \times 1024})$ injected through independent cross-attention layers. This separation is necessary because albedo (RGB color) and MR (scalar material properties) occupy fundamentally different distribution spaces — a single shared decoder would struggle to model both simultaneously. But the separation creates the alignment problem that the shared attention mask solves.

The elegance of the solution lies in what it does not do: it does not add a spatial consistency loss term (which would require tuning a loss weight and might conflict with the diffusion objective), does not add a separate alignment network, and does not require architectural changes beyond reusing an already-computed attention matrix. It is a one-line change — compute M_attn from Q_albedo and apply it to V_MR — that leverages the existing attention computation to enforce spatial coherence. This is a design pattern, not a method: identify the point in the architecture where independent decisions are made for dependent outputs, and couple them at that point without constraining their independent processing elsewhere.

The paper's systematic diagnosis — "after systematically examining the reference attention module, we found that the main cause of multi-channel misalignment lies in the misaligned attention masks" — is as important as the solution. It demonstrates a debugging methodology for generative architectures that produces targeted fixes rather than trial-and-error loss term additions. And the specific choice of sharing the albedo channel's mask (rather than the MR channel's mask, or averaging them) has a principled justification: the albedo channel and reference image share the RGB color space, making the albedo-to-reference attention more semantically grounded than the MR-to-reference attention. This choice would not be obvious without the diagnostic step.

Evidence and significance. The paper does not provide an ablation isolating the dual-channel attention's contribution (no "with vs. without shared mask" quantitative comparison is reported). However, the qualitative results in Figure 7 show generated PBR maps where albedo and MR are visibly aligned — material transitions occur at the same spatial positions in both maps — while competing methods (Table 2) "struggle to accurately estimate the correct MR (metallic and roughness) values" and fail to decouple illumination from albedo. This is an incremental contribution technically (it is a modification to an existing attention mechanism) but a fundamental insight diagnostically (it reframes a generation quality problem as an attention mask alignment problem and provides a solution pattern that generalizes to any architecture where multiple output modalities attend to a shared reference).

Innovation 3: Zoom-In Training as a Resolution-Memory Decoupling Strategy

The dual-phase resolution enhancement strategy embodies an insight that is simple in retrospect but was not obvious before the paper articulated the specific bottleneck: the memory cost of multi-view training scales with (resolution² × views), creating a false choice between high resolution with few views and lower resolution with sufficient views — but these can be decoupled through a training curriculum. The insight is that multi-view consistency and high-resolution geometric alignment are learned at different stages and can be trained sequentially with different data configurations.

Prior work in multi-view generation (including Hunyuan3D 2.0 and virtually all concurrent methods) treats resolution and view count as coupled hyperparameters: you pick a resolution and a view count that fit in GPU memory, train end-to-end, and accept the tradeoff. The paper's key diagnostic claim is that this tradeoff is unnecessarily restrictive because multi-view consistency is a coarse-scale property that can be learned at lower resolution with many views, while geometric alignment is a fine-scale property that can be learned on zoomed crops that simulate high resolution without actually requiring full high-resolution multi-view batches.

This reframes the training problem from "how do we fit large tensors in memory?" to "how do we sequence learning so that the model acquires complementary capabilities without simultaneously requiring the memory-intensive combination?" It is analogous to curriculum learning in reinforcement learning (start with easy tasks, progress to hard ones) but applied to a specific representational bottleneck rather than task complexity. The "zoom-in" is not just data augmentation — it is a form of resolution upsampling training where the model learns to generate fine detail from the same token budget, effectively learning an internal super-resolution capability.

The practical significance is substantial: the strategy should generalize to any multi-view generation problem where (1) memory constraints prevent simultaneous high-resolution multi-view training, and (2) there exists a natural decomposition of the learning problem into a coarse consistency phase and a fine detail phase. This includes multi-view novel view synthesis, video generation, and potentially even large-context language modeling where long-range consistency and local detail might benefit from phased training.

Evidence. The paper demonstrates that models trained with this strategy can generate at 768×768 resolution at inference despite being trained at 512×512 (with zoom augmentation), and the visual results in Figure 7 show textures with crisp detail and geometric precision. The improvement over Hunyuan3D 2.0 (which lacked this strategy) is evident in the quantitative metrics: CLIP-FID of 23.97 vs. the next-best Paint3D at 26.86 (Table 2). However, as with the dual-channel attention, no direct ablation (with/without Phase 2) is reported. This innovation is incremental as a training technique (curriculum learning and data augmentation are well-established) but fundamental as an insight about the decomposability of multi-view consistency and geometric alignment learning — and it provides a transferable pattern for other memory-constrained multi-view training problems.

Innovation 4: PBR Material Generation as a First-Class Open-Source Capability

The paper's explicit claim that "PBR material generation solution is not available in open source community" (Section 1) frames Hunyuan3D 2.5's texture component as filling a capability gap rather than advancing a metric. This is a different kind of contribution: it is about making a specific functionality — joint generation of albedo, metallic, and roughness maps in a multi-view consistent, open-source pipeline — available to practitioners for the first time.

Prior PBR material generation work falls into three categories the paper identifies (Section 4): generation-based (closed-source or single-view), retrieval-based (limited to pre-existing materials), and optimization-based (slow and incomplete in illumination-material disentanglement). None of these provide what Hunyuan3D 2.5 provides: a diffusion-based model that generates novel PBR maps from an image in a single forward pass with multi-view consistency suitable for mesh texturing, released as part of an open-source pipeline.

The intellectual contribution here is not algorithmic novelty (the PBR decomposition is based on the standard Disney/GGX BRDF, and the training includes an illumination-invariant loss from He et al., 2025) but systems integration: combining the right material representation, the right attention mechanisms, the right training objectives, and the right inference optimizations to produce a model that outputs production-grade PBR maps rather than just RGB textures. This matters because PBR output fundamentally changes what generated assets can be used for — relighting, integration into game engines, physically accurate simulation — in ways that RGB textures cannot support. By making this capability open-source, the paper potentially shifts what the broader community considers the "standard" output of a 3D generation pipeline, much as Stable Diffusion shifted the standard for 2D image generation from closed APIs to open weights.

Evidence and limitations. The evaluation demonstrates PBR-specific quality indirectly: competing methods in Table 2 produce RGB textures only, and the qualitative comparison in Figure 7 shows that "competing models struggle to accurately estimate the correct MR (metallic and roughness) values, and face challenges in decoupling the inherent illumination effects in the input images for the albedo component." The user study (Figure 8) showing a 72% win rate against commercial models is based on end-to-end textured results, which includes PBR quality implicitly but does not isolate it. The lack of PBR-specific metrics (e.g., relighting consistency, BRDF parameter accuracy against ground truth) means the PBR quality claim is supported visually and by user preference, not by material-property ground truth. This innovation is incremental as a technical contribution (it synthesizes existing PBR, multi-view diffusion, and attention mechanisms) but potentially field-shifting as a capability release, depending on whether the open-source release matches the paper's described performance and whether the community adopts PBR output as the new standard for 3D generation.

5. Experimental Analysis

Evaluation Methodology

Dataset. The evaluation is conducted on a test set of "diverse real-world images from various categories" collected by the authors (Section 3.2, user study description). No standard benchmark dataset (such as GSO, OmniObject3D, or Objaverse subsets) is cited for the quantitative shape or texture evaluations. For shape metrics (Section 3.1), similarity scores are computed between generated meshes and "input images as well as image prompts synthesized by the vision-language model" InternVL (Chen et al., 2024b), implying that the test images themselves serve as the reference without access to ground-truth 3D geometry. For texture metrics (Section 3.2), the paper reports FID, CLIP-FID, LPIPS, CMMD, and CLIP-I without specifying what constitutes the "ground truth" distribution or reference images against which these are computed. This is a significant gap: without specifying the evaluation dataset's size, composition, or provenance, the reported metrics cannot be contextualized or compared to other papers that use standard benchmarks.
Base model(s). The shape generation component is LATTICE, described as "a large-scale diffusion model... our largest model reaches 10B parameters" (Section 2.1). The texture generation component is Hunyuan3D-Paint-PBR, extended from Hunyuan3D 2.0 and 2.1 (Zhao et al., 2025; Hunyuan3D et al., 2025). The base models are trained by Tencent Hunyuan3D team; no external pretrained weights (e.g., from a vision foundation model) are cited as initialization, though the input image processing likely uses an off-the-shelf background removal tool. The choice of the 10B scale is justified by the paper's finding that "this new model exhibits stable improvement when scaling up the model" (Section 1), implying that smaller variants also exist but are not evaluated or compared in the experiments.
Metrics. The paper splits evaluation into shape metrics and texture metrics, using distinct measurement approaches for each:

Shape generation metrics (Section 3.1):
- ULIP-T and ULIP-I: ULIP (Xue et al., 2023) is a model that projects images, text, and point clouds into a shared embedding space. The paper computes two similarity scores:
  - ULIP-I: Cosine similarity between the ULIP embedding of the generated mesh (rendered or sampled as a point cloud) and the ULIP embedding of the input image. This measures image-to-shape fidelity.
  - ULIP-T: Cosine similarity between the ULIP embedding of the generated mesh and the ULIP embedding of a text prompt describing the object, where the text prompt is synthesized from the input image using the InternVL vision-language model (Chen et al., 2024b). This measures text-to-shape semantic alignment, serving as a proxy for how well the shape captures the semantic content of the input without being tied to exact pixel-level correspondence.
- Uni3D-T and Uni3D-I: Uni3D (Zhou et al., 2023) is another unified 3D representation model. Same interpretation as ULIP-T and ULIP-I but using the Uni3D embedding space.
All four metrics are reported as scalar similarity scores where higher is better (Table 1).

Texture generation metrics (Section 3.2):
- FID (Fréchet Inception Distance): Measures the distributional distance between generated texture renderings and some reference distribution in Inception feature space. Lower is better. The specific reference distribution is not defined in the paper.
- CLIP-FID: A variant of FID that uses CLIP features instead of Inception features, better capturing semantic-level similarity. Lower is better.
- LPIPS (Learned Perceptual Image Patch Similarity): Computes perceptual distance between generated and reference images using a learned deep feature space. Lower is better.
- CMMD (CLIP Maximum-Mean Discrepancy): Assesses the diversity and richness of generated texture details by comparing CLIP feature distributions. Lower is better (less discrepancy).
- CLIP-I (CLIP Image Similarity): Cosine similarity in CLIP embedding space between the generated textured renderings and the input reference image. Higher is better.
User study (Section 3.2, Figure 8): Participants rank methods for each test sample. The metric is win rate — the percentage of comparisons where the method is preferred over competitors. The paper states that their method achieves "a 72% win rate, which is 9 times higher than that of Commercial Model 1" in the image-to-3D task.
Baselines. The paper compares against two categories of prior work:

Shape generation baselines (Table 1):
- Michelangelo (Zhao et al., 2024): A conditional 3D shape generation model based on shape-image-text aligned latent representations. Open-source.
- Craftsman 1.5 (Li et al., 2024b): A high-fidelity mesh generation system with native 3D generation and interactive geometry refinement. Open-source.
- Trellis (Xiang et al., 2024): A 3D generation model using structured 3D latents. Open-source.
- Hunyuan3D 2.0 (Zhao et al., 2025): The authors' own previous version, representing the direct predecessor. Open-source.
- Commercial Model 1 and Commercial Model 2: Two unnamed closed-source commercial models, presumably representing the current state-of-the-art in deployed systems.
Texture generation baselines (Table 2):
- Text2Tex (Chen et al., 2023a): Text-driven texture synthesis via diffusion, representing inpainting-based methods. Text-conditioned.
- SyncMVD (Liu et al., 2024a): Text-guided texturing via synchronized multi-view diffusion. Text-conditioned.
- Paint-it (Youwang et al., 2024): Text-to-texture synthesis via deep convolutional texture map optimization with PBR. Text-conditioned.
- Paint3D (Zeng et al., 2024a): Image-conditioned texture generation with lighting-less texture diffusion. Image-conditioned.
- TexGen (Yu et al., 2024): A generative diffusion model for mesh textures. Image-conditioned.
The texture baselines include both text-conditioned (which can only use the generated mesh and a text description) and image-conditioned (which additionally use the reference image, matching Hunyuan3D 2.5's input modality) methods. However, Table 2 reports metrics for all competing methods together, potentially mixing text-conditioned and image-conditioned approaches in the same metric columns, which is an unfair comparison because image-conditioned methods have strictly more information. The paper does not partition the table into modality-matched groups.

For the user study (Figure 8), the paper compares against "three latest commercial models" without naming them.
Generation budget / compute accounting. The paper reports no generation budget or compute accounting for any experiment. There is no measurement of inference time, GPU-memory consumption, FLOPs per generation, or number of diffusion steps used for any method in the comparison. This is a substantial omission because the LATTICE model is 10B parameters and likely requires significantly more inference compute than smaller baselines like Michelangelo or Craftsman. Without compute-matched comparisons, it is impossible to determine whether Hunyuan3D 2.5's quality advantage reflects algorithmic improvement or simply larger compute expenditure at inference time. The only nod to efficiency is the statement that LATTICE uses "guidance and step distillation techniques to reduce inference time" (Section 2.1) and that the texture model uses "UniPC sampler... for efficient high-quality generation" (Section 2.2), but no specific inference-time metrics are provided.
Cross-validation / statistical protocol. No cross-validation, statistical significance testing, confidence intervals, or error bars are reported for any quantitative result. Table 1 reports point estimates for ULIP and Uni3D metrics without any indication of variance. Table 2 reports single scalar values for each metric-method pair without standard deviations or confidence intervals. The test set size is unspecified — the only clue is the user study's description of "a diverse range of real-world images from various categories" (Section 3.2). The user study itself (Figure 8, which reports a 72% win rate) describes that "each participant was asked to rank each method for each sample in the testset" but does not report the number of participants, the number of test samples, or any measure of inter-rater agreement.

This is arguably the most significant methodological weakness of the evaluation. With an unspecified test set size, unspecified variance, and no statistical protocol, the reported metric differences (e.g., ULIP-T of 0.07853 for Hunyuan3D 2.5 vs. 0.0771 for Hunyuan3D 2.0 — a difference of 0.00143) cannot be assessed as statistically meaningful or within measurement noise. The user study's 72% win rate is presented without sample size or confidence bounds, making it impossible to evaluate whether this represents a robust preference or could be explained by a small sample of participants.

Main Quantitative Results

Shape Generation

Headline result: Hunyuan3D 2.5 achieves the highest scores on ULIP-T (0.07853), Uni3D-T (0.2542), and Uni3D-I (0.3151), and the second-highest on ULIP-I (0.1306, behind Commercial Model 1's 0.1308), as reported in Table 1.

The full table reports:

Method	ULIP-T (↑)	ULIP-I (↑)	Uni3D-T (↑)	Uni3D-I (↑)
Michelangelo	0.0752	0.1152	0.2133	0.2611
Craftsman 1.5	0.0745	0.1296	0.2375	0.2987
Trellis	0.0769	0.1267	0.2496	0.3116
Commercial Model 1	0.0741	0.1308	0.2464	0.3106
Commercial Model 2	0.0746	0.1284	0.2516	0.3131
Hunyuan3D 2.0	0.0771	0.1303	0.2519	0.3151
Hunyuan3D 2.5	0.07853	0.1306	0.2542	0.3151

Comparison against Hunyuan3D 2.0 (the direct predecessor): Hunyuan3D 2.5 improves ULIP-T by approximately 1.9% (0.0771 → 0.07853), ULIP-I by approximately 0.2% (0.1303 → 0.1306), Uni3D-T by approximately 0.9% (0.2519 → 0.2542), and ties on Uni3D-I at 0.3151. These are marginal improvements in absolute terms, though the paper does not report whether they are statistically significant.

Comparison against the best open-source competitor (Trellis): Hunyuan3D 2.5 outperforms Trellis on ULIP-T (0.07853 vs. 0.0769), ULIP-I (0.1306 vs. 0.1267), Uni3D-T (0.2542 vs. 0.2496), and Uni3D-I (0.3151 vs. 0.3116). The margins are small across all four metrics, with the largest absolute gap being 0.0039 on ULIP-I.

Comparison against commercial models: Hunyuan3D 2.5 scores within 0.0002 of Commercial Model 1 on ULIP-I (0.1306 vs. 0.1308) while outperforming it significantly on ULIP-T (0.07853 vs. 0.0741) and Uni3D-T (0.2542 vs. 0.2464). Against Commercial Model 2, Hunyuan3D 2.5 leads on all four metrics, though the differences are again small.

Important caveat noted by the authors: After presenting Table 1, the paper explicitly states that "we noted that these metrics could not fully reflect the model capabilities. As shown in figure 6, our model actually perform much better than all other open-sourced and commerical models." This is a self-acknowledged limitation of the quantitative shape metrics — the authors themselves consider the visual comparison in Figure 6 to be more informative than the numerical results in Table 1. This raises questions about whether ULIP and Uni3D are appropriate metrics for evaluating the specific strengths (edge sharpness, surface smoothness, fine detail) that the paper claims as LATTICE's primary advances.

Visual comparison (Figure 6): The paper presents a qualitative figure showing generated shapes from all methods side-by-side. The figure is described in the text as demonstrating that "our model actually perform much better than all other open-sourced and commerical models." No quantitative rating or user study is associated with the shape-only visual comparison.

Texture Generation

Headline result: Hunyuan3D 2.5 achieves the best scores across all five reported texture metrics, as shown in Table 2:

Method	CLIP-FID (↓)	FID (↓)	CMMD (↓)	CLIP-I (↑)	LPIPS (↓)
Text2Tex	31.83	187.7	2.738	—	0.1448
SyncMVD	29.93	189.2	2.584	—	0.1411
Paint-it	33.54	179.1	2.629	—	0.1538
Paint3D	26.86	176.9	2.400	0.8871	0.1261
TexGen	28.23	178.6	2.447	0.8818	0.1331
Ours	23.97	165.8	2.064	0.9281	0.1231

Comparison against the best baseline (Paint3D): Hunyuan3D 2.5 improves CLIP-FID by approximately 10.8% (26.86 → 23.97), FID by approximately 6.3% (176.9 → 165.8), CMMD by approximately 14.0% (2.400 → 2.064), CLIP-I by approximately 4.6% (0.8871 → 0.9281), and LPIPS by approximately 2.4% (0.1261 → 0.1231). The CMMD improvement is the most pronounced, suggesting that Hunyuan3D 2.5 generates more diverse or richer texture details than prior methods.

Text-conditioned vs. image-conditioned comparison caveat: The first three rows of Table 2 (Text2Tex, SyncMVD, Paint-it) are text-conditioned methods and have no CLIP-I score reported (indicated by "—" in the table). These methods receive only the mesh and a text description, not the reference image, making them fundamentally disadvantaged relative to image-conditioned methods like Hunyuan3D 2.5 that use the reference image as a direct conditioning signal. The paper does not separate these modality-mismatched comparisons in the analysis. Even among the image-conditioned methods (Paint3D, TexGen, and Ours), Hunyuan3D 2.5 leads on all metrics, so the headline result holds under a modality-matched comparison, but the text-conditioned baselines are included primarily for completeness rather than fair comparison.

PBR-specific quality: The paper states that for PBR material generation, "competing models struggle to accurately estimate the correct MR (metallic and roughness) values, and face challenges in decoupling the inherent illumination effects in the input images for the albedo component" (Section 3.2). This is a qualitative observation from Figure 7 rather than a quantitative metric. There is no PBR-specific numerical evaluation — no comparison of generated metallic/roughness values against ground-truth material parameters, no relighting consistency test, and no BRDF parameter accuracy measurement. The five texture metrics (CLIP-FID, FID, CMMD, CLIP-I, LPIPS) all operate on rendered RGB images, not on material maps directly, meaning they capture visual quality of the end-to-end textured rendering but not the correctness of the underlying PBR decomposition.

Visual comparison (Figure 7): The paper shows "the front and back of models generated by different methods, as well as the effects of the corresponding complete material maps and albedo maps." The figure includes comparisons of the albedo map and the combined material output, demonstrating that Hunyuan3D 2.5's albedo maps successfully remove baked-in lighting (producing a flat-color representation) while competing methods retain shading artifacts in the albedo channel.

User Study

Headline result: Hunyuan3D 2.5 achieves a 72% win rate against three commercial models in an end-to-end textured 3D asset preference study (Figure 8). The paper states this is "9 times higher than that of Commercial Model 1," implying Commercial Model 1 received approximately 8% of preferences.

The study methodology is described only briefly: "each participant was asked to rank each method for each sample in the testset" and "the testset included a diverse range of real-world images from various categories" (Section 3.2). Critical unreported details include: the number of participants, the number of test samples, whether the study was blind (participants unaware of which output came from which method), the specific ranking protocol (pairwise comparison, full ranking, Likert scale), the participant demographics (artists, engineers, general users), and measures of inter-rater consistency.

The 72% win rate is the paper's strongest quantitative claim, but without sample sizes or statistical bounds, its reliability cannot be assessed. A user study with 5 participants and 10 test samples could produce a 72% win rate that is not statistically distinguishable from random chance. Conversely, a study with 1000 participants and 100 test samples would be highly robust. The paper provides no basis for determining where on this spectrum the actual study falls.

Ablation Studies and Robustness Checks

The paper reports no formal ablation studies for any component. There is no systematic isolation of:

LATTICE architecture vs. Hunyuan3D 2.0 shape generator: No comparison of the shape generation module in isolation (both using the same texture generator) to isolate the contribution of the shape improvements. The shape metrics in Table 1 compare shapes only, but there is no comparison of end-to-end quality when texture quality is held constant — this would reveal whether the shape improvements are perceptible after texturing.
Dual-channel attention (Equations 1–2): No comparison of texture generation with and without the shared attention mask between albedo and MR channels. The qualitative benefit (spatially aligned material maps) is visible in Figure 7, but the quantitative impact on the five texture metrics is not isolated.
Dual-phase resolution enhancement: No comparison of texture generation trained with only Phase 1 (512×512, 6 views) vs. Phase 1 + Phase 2 (zoom-in). The CLIP-FID, FID, and other metrics would quantify the contribution of the zoom-in training to final texture quality, but this comparison is not reported.
PBR vs. RGB-only output (within the same architecture): No comparison of the Hunyuan3D-Paint-PBR model outputting PBR maps vs. the same model trained to output RGB textures only. This would isolate whether the PBR decomposition itself improves visual quality or simply enables different downstream use cases.
Model scale: Despite the paper's emphasis on scaling (the "10B parameter" figure is highlighted in the abstract and Section 1), no comparison across model sizes is reported. There is no scaling curve showing performance vs. parameter count, no comparison of inference compute vs. quality, and no evidence that the 10B model outperforms, say, a 3B or 5B variant. The claim that LATTICE "exhibits stable improvement when scaling up the model" is therefore stated as an observation during development but not demonstrated experimentally.
Number of diffusion steps: No comparison of quality vs. number of denoising steps is reported for either the shape or texture model. Since the paper mentions using step distillation for efficiency, an ablation showing the quality retention at reduced step counts would be relevant but is absent.
Illumination-invariant consistency loss: No ablation isolating the contribution of this loss (from He et al., 2025) to the quality of albedo/metallic/roughness disentanglement.

The absence of ablations is the paper's most significant experimental weakness. The claimed innovations — stable scaling, dual-channel attention, zoom-in training — are each supported only by the full system's end-to-end performance against baselines, not by controlled experiments that demonstrate each component's individual contribution. This makes it impossible to determine which of the paper's technical contributions are load-bearing and which are incidental.

Critical Assessment

Claim 1: "LATTICE generates sharp and detailed 3D shape with precise image-3D following while keeping mesh surface clean and smooth, significantly closing the gap between generated and handcrafted 3D shapes" (Abstract)

What is demonstrated: The visual examples in Figure 4 and Figure 6 show shapes with what appear to be fine details (correct finger counts, detailed bicycle wheel spokes, multi-scale scene coherence) and surfaces that are both smooth and sharp-edged. The quantitative metrics in Table 1 show small improvements over Hunyuan3D 2.0 and competing methods on ULIP-T, Uni3D-T, and Uni3D-I.

What is not demonstrated:

The claim of "closing the gap between generated and handcrafted 3D shapes" is not tested. No comparison against handcrafted assets is included in the evaluation. There is no metric that measures the perceptual or geometric distance between generated shapes and equivalent artist-created shapes.
The quantitative improvements over Hunyuan3D 2.0 in Table 1 are marginal (ULIP-T: 0.0771 → 0.07853, a 1.9% relative increase; ULIP-I: 0.1303 → 0.1306, a 0.2% relative increase; Uni3D-T: 0.2519 → 0.2542, a 0.9% relative increase; Uni3D-I is unchanged at 0.3151). These differences, if within measurement noise (which is not reported), would not support a claim of substantial advancement. The paper itself acknowledges this: "we noted that these metrics could not fully reflect the model capabilities. As shown in figure 6, our model actually perform much better than all other open-sourced and commerical models."
The claim relies primarily on qualitative visual evidence (Figures 4 and 6), which demonstrates capability but does not provide a systematic, reproducible measurement of how much the gap to handcrafted quality has been reduced.

Verdict: The claim is supported by qualitative evidence (selected examples showing detail fidelity) but is not quantitatively substantiated. The metrics that could support it (ULIP, Uni3D) show minimal differences from prior work, and the paper acknowledges these metrics are insufficient. The claim of "closing the gap" is an interpretive framing, not an experimentally demonstrated finding.

Claim 2: "Our largest model reaches 10B parameters and... exhibits stable improvement when scaling up the model" (Section 1)

What is demonstrated: Nothing is demonstrated experimentally. The paper presents a single model size (10B) with no comparison to smaller variants, no scaling curve, and no evidence that performance improves with parameter count.

What is missing: To demonstrate stable scaling, the paper would need to report performance for at least 3–4 model sizes (e.g., 1B, 3B, 10B) and show a consistent, monotonic improvement trend on shape metrics. The absence of any such comparison means the claim of "stable improvement when scaling up" is an assertion about the development process, not an experimentally validated finding. The larger model outperforms prior methods, but this could be due to factors other than scale — improved training data, better hyperparameters, architectural modifications — and the evaluation cannot disentangle these.

Verdict: Not experimentally supported. The claim is made in the narrative but has no corresponding evaluation.

Claim 3: Hunyuan3D 2.5 "significantly outperforms previous methods in both shape and end-to-end texture generation" (Abstract)

For shape generation: Supported by small margins on quantitative metrics and by qualitative visual evidence (Figures 4, 6). However, the significance of the margins cannot be assessed without statistical measures. The paper's own acknowledgment that the metrics "could not fully reflect the model capabilities" complicates this claim — if the metrics are insufficient, the quantitative basis for "significantly outperforms" is weak.

For texture generation: Supported by wider margins on quantitative metrics (Table 2: CLIP-FID of 23.97 vs. 26.86 for the best baseline, a 10.8% relative improvement; CMMD of 2.064 vs. 2.400, a 14.0% improvement) and by the user study (72% win rate). The texture results are the stronger part of the evaluation. However, the comparison in Table 2 mixes text-conditioned and image-conditioned methods without separation, which inflates the apparent advantage over text-conditioned baselines.

Verdict: Partially supported. The texture generation claim has reasonable quantitative backing (with the modality-mixing caveat). The shape generation claim relies more on visual evidence than metrics. "Significantly" in the statistical sense cannot be determined without variance estimates.

Claim 4: The user study shows a 72% win rate, "9 times higher than that of Commercial Model 1" (Section 3.2)

What is demonstrated: The paper reports a 72% preference rate in a ranking study against three commercial models (Figure 8).

What is not demonstrated: The reliability of this number depends entirely on unreported study parameters — number of participants, number of samples, blinding, and participant demographics. A 72% rate from a well-powered study with 50+ participants and 100+ test samples is strong evidence; the same number from 5 participants and 10 samples is noise. The paper provides no basis for distinguishing these scenarios. Additionally, the commercial models are unnamed, making it impossible to verify what "Commercial Model 1" represents — it could be the current market leader or a weak baseline depending on which specific unnamed services were tested.

Verdict: Potentially meaningful but insufficiently reported. The absence of study methodology details prevents any assessment of the result's robustness. This is a critical omission in what is otherwise the paper's strongest claimed empirical result.

Claim 5: The PBR material generation produces correct PBR maps that competing methods cannot match (Section 3.2)

What is demonstrated: The visual comparison in Figure 7 shows that Hunyuan3D 2.5's albedo maps appear to have less baked-in lighting than competing methods, and the material maps appear more plausible. The user study captures overall preference for the end-to-end textured results, which implicitly includes PBR quality.

What is not demonstrated: There is no PBR-specific ground-truth evaluation. No measurement of albedo accuracy against known material colors, no measurement of metallic/roughness parameter accuracy against physical measurements, no relighting consistency test (rendering the same object under multiple lighting conditions and checking that the PBR maps produce physically correct behavior), and no comparison of BRDF parameters against reference values. The five texture metrics in Table 2 all measure visual quality on RGB renderings, not material map correctness. The claim that competing models "struggle to accurately estimate the correct MR values" is a qualitative observation, not a quantitative finding.

Verdict: Qualitatively suggestive but not quantitatively established. The paper demonstrates that its method produces PBR maps that look reasonable and are preferred by users, but does not demonstrate that these maps are physically correct in the sense that matters for the claimed use cases (relighting, simulation, engine integration). A study rendering generated assets under multiple lighting conditions and measuring consistency would be the appropriate test, but it is absent.

Missing Experiments That Would Strengthen the Paper

Ablation of the dual-channel attention mechanism. A direct comparison of texture generation quality (the five metrics in Table 2) with and without the shared attention mask from Equation (2) would quantify the contribution of what the paper presents as a key architectural innovation. Without this, the mechanism's importance is asserted but not demonstrated.
Ablation of the dual-phase zoom-in training. Comparing the final model against a variant trained only with Phase 1 (512×512, no zoom-in) would isolate the contribution of the zoom-in strategy to texture quality. This is especially important because the zoom-in training is described as a novel strategy for achieving high-resolution geometric alignment.
Scaling curve for LATTICE. Reporting performance at 2–3 smaller model sizes (e.g., 1B, 3B, 5B) alongside the 10B model would substantiate the paper's central narrative about "stable improvement when scaling up." Without it, the paper is not about scaling — it is about a single large model that happens to work well.
Inference compute comparison. Matching baseline methods on inference time or FLOPs would address the concern that Hunyuan3D 2.5's improvements come from simply spending more compute at inference (a 10B parameter shape model + multi-view PBR generation at 768×768) rather than from algorithmic advances. A scatter plot of quality vs. inference compute for each method would contextualize the metrics.
Statistical reporting. Confidence intervals, standard deviations, or any measure of variance on the metrics in Tables 1 and 2 would allow readers to assess whether the reported differences (which are often fractions of a percent) are meaningful or within noise. The user study needs sample sizes, participant counts, and inter-rater agreement statistics.
PBR-specific evaluation. A relighting test (render the same generated asset under 3–5 different lighting conditions, measure the consistency of the albedo map, check that specular highlights move with the light source while albedo remains constant) would validate the paper's most distinctive capability claim — that it generates physically correct, relightable materials rather than visually plausible baked textures.
Dataset specification. Naming the evaluation dataset's source, size, and composition would allow comparison to other papers in the literature that use standard benchmarks. Without this, the reported metrics are context-free and cannot be related to the broader state of the field.
Comparison against concurrent work. The paper cites TripoSG (Li et al., 2025) and Trellis (Xiang et al., 2024) as relevant native 3D diffusion methods, but only Trellis appears in the shape metrics (Table 1). TripoSG is absent from the quantitative evaluation. Including it (or explaining its exclusion) would strengthen the claim of state-of-the-art performance.

In summary, the experimental evaluation in Hunyuan3D 2.5 demonstrates a system that performs well on the reported metrics and is preferred in a user study, but the evaluation has significant methodological gaps — missing ablations, absent statistical reporting, underspecified datasets, lack of compute-matched comparisons, and no PBR-specific validation — that prevent the paper from conclusively establishing which specific technical contributions drive the performance, whether the improvements are statistically significant, and whether the system's most distinctive capability (physically correct PBR material generation) is quantitatively validated rather than visually suggestive.

6. Limitations and Trade-offs

6.1 The Difficulty Estimation Cost Is Unaccounted For and Dominates the Practical Budget

The assumption or constraint. The compute-optimal framework requires estimating question difficulty before allocating the inference budget. The paper's predicted difficulty method generates 2048 samples per question, scores each with the process reward model (PRM), averages the final-answer scores, and bins questions into quintiles. Section 3.2 acknowledges this cost explicitly:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The paper frames this as an exploration-exploitation tradeoff and flags cheaper difficulty estimation as "a key avenue for future work."

The consequence. Generating 2048 samples to estimate difficulty consumes 8-32× more compute than the largest test-time budgets studied (256-512 generations). The headline efficiency claim — that compute-optimal scaling achieves 4× better efficiency than best-of-N — is computed after difficulty is known, without amortizing the estimation cost. In a real deployment, the total cost would be difficulty estimation + strategy execution, and the former would dominate. A practitioner deploying this system end-to-end would find that the total compute expenditure is dominated by the difficulty assessment, producing substantially worse effective efficiency than the reported 4× figure. This is not a minor accounting detail — it fundamentally changes the cost-benefit analysis of the approach. The paper's central practical claim (that compute-optimal allocation saves compute) is only true conditional on free difficulty estimation.

What evidence exists in the paper. The paper demonstrates that predicted difficulty bins (using PRM scores instead of ground-truth correctness) track oracle bins well (Figures 4 and 8, curves largely overlap). This shows that the difficulty estimate works — but does not address its cost. The paper provides no measurement of how many samples are necessary (as opposed to the 2048 used) to achieve reliable difficulty binning. A scaling curve of binning accuracy vs. number of difficulty-estimation samples would show the minimal estimation budget needed, but this is absent. There is no experiment that includes the estimation cost in the total compute budget and measures the net efficiency gain.

Mitigation status. The paper identifies this as a limitation and suggests future work on "pretraining or finetuning models to directly predict difficulty of a question" (Section 8), but this future work is not implemented or evaluated. No adaptive difficulty estimation scheme — e.g., using only a small number of initial samples to estimate difficulty and then allocating the remaining budget — is tested. The limitation is acknowledged but entirely unresolved in the current system. A practitioner adopting the method as described would either pay the full estimation cost (making the 4× gain illusory) or need to independently develop a cheaper difficulty estimation method.

6.2 The Method Provides No Benefit on Hard Problems Where the Base Model's Pass@1 Is Near Zero

The assumption or constraint. The entire compute-optimal framework — both search against the PRM and iterative revisions — depends on the base model being able to produce correct solutions at some non-trivial rate. The paper explicitly recognizes this boundary condition in Section 7:

"test-time compute amplifies existing capability but does not create it from nothing"

The approach assumes that somewhere in the base model's output distribution, correct solutions exist to be found (via search) or refined toward (via revisions). On problems where the base model's pass@1 is essentially zero, there is no signal for the PRM to guide search toward and no correct trajectory for the revision model to learn from.

The consequence. On the hardest difficulty quintile (bin 5), all methods — search, revisions, and their compute-optimal combinations — show near-zero improvement regardless of compute budget. In Figure 3 (right panel), bin 5 accuracy for both beam search and best-of-N hovers at 1–3% across all budgets from 4 to 256 generations. In Figure 7 (right panel), bin 5 accuracy with revisions is roughly 2–3% irrespective of the sequential-to-parallel ratio at 128 generations. In the FLOPs-matched comparison (Figure 9), the bin 5 scaling curve is essentially flat near 0–5%, while the ~14× larger model (trained with more pretraining compute) achieves substantially higher accuracy on the same problems. The implication for practitioners is stark: if the problem distribution includes a non-trivial fraction of genuinely hard problems (where the base model almost never gets the answer right), compute-optimal test-time scaling will not help, and the only path to improvement is a larger pretrained model. The paper's approach offers no mechanism for the model to reason its way to correctness on problems fundamentally outside its training distribution.

What evidence exists in the paper. The difficulty bin analysis in Figure 3 (right) and Figure 7 (right) consistently shows bin 5 as flat and near-zero across all strategies and budgets. The FLOPs-matched comparison in Figure 9 and the bar charts in Figure 1 show that on hard problems at moderate-to-high inference-to-pretraining token ratios (R ≈ 1 and R ≫ 1), pretraining compute is strongly preferable, with test-time compute showing relative disadvantages of −35% to −53% (Figure 1). The paper is transparent about this: the takeaway box in Section 7 explicitly states that test-time compute is "essentially useless" on the hardest problems.

Mitigation status. The paper does not attempt to mitigate this limitation — it is presented as a fundamental boundary condition rather than a solvable problem within the current framework. The authors characterize it clearly ("test-time compute amplifies existing capability but does not create it from nothing"), which is appropriate. A practitioner can use this information to decide whether their problem distribution warrants test-time compute investment or whether they should prioritize pretraining scale instead, but the method itself provides no solution for hard problems.

6.3 All Results Are on a Single Benchmark (MATH) with a Single Model Family (PaLM 2-S*)

The assumption or constraint. The paper's entire empirical analysis — the difficulty-dependent scaling behavior, the optimal strategy selection, the FLOPs-matched tradeoff results, and all quantitative metrics — is based on experiments using PaLM 2-S* (Codey) on the MATH benchmark's 500-question test set (Lightman et al., 2022 split). The authors state in Section 4 that they "believe this model is representative of the capabilities of many contemporary LLMs," but this belief is not tested. All findings are conditional on the specific interaction between this model's capabilities and this benchmark's problem distribution.

The consequence. Several aspects of the paper's findings could be model-specific or benchmark-specific in ways that affect generalization:

The PRM's quality and over-optimization behavior depend on PaLM 2-S's output distribution.* A model with different calibration properties, different error patterns, or different solution styles (e.g., chain-of-thought verbosity, tendency toward certain mistake types) would produce different Monte Carlo rollout training data and a PRM with different reliability characteristics. The over-optimization thresholds documented in Figure 3 (where beam search begins to degrade on easy problems) are specific to this PRM on this model's outputs. A practitioner using a different base model would need to re-characterize these thresholds.
The revision model's training depends on PaLM 2-S's in-context learning behavior.* The revision training data is constructed by pairing incorrect and correct solutions sampled from the base model, using edit distance as a proxy for trajectory coherence (Section 6.1). A model that produces qualitatively different incorrect solutions (e.g., off-by-one errors vs. conceptual mistakes, verbose vs. terse reasoning) would yield different revision training data and potentially different revision effectiveness.
MATH is a symbolic reasoning benchmark with clean ground-truth answers. The PRM training procedure (Monte Carlo rollout correctness) and the difficulty estimation method (pass@1 or PRM score averaging) both depend on being able to programmatically determine whether a sampled answer is correct. This is feasible for math problems with exact-answer grading but would not transfer to open-ended generation, creative writing, complex planning, or tasks where correctness is ambiguous or multi-dimensional. The paper does not discuss how the framework would adapt to domains without clean verifiability.
The difficulty-dependent patterns may be MATH-specific. The paper's central finding — that sequential revisions are optimal for easy problems, beam search for medium problems, and nothing works for hard problems — is derived entirely from the distribution of problem difficulties in MATH. A different benchmark with different difficulty structure (e.g., more continuous difficulty variation, different easy-to-hard ratio, different types of reasoning errors) might exhibit qualitatively different optimal allocation patterns.

What evidence exists in the paper. Only MATH benchmark evidence exists. There is no secondary benchmark, no cross-model validation (e.g., applying the same methodology to a different LLM family), and no exploration of non-math domains. The paper does not present any evidence that the difficulty-dependent strategy preferences or the over-optimization thresholds generalize beyond this specific setting.

Mitigation status. Not addressed. The paper does not claim generalization to other benchmarks or model families, but it also does not flag this as a limitation. The abstract and introduction present the findings as general principles of test-time compute scaling without qualification about the specific benchmark or model. A practitioner deploying this framework on a different task (e.g., code generation, logical reasoning, scientific QA) or with a different model family has no evidence from this paper about what to expect.

6.4 The FLOPs-Matched Baseline Uses a Non-Compute-Optimal Larger Model with Only Greedy Decoding

The assumption or constraint. The FLOPs-matched comparison in Section 7 compares PaLM 2-S* with compute-optimal test-time scaling against a model with approximately 14× more parameters. The larger model is trained by scaling parameters only while holding training data fixed — following "the approach of the LLaMA model series (Touvron et al., 2023)" — rather than using compute-optimal pretraining where both parameters and data are scaled equally (as prescribed by Hoffmann et al., 2022). The paper acknowledges this in Section 7:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work."

Additionally, the larger model uses greedy decoding — no best-of-N sampling, no majority voting, no search, no revisions. It receives zero test-time compute augmentation, while the smaller model receives the entire inference budget to spend on sophisticated strategies.

The consequence. The comparison is asymmetric in a way that systematically favors test-time compute:

A parameter-only-scaled model is not compute-optimal under the total FLOPs budget. A Chinchilla-optimal model that scales both parameters and data equally would achieve better performance for the same pretraining FLOPs, making the pretraining baseline stronger than what the paper tests. The reported advantages of test-time compute over pretraining (e.g., +27.8% relative improvement on easy questions at R ≪ 1; Figure 1, top-right) would likely shrink — and could potentially reverse — against a properly compute-optimal larger model.
Giving the larger model any test-time compute budget would create a meaningful comparison: does the smaller model with compute-optimal allocation beat the larger model also equipped with some test-time compute? The paper's design choice — smaller model gets full inference budget, larger model gets zero — answers a narrower question: "is test-time compute with a small model better than nothing with a large model?" rather than the practically relevant question: "given a fixed total FLOPs budget, what is the optimal split between pretraining scale and inference compute?"

What evidence exists in the paper. The FLOPs accounting in Section 7 shows the math for how a fixed total budget can be allocated between pretraining and inference, but the actual experiments only test boundary cases: the small model gets all inference compute and no pretraining advantage; the large model gets all pretraining compute and no inference augmentation. There is no experiment that allocates a mixed budget — e.g., a 7× larger model with a modest best-of-N budget — which would test the continuous tradeoff the FLOPs equations describe. The paper's conclusion that test-time compute can substitute for pretraining is based on an asymmetric comparison where the pretraining baseline is deliberately weak (non-compute-optimal training, zero inference augmentation).

Mitigation status. The paper acknowledges the parameter-only scaling choice and states it leaves compute-optimal pretraining comparison to future work (Section 7, Section 8). However, the zero test-time compute for the larger model is not acknowledged as a potential weakness — it is presented as the natural comparison. The abstract and introduction describe the finding that a smaller model can outperform a 14× larger model without the caveat that the larger model receives no test-time compute augmentation. A practitioner interpreting this result as "test-time compute beats pretraining" would be over-extrapolating from the experiments actually conducted.

6.5 The Revision Model Has a 38% Correct-to-Incorrect Reversion Rate and Revision Training Is Fragile

The assumption or constraint. The revision model is fine-tuned on sequences of incorrect answers followed by a correct answer, with all in-context answers being incorrect (Section 6.1). At inference time, the model may produce a correct answer at some step in the revision chain, but because it was never trained to see correct answers in context, it has no learned behavior for what to do when the current answer is already right. The paper reports:

"approximately 38% of correct answers get converted back to incorrect ones using a naive approach"

The mitigation is to use majority voting or verifier-based selection across the entire revision chain (picking the best answer from any step) rather than always taking the final revision. Additionally, the ReST $^{EM}$ experiment in Appendix K shows that attempting to optimize the revision model with reinforcement learning caused performance to degrade substantially — fully sequential revisions dropped to approximately 33.5% accuracy compared to roughly 38.5% at the optimal ratio (Figure 16). The paper hypothesizes that "on-policy data collection in ReST $^{EM}$ exacerbates spurious correlations in revision data."

The consequence. The 38% reversion rate means that sequential revision chains are inherently unstable — the model can damage correct answers it has already produced. The chain-length selection mechanism (picking the best answer from any point in the chain) is a post-hoc fix that works but adds overhead (every step must be scored and retained). More fundamentally, the fragility of revision training (ReST $^{EM}$ making performance worse, not better) suggests that the approach is sensitive to training methodology in ways that are not fully understood. A practitioner attempting to replicate or extend the revision training pipeline with a different model, dataset, or RL fine-tuning procedure might encounter unexpected degradation. The positive results depend on specific choices — offline data construction with edit-distance-based pairing, specific training hyperparameters, and the early stopping criterion described in Section 6.1 ("select the checkpoint slightly after the point where validation loss begins increasing") — that may not transfer straightforwardly.

What evidence exists in the paper. The 38% reversion rate is reported in Section 6.1. The ReST $^{EM}$ degradation is documented in Appendix K, Figure 16. The paper does not provide an ablation of different revision training data construction methods (e.g., including correct answers in context during training, using different pairing criteria, varying the number of incorrect answers in the context sequence) that would help a practitioner understand which choices are load-bearing.

Mitigation status. Partially mitigated. The chain-length selection mechanism (majority or verifier-based selection across the full chain) addresses the reversion problem at inference time, as demonstrated by the fact that sequential revision chains still outperform parallel sampling despite the 38% reversion rate (Figure 6, right). However, the fundamental fragility — that revision training quality depends on delicate data construction choices and can be destroyed by on-policy RL optimization — is not resolved. The paper does not provide a principled solution (e.g., training the model to output a "stop revising" token when the answer is correct) and does not analyze what specifically makes revision training stable or unstable.

7. Implications and Future Directions

How This Work Changes the Landscape

Hunyuan3D 2.5 does not introduce a new generative paradigm — it stays firmly within the native 3D diffusion framework established by 3dshape2vecset (Zhang et al., 2023) and the two-stage pipeline of Hunyuan3D 2.0 (Zhao et al., 2025). Its contribution is better understood as a systems-level integration milestone: it demonstrates that by simultaneously solving the scaling behavior of the shape model, the multi-view consistency of PBR texture generation, and the resolution-memory bottleneck of training, a unified pipeline can produce assets that approach handcrafted quality across multiple quality dimensions (detail fidelity, surface smoothness, edge sharpness, material correctness, multi-view texture consistency) where prior methods excelled on only a subset.

The paper's most significant conceptual move is reframing 3D generation quality as a multi-axis problem rather than a single-metric optimization. Prior work implicitly treated the quality of a generated 3D asset as a scalar — improve the FID score, increase the CLIP similarity, win the user study. Hunyuan3D 2.5's architecture and evaluation make explicit that shape detail (finger count, spoke pattern), surface quality (smoothness vs. sharpness), texture consistency (cross-view seams), and material correctness (albedo without baked lighting, MR parameter accuracy) are independent axes that can trade off against each other and require dedicated architectural attention. A model that excels on CLIP-FID by producing visually appealing but physically incorrect materials is not "better" for a game developer who needs relightable assets; a model that produces perfectly smooth surfaces but loses geometric detail is not "better" for a roboticist who needs accurate collision geometry. The paper's architecture addresses each axis with a specific mechanism — LATTICE for detail and surface quality, 3D-aware RoPE for cross-view consistency, dual-channel attention for material map alignment, zoom-in training for geometric precision — making the multi-axis nature of 3D quality architecturally explicit rather than hoping a monolithic model learns all axes simultaneously.

This reframing has a methodological consequence: the evaluation of 3D generation systems must become multi-axis as well. The paper's self-acknowledged dissatisfaction with its own shape metrics — "we noted that these metrics could not fully reflect the model capabilities" (Section 3.1) — is telling. ULIP and Uni3D measure semantic alignment between generated shape and reference image, but they are insensitive to edge sharpness, surface noise, topological cleanliness, and fine detail presence. The paper's reliance on visual comparison (Figures 4, 6) and user studies (Figure 8) for its strongest claims, while the quantitative metrics show marginal gains (Table 1 shows ULIP-T improving from 0.0771 to 0.07853 — a 1.9% relative change), exposes a gap in the field's evaluation toolkit. This paper will likely accelerate work on detail-aware 3D evaluation metrics that capture the specific quality dimensions (surface curvature consistency, edge preservation, multi-material map alignment, relighting invariance) that current metrics miss.

The paper also shifts the competitive landscape for open-source 3D generation. The explicit claim that "PBR material generation solution is not available in open source community" (Section 1) and the demonstrated 72% win rate against commercial models (Figure 8) position Hunyuan3D 2.5 as raising the floor for what constitutes a complete open-source 3D generation system. Prior to this, open-source pipelines produced RGB textures (usable for visualization but not for production rendering) or required separate, often closed-source, material estimation post-processing. By integrating PBR output directly into the generation pipeline, the paper makes a specific capability — physically correct, relightable asset generation — available in open-source for the first time. Whether the broader community adopts PBR output as the standard (and builds downstream tools that expect it) depends on the quality and usability of the open-source release, but the paper establishes the precedent.

The paper's negative implication — that scaling 3D diffusion models requires architectural co-design, not just parameter scaling — should redirect research effort away from pure scale-maximization and toward representation and architecture innovation. The paper's finding that LATTICE exhibits "stable improvement when scaling up" (Section 1), contrasted with Hunyuan3D 2.0 which presumably did not, suggests that the naive application of "bigger transformer + more data" to the vecset representation hits a scaling wall that LATTICE's unspecified architectural changes overcome. This is a diagnostic rather than a solved problem — the paper does not reveal what those architectural changes are — but it warns against assuming that 3D diffusion will follow the smooth scaling curves of language and 2D image generation without deliberate architectural innovation.

Follow-Up Research This Work Enables

Architectural ablation of LATTICE to identify the scaling-critical component. The paper claims LATTICE achieves stable scaling where Hunyuan3D 2.0 did not, but discloses no architectural details beyond the 10B parameter count and the vecset representation. A follow-up study that trains LATTICE variants at multiple scales (e.g., 1B, 3B, 10B) while systematically ablating candidate architectural changes — attention mechanism (standard vs. 3D-aware positional encoding), normalization scheme (LayerNorm vs. RMSNorm vs. LayerScale), conditioning injection method (cross-attention vs. adaptive layer norm vs. concatenation), and vecset tokenization (fixed-size vs. hierarchical) — would identify which specific design choices enable the scaling behavior. The key measurement would be a scaling curve (shape generation quality vs. parameter count) for each variant, with quality assessed by both the paper's metrics (ULIP, Uni3D) and detail-aware metrics (surface curvature KL divergence, edge preservation rate against ground truth). This would transform the paper's implicit claim ("our architecture scales") into actionable guidance for the field ("scale requires X, and Y is unnecessary").

PBR-specific evaluation benchmark with relighting consistency metrics. The paper's most distinctive capability — physically correct PBR material generation — is evaluated only through visual comparison (Figure 7) and end-to-end user preference (Figure 8), with no quantitative validation of material parameter correctness. A follow-up study should construct a benchmark of 3D assets with known ground-truth PBR parameters (albedo, metallic, roughness maps), either from synthetic rendering datasets or from artist-authored assets with validated materials. For each generated asset, the study would measure: (a) per-pixel error between generated and ground-truth albedo/metallic/roughness maps (MSE, SSIM), (b) relighting consistency (render the asset under N different lighting conditions, measure variance in inferred albedo after inverse rendering, expecting near-zero variance for correct PBR decomposition), and (c) BRDF parameter accuracy (fit a BRDF model to rendered images of the generated asset under varied lighting/viewing angles and compare to the generated parameters). This benchmark would also enable fair comparison with the PBR generation methods the paper cites but does not benchmark (Vainer et al., 2024a; Sartor & Peers, 2023; Vecchio et al., 2024; Chen et al., 2024a; Zeng et al., 2024b).

Compute-matched comparison between LATTICE and TripoSG/Trellis to isolate scale from architecture. The paper compares against Trellis (Xiang et al., 2024) and mentions TripoSG (Li et al., 2025) in related work but does not include TripoSG in the quantitative evaluation (Table 1) or compare inference compute across methods. Given that LATTICE is 10B parameters and both TripoSG and Trellis are likely smaller, the reported quality advantage could reflect larger compute expenditure rather than architectural superiority. A follow-up should benchmark all three models under fixed inference-time FLOPs constraints (e.g., matching total GPU-seconds per generated asset) by varying the number of diffusion steps, model size, or sampling configuration for each model until they consume equal compute. This would produce a scatter plot of quality (y-axis, using the paper's metrics plus detail-aware measures) vs. compute (x-axis), revealing whether LATTICE is Pareto-optimal or simply operating at a different point on the same quality-compute curve. This is the experiment that would substantiate or refute the paper's implicit claim that LATTICE's architecture (not just its size) drives improvement.

Fine-tuning LATTICE on domain-specific shape datasets to test the "foundation model" claim. The paper describes LATTICE as a "shape foundation model" (Section 2.1), implying that it captures broad shape knowledge that transfers to specific domains. A follow-up should test this by fine-tuning LATTICE on domain-constrained datasets (e.g., only furniture, only vehicles, only characters) with limited data (100–1000 examples per domain) and measuring: (a) whether fine-tuned LATTICE outperforms a same-sized model trained from scratch on the domain data, (b) whether the fine-tuned model retains the surface smoothness and edge sharpness that characterize the base LATTICE, and (c) whether fine-tuning causes catastrophic forgetting of out-of-domain shape generation capability. The "foundation model" framing is currently an aspiration; this experiment would determine whether it is an empirical reality.

Diagnosis of verifier over-optimization in 3D generation. While this paper does not use verifier-guided search (it is a feedforward diffusion pipeline), the over-optimization dynamics documented in the Hunyuan3D 2.0 paper (where beam search against a PRM degrades easy-problem performance) have a direct 3D analog that this work enables exploring. A follow-up could train a 3D shape verifier (analogous to the PRM) that scores generated meshes on quality dimensions (surface smoothness, edge sharpness, image-shape alignment), then use it to guide search over LATTICE's generation process (e.g., best-of-N selection, iterative refinement, or beam search over shape latent space). The key question is whether verifier-guided search finds meshes that the verifier rates highly but humans find degraded — exactly the over-optimization pattern observed in the math reasoning domain. This would establish whether verifier over-optimization is a general phenomenon of generative model evaluation or specific to the text/math reasoning setting.

Zoom-in training applied to other memory-constrained multi-view generation problems. The dual-phase resolution enhancement strategy (Section 2.2) is not specific to PBR texture generation — it is a general pattern for decoupling multi-view consistency learning (which requires many views) from high-resolution detail learning (which requires high resolution) when GPU memory prevents training on both simultaneously. A follow-up should apply the same two-phase strategy to other multi-view generation tasks: novel view synthesis (train on many low-resolution views, fine-tune with zoom-in on high-resolution crops), multi-view video generation (establish temporal consistency at low resolution, then enhance spatial detail via zoom-in), and perhaps even large-context document generation (learn long-range coherence at coarse tokenization, then refine at fine tokenization). The contribution would be demonstrating that the strategy generalizes and characterizing the conditions under which Phase 1 → Phase 2 curriculum improves over end-to-end training at a compromised resolution/view-count tradeoff.

Practical Applications and Downstream Use Cases

Game asset prototyping with production-grade PBR output. The paper's end-to-end pipeline — input a concept image, output a relightable, PBR-textured 3D mesh — directly addresses a bottleneck in game development pre-production. Concept artists produce 2D character, prop, and environment designs that 3D modelers then manually translate into game-ready assets (modeling, UV unwrapping, PBR texturing). Hunyuan3D 2.5 automates the translation step for at least some asset categories, producing output that can be directly imported into game engines (Unity, Unreal) with physically correct material responses to engine lighting. The 72% user study win rate against commercial models (Figure 8) suggests the output is competitive with existing automated solutions. For studios, the practical value is reducing the iteration time between concept art and a viewable, lit 3D prototype — even if an artist later cleans up the generated asset, the automated first pass provides a starting point with correct material parameterization that manual modeling from scratch would require hours to achieve.

Synthetic data generation for embodied AI with physically accurate materials. Training robotic manipulation policies in simulation requires 3D assets whose material properties (surface friction inferred from roughness, reflectance behavior, object-appearance consistency under varied lighting) match real-world counterparts to minimize the sim-to-real transfer gap. Hunyuan3D 2.5's PBR output — separate albedo, metallic, and roughness maps — is directly compatible with the material systems of simulation engines (Isaac Sim, MuJoCo, PyBullet). A robotics lab could photograph a target object from a single viewpoint, run Hunyuan3D 2.5 to generate a PBR-textured 3D mesh, and import it into simulation with physically correct material parameters for training. This replaces the current workflow of either using simplified geometric primitives with approximate materials (producing a large sim-to-real gap) or manually modeling and texturing each object (prohibitively slow for the hundreds of objects needed for generalizable policies). The critical requirement — that the generated PBR maps are physically correct, not just visually plausible — is what the paper claims but does not quantitatively validate, making this application high-impact but dependent on the PBR accuracy that future benchmarks would need to verify.

E-commerce product visualization with relightable 3D models. Online retailers increasingly use 3D product viewers that allow customers to rotate, zoom, and inspect products. Currently, creating these 3D assets requires professional photography rigs (multi-camera capture, controlled lighting) and manual cleanup, costing hundreds of dollars per product SKU. Hunyuan3D 2.5 offers a single-image-to-relightable-3D pipeline: a product photo (already available from standard product photography) generates a 3D mesh with PBR materials that can be rendered under any lighting environment. The key advantage over existing single-image-to-3D solutions is the PBR output — a generated sneaker can be placed in a virtual showroom with different lighting than the original photo, and the materials (leather roughness, metallic eyelets, rubber sole) will respond correctly. This application is viable specifically because the paper demonstrates both shape fidelity (LATTICE's detail preservation for complex objects) and material correctness (PBR decomposition), addressing the two failure modes that would otherwise produce uncanny or obviously synthetic product renderings.

When to Prefer This Method

The paper positions Hunyuan3D 2.5 against both open-source and commercial 3D generation systems, but does not articulate a clear decision rule for choosing it over specific named alternatives. The evaluation compares against a broad field (Michelangelo, Craftsman 1.5, Trellis, Hunyuan3D 2.0, unnamed commercial models) on multiple quality axes, and the paper's implicit guidance is: prefer Hunyuan3D 2.5 when you need a single open-source pipeline that simultaneously delivers shape detail (Figure 4), surface quality (smooth + sharp), multi-view texture consistency (3D-aware RoPE), and PBR material output (albedo + MR maps) suitable for relightable rendering. No alternative in the paper's comparison provides all four capabilities in an integrated system. However, because the paper provides no compute or latency measurements for any method, a practitioner cannot make a compute-aware decision — if Hunyuan3D 2.5's 10B shape model plus multi-view 768×768 PBR generation requires orders of magnitude more inference compute than Trellis or Craftsman, the quality advantage must be weighed against the cost, and the paper provides no basis for that weighing. The absence of a compute-matched comparison means the "prefer" decision cannot include efficiency as a criterion based on evidence in this paper.

Dependency tree

Papers this one builds on, walking backwards through the same domain and shared topics.

Cube: A Roblox View of 3D Intelligence2025· architecture← LLM-judged similar
- Hunyuan3D 2.0: Scaling Diffusion Models for High Resolution Textured 3D Assets Generation2025· llm-systems← LLM-judged similar
- RWKV-7 "Goose" with Expressive Dynamic State Evolution2025· architecture← in-domain predecessor
CyberV: Cybernetics for Test-time Scaling in Video Understanding2025· vision← in-domain predecessor
- Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters2024· inference-optimization← LLM-judged similar
- SeedVR2: One-Step Video Restoration via Diffusion Adversarial Post-Training2025· vision← in-domain predecessor
- Molmo2: Open Weights and Data for Vision-Language Models with Video Understanding and Grounding2026· vision← similar topic
- Divide, then Ground: Adapting Frame Selection to Query Types for Long-Form Video Understanding2025· vision← similar topic
HiFi-Inpaint: Towards High-Fidelity Reference-Based Inpainting for Generating Detail-Preserving Human-Product Images2026· vision← similar topic
- Mode Seeking meets Mean Seeking for Fast Long Video Generation2026· vision← in-domain predecessor
- Seed3D 1.0: From Images to High-Fidelity Simulation-Ready 3D Assets2025· vision← similar topic
Lynx: Towards High-Fidelity Personalized Video Generation2025· vision← similar topic
- AToken: A Unified Tokenizer for Vision2025· vision← in-domain predecessor
- FlowAct-R1: Towards Interactive Humanoid Video Generation2026· vision← similar topic
- LayerComposer: Multi-Human Personalized Generation via Layered Canvas2025· vision← similar topic
- Towards Universal Video Retrieval: Generalizing Video Embedding via Synthesized Multimodal Pyramid Curriculum2025· vision← similar topic

What it influenced

Later papers in the same chain. Direction reversed.

Hunyuan-GameCraft: High-dynamic Interactive Game Video Generation with Hybrid History Condition2025· vision→ in-domain predecessor
- AI-Generated Video Detection via Perceptual Straightening2025· vision→ in-domain predecessor
- DC-VideoGen: Efficient Video Generation with Deep Compression Video Autoencoder2025· vision→ similar topic
- EgoX: Egocentric Video Generation from a Single Exocentric Video2025· vision→ similar topic
- FlowAct-R1: Towards Interactive Humanoid Video Generation2026· vision→ similar topic
Lynx: Towards High-Fidelity Personalized Video Generation2025· vision→ similar topic
- TurboDiffusion: Accelerating Video Diffusion Models by 100-200 Times2025· inference-optimization→ LLM-judged similar
- V2V-GoT: Vehicle-to-Vehicle Cooperative Autonomous Driving with Multimodal Large Language Models and Graph-of-Thoughts2025· vision→ in-domain predecessor
- Towards Universal Video Retrieval: Generalizing Video Embedding via Synthesized Multimodal Pyramid Curriculum2025· vision→ similar topic
Seed3D 1.0: From Images to High-Fidelity Simulation-Ready 3D Assets2025· vision→ similar topic
- LayerComposer: Multi-Human Personalized Generation via Layered Canvas2025· vision→ in-domain predecessor
- HiFi-Inpaint: Towards High-Fidelity Reference-Based Inpainting for Generating Detail-Preserving Human-Product Images2026· vision→ similar topic