HY3D-Bench: Generation of 3D Assets

🎯 Pitch

Raw 3D datasets like Objaverse are abundant but remain largely unusable for training without months of intensive preprocessing. HY3D-Bench ships over 250k pre-cleaned, watertight assets with per-part decompositions and even generates 125k synthetic objects to fill long-tail category gaps. Most strikingly, training a compact 832M-parameter model on this curated data matches the performance of a full-scale model with 33% more parameters, proving that democratizing high-fidelity data engineering can dramatically lower the barrier to competitive 3D generation.

1. Executive Summary

This paper introduces HY3D-Bench, an open-source ecosystem that curates and distributes high-quality, training-ready 3D data to address the preprocessing bottlenecks plaguing 3D generative modeling. Using Objaverse and Objaverse-XL as source repositories, the work applies a rigorous multi-stage pipeline—full-level data processing (watertight mesh generation via $512^3$ grid UDF computation and Delaunay triangulation) and part-level data processing (connected-component splitting with area-threshold merging)—to produce 252k holistic assets and 240k part-decomposed assets with multi-view renderings and per-part masks, and further bridges real-world distribution gaps through an AIGC synthesis pipeline—text-to-text expansion via LLM followed by LoRA-fine-tuned image generation and image-to-3D reconstruction—contributing 125k long-tail synthetic assets spanning 1,252 fine-grained sub-categories. Training a scaled-down Hunyuan3D-2.1-Small model (832M parameters) on this curated data yields a Uni3D-I score of 0.3606—competitive with the full Hunyuan3D-2.1 model (0.3636) despite having ~33% fewer parameters—demonstrating that democratized access to preprocessed, high-fidelity data enables strong generation performance without requiring researchers to solve the data engineering problem themselves, with the key boundary condition that the framework currently addresses only static assets and leaves dynamic content to future work.

2. Context and Motivation

The Core Problem: 3D Data Is Abundant but Unusable Without Massive Preprocessing

The fundamental challenge this paper addresses is deceptively simple: the 3D research community has access to millions of raw 3D models, but transforming those models into training-ready data is so expensive and technically complex that it creates a severe bottleneck for progress in 3D generative modeling. The paper identifies this as a data processing problem rather than a data scarcity problem. Objaverse (Deitke et al., 2022) and Objaverse-XL (Deitke et al., 2023) together provide millions of 3D assets spanning diverse categories, but the paper argues that these raw assets are "unsuitable for direct application in downstream tasks such as 3D generation" (Section 4) due to a cascade of quality and format issues.

This gap is critical because the recent breakthroughs in 3D generation—particularly native 3D generation methods that learn directly from 3D representations (Section 2.1)—are fundamentally data-hungry. Methods like 3DShape2Vecset (Zhang et al., 2023), CLAY (Zhang et al., 2024), CraftsMan (Li et al., 2024c), TripoSG (Li et al., 2025b), and Hunyuan3D-2.1 (Hunyuan3D et al., 2025a) all follow a paradigm inspired by 2D latent diffusion: train a 3D VAE to compress shapes into a compact latent representation, then train a diffusion model on those latents. This paradigm shift from optimization-based generation (SDS) to feedforward generation means that data quality and data processing directly determine model capability—poor watertight meshes produce poor SDF training signals, inconsistent orientations confuse the VAE, and missing multi-view renderings prevent image-conditioned training.

Why Prior Datasets Fall Short: Three Categories of Systemic Deficiencies

The paper catalogs the specific failures of raw Objaverse assets in detail (Section 4), grouping them into three categories:

Format and standardization failures. Different 3D modeling software (Blender, Maya, 3ds Max) produces assets with incompatible coordinate systems—left-handed vs. right-handed, Y-up vs. Z-up—causing orientation errors or mirror flipping when loaded in different environments. Many assets employ multi-level node hierarchies with parent-child scale inheritance relationships and hidden transformation matrices, requiring complex scene graph traversal to extract usable geometry. These are not cosmetic issues; for a 3D VAE learning a signed distance function from point samples, a Y-up vs. Z-up inconsistency means the latent space must waste capacity disentangling arbitrary coordinate conventions rather than learning meaningful shape variation.

Geometric quality failures. The paper describes three sub-problems in detail:

Insufficient polygon counts: "overly simplified meshes" that "fail to accurately represent the detailed features of objects" (Section 4). For training a $512^3$ -resolution SDF, a mesh with too few triangles undersamples the true surface, producing aliasing artifacts in the ground-truth distance field.
Topological defects: non-manifold edges, self-intersecting faces, and isolated vertices render the assets unsuitable for watertight mesh extraction—a prerequisite for computing signed distance functions, since SDFs require a well-defined inside/outside distinction.
Texture mapping errors: serious UV unwrapping problems, incorrect texture-to-geometry mapping, excessively low texture resolution, or missing textures compromise the rendered images that feed image-conditioned generation pipelines.

Ecosystem-level deficiencies. Beyond per-asset quality:

Severely imbalanced category distribution: Common categories like chairs and tables are abundant, while rare but real-world-important categories are scarce, limiting model generalization to long-tail items.
Lack of structured information: The vast majority of assets are "holistic, monolithic meshes, lacking hierarchical part decomposition and assembly relationship descriptions" (Section 4). This constrains fine-grained understanding, editable generation, and robotic manipulation—all of which require knowing where one part ends and another begins.

Why This Problem Matters: Practical, Scientific, and Economic Stakes

Practical barrier to entry. The paper emphasizes that "mainstream 3D generation models typically require extensive preprocessing of raw 3D data to generate task-specific representations, such as rendered images, watertight meshes, and corresponding Signed Distance Function (SDF) fields" (Section 2.2). This preprocessing "not only increases the entry barrier for researchers new to 3D generation, requiring proficiency in specialized data processing techniques, but also imposes substantial computational burdens." A researcher with a good idea for a 3D VAE architecture must first become expert in Blender scripting, mesh repair algorithms, and multi-view rendering pipelines before they can even begin training. The paper estimates that processing millions of 3D models "demands enormous GPU and CPU computational resources" that many academic labs simply do not have.

Scientific impact on reproducibility and fair comparison. When every group processes raw Objaverse independently, they inevitably make different filtering choices, use different rendering configurations, and apply different watertightening algorithms. This makes comparing methods scientifically difficult—is a model's improved performance due to a better architecture, or due to better-processed training data? The paper identifies this fragmentation explicitly: "Unlike previous works with inconsistent evaluation protocols, we provide a complete suite of standard metrics, baselines, and a fixed experiment setting" (Section 1).

Economic implications for real-world deployment. The paper connects data quality to practical applications including robotics simulation, digital content creation, and e-commerce product visualization. For robotics in particular, watertight meshes are non-negotiable—physical simulation engines require closed, manifold geometry to compute collision detection and grasp planning. Part-level decomposition enables learning manipulation policies that reason about object components. The AIGC synthesis pipeline addresses the long-tail problem: for e-commerce, the universe of real products (1,252 fine-grained sub-categories in this paper's taxonomy) far exceeds what manual 3D modeling can economically cover, and a model trained only on common categories will fail on niche products.

What Prior Approaches Existed, and Where They Fall Short

The paper provides a thorough accounting of existing dataset enhancement efforts in Section 4.1, positioning each as partial solutions that address one dimension of the problem while leaving others unresolved. Understanding these prior attempts is crucial because they represent the state-of-the-art that HY3D-Bench aims to surpass.

Objaverse++ (Lin et al., 2025a): Quality filtering only. This work manually annotated 10,000 samples along quality dimensions (transparency, single-object completeness, scene attributes), then trained a quality assessment model to filter Objaverse down to 500,000 high-quality samples. The limitation the paper identifies is that "filtered data still requires complex workflows before it can be used for training" (Section 4.1). Filtering tells you which assets are good, but it doesn't make them training-ready—the watertight meshes, multi-view renderings, SDF samples, and point clouds still must be generated by the end user.

Objaverse-OA (Lu et al., 2025) and Canonical Objaverse Dataset (Jin et al., 2025): Orientation normalization only. These works addressed orientation inconsistency by annotating 14,000 and 32,000 orientation-aligned samples respectively. The paper's critique is that while orientation normalization is valuable, these datasets lack "a complete processing pipeline that covers format standardization, topology repair, high-quality rendering, and diverse sampling" (Section 4.1). An orientation-corrected mesh that is still non-manifold and poorly textured is not training-ready.

Objaverse-MIX (Qian et al., 2024): Diverse representations but quality issues. This work provided 900,000 samples with multiple geometric representations (point clouds, meshes, voxels), rendered images, and text annotations—the most comprehensive prior effort. However, the paper notes that the data "struggles to meet the training requirements of current 3D generation models due to issues such as fixed rendering viewpoints and single point cloud sampling strategy" (Section 4.1). Fixed rendering viewpoints (e.g., always the same camera angles) mean models cannot learn view-invariant representations; single point cloud sampling strategies mean models overfit to specific sampling patterns rather than learning robust geometry.

The missing piece across all prior work. The paper's synthesis of these limitations reveals a pattern: each prior work optimized one preprocessing dimension, but no work provided a complete, end-to-end pipeline that produces training-ready asset packages suitable for the current generation of 3D VAE + diffusion models. As the paper states, "existing works have improved Objaverse from different dimensions... however, the following systemic deficiencies still exist: insufficient comprehensiveness and depth in data processing, filtered data still requires complex workflows, and processed data struggles to meet the training requirements of current 3D generation models" (Section 4.1).

How This Paper Positions Itself

HY3D-Bench is positioned not as a new model or algorithm, but as infrastructure—a "unified, high-quality foundation" (Abstract) that democratizes access to the data that 3D generation research depends on. The paper explicitly frames its contributions as addressing the "critical bottleneck for the broader research community, hindering the rapid iteration and widespread adoption of 3D generation models" (Section 2.2).

Three-pillar architecture as a response to three deficiencies. The paper's contribution structure is designed to directly counter the systemic problems it identifies:

The full-level data library (252k assets) addresses the preprocessing burden by providing complete, training-ready packages that include watertight meshes at $512^3$ resolution (generated via UDF computation → $\epsilon$ -contour extraction → Delaunay tetrahedralization → graph-cut optimization), multi-view renderings with both orthographic and perspective cameras, and hybrid point cloud sampling combining surface uniform and edge importance sampling. This is designed so that "researchers can conduct algorithmic exploration and research on a unified, high-quality benchmark" (Section 4).
The part-level decomposition (240k assets) addresses the lack of structured granularity by providing connected-component-based part splitting with area-threshold merging (mean 14.13 parts per object), per-part watertight meshes, and paired RGB renderings with part ID masks. The paper notes this delivers "the necessary information for part-aware generation and fine-grained perception tasks" (Section 1).
The AIGC synthesis pipeline (125k synthetic assets) addresses the long-tail distribution gap by leveraging a three-step paradigm—Text-to-Text for semantic expansion (LLM-generated descriptions of 1,252 fine-grained product categories with controlled diversity in shape, material, and color), Text-to-Image via LoRA-fine-tuned Qwen-Image (optimized for clean backgrounds, complete objects, appropriate positioning, and three-quarter viewpoints), and Image-to-3D via HY3D-3.0 (producing fine geometry with clear textures). The pipeline targets categories where "manual 3D modeling is prohibitively expensive" (Section 1).

Standardized evaluation as a positioning move. Beyond data release, the paper establishes a 400-object test set with fixed evaluation protocols using ULIP (Xue et al., 2023a) and Uni3D (Zhou et al., 2023) metrics for image-to-3D consistency. By releasing "standardized training configurations and pre-trained model checkpoints" (Section 1), the paper positions HY3D-Bench as a platform for fair comparison—answering the fragmentation concern that different groups' incompatible preprocessing choices make head-to-head comparison scientifically suspect.

Validation strategy: proving the data's worth through a smaller model. Rather than simply asserting that the processed data is high-quality, the paper takes the unusual and scientifically honest approach of training a scaled-down model—Hunyuan3D-2.1-Small (832M parameters, with reduced channel dimensions and no Mixture of Experts)—on the dataset to demonstrate that the data quality, not model scale, is the differentiator. The result that this model achieves a Uni3D-I score of 0.3606, competitive with the full 1,238M-parameter Hunyuan3D-2.1 (0.3636), is the paper's central empirical argument: when data quality is controlled, smaller models can approach larger models' performance. This inverts the typical narrative that performance gains come primarily from scaling model size, and instead argues that the community has been limited by data quality, not model capacity.

What the paper does NOT claim to solve. The scope is explicitly bounded: the framework covers only static 3D assets, not dynamic objects, animations, or scenes. The part-level decomposition is based on geometric connectivity (connected components), not semantic part labeling—the parts are separated but not named or categorized. The AIGC pipeline produces assets that inherit the biases of the LLM and image diffusion model used in the pipeline, and the paper does not deeply analyze those biases. These are acknowledged limitations that define the boundaries of the contribution.

3. Technical Approach

3.1 Reader Orientation

This paper is primarily a data infrastructure and curation paper — it doesn't propose a new 3D generation algorithm, but rather builds a system that takes raw, messy 3D assets from large-scale repositories and transforms them into clean, standardized, training-ready packages that can directly feed modern 3D generative models (VAEs and diffusion models). The core idea is that the 3D generation field doesn't suffer from a lack of raw data (Objaverse alone has millions of models), but from a severe preprocessing bottleneck: converting those raw models into watertight meshes, multi-view renderings, part decompositions, and correctly sampled point clouds requires such specialized expertise and massive compute that it walls off most researchers from even beginning to train 3D generative models. HY3D-Bench solves this by doing all that preprocessing once, at scale, and releasing the results as open-source, training-ready asset packages — effectively democratizing access to the data foundation that modern 3D generation depends on.

3.2 Big-Picture Architecture (Diagram in Words)

The HY3D-Bench ecosystem has five major components connected by sequential data flow:

Full-Level Data Processing Pipeline — takes raw Objaverse/Objaverse-XL meshes, standardizes coordinate systems and formats via Blender rendering, applies multi-dimensional quality filtering (geometric complexity, texture quality, thin-structure exclusion), and produces watertight meshes via UDF computation plus Delaunay tetrahedralization with graph-cut optimization. Outputs: 252k watertight PLY meshes, multi-view RGB renderings, and hybrid-sampled point clouds.
Part-Level Data Processing Pipeline — takes the full-level static meshes, performs connected-component analysis to split objects into constituent parts, applies area-threshold merging to avoid over-fragmentation (target: 10–40 parts per object), filters for component count reasonableness and part scale balance, then produces per-part watertight meshes plus paired RGB renderings and part ID masks. Outputs: 240k part-decomposed assets with holistic and per-part watertight meshes, multi-view RGB images, and 2D part mask images.
AIGC Synthesis Pipeline — a three-stage generative pipeline to address long-tail category gaps. Stage 1: LLM-based text expansion generates detailed product descriptions for 1,252 fine-grained e-commerce categories. Stage 2: LoRA-fine-tuned Qwen-Image transforms those descriptions into clean-background, appropriately-positioned product images. Stage 3: HY3D-3.0 reconstructs those images into textured 3D meshes. Outputs: 125k synthetic 3D assets spanning categories poorly represented in real datasets.
Standardized Evaluation Framework — a 400-object test set with fixed evaluation protocols, released model checkpoints, and standard metrics (ULIP and Uni3D for image-to-3D consistency).
Validation Model (Hunyuan3D-2.1-Small) — a scaled-down 832M-parameter version of Hunyuan3D-2.1 trained on the curated full-level data to empirically demonstrate that the dataset's quality enables strong generation performance even at reduced model scale.

The flow is: raw Objaverse assets → Full-Level Pipeline → watertight meshes + renderings → (optionally) Part-Level Pipeline → part-decomposed assets → (separately) AIGC Synthesis Pipeline → synthetic assets → all three data pools released as standardized packages → researchers train models directly on these packages without running preprocessing themselves.

3.3 Roadmap for the Deep Dive

First, the Full-Level Data Processing Pipeline (Section 4.2), since it is the foundation that produces the watertight meshes and renderings that all downstream training depends on. Understanding the three-phase structure (rendering/conversion → filtering → post-processing) and the specific algorithms used (Marching Cubes, Delaunay triangulation, graph-cut optimization) is essential because these choices determine what geometric quality "means" in this dataset.
Second, the Part-Level Data Processing Pipeline (Section 4.3), which extends the full-level pipeline by decomposing holistic meshes into semantically consistent parts. The key technical decisions here are the connected-component splitting strategy, the area-threshold merging rules, and the filtering criteria that determine what counts as a "reasonable" part decomposition.
Third, the AIGC Synthesis Pipeline (Section 4.4), which operates on a fundamentally different principle from the first two — it generates novel data rather than curating existing data. The three-stage Text→Image→3D architecture, the LoRA fine-tuning objectives for image generation, and the category taxonomy design are the critical technical elements.
Fourth, the VAE and Diffusion Model Background (Section 3), which provides the technical context for why the data must take the specific forms it does. Understanding the VecSet latent representation, the signed distance function reconstruction loss, and the flow matching objective explains the downstream requirements that drive the preprocessing design choices.
Fifth, the Data Distribution and Splits (Section 4.5), which specifies what exactly is released: train/val/test splits (252k/276/400 for full-level), category hierarchies (19 top-level, 74 mid-level, 389 fine-grained), and part count statistics (mean 14.13, median 11).
Sixth, the Hunyuan3D-2.1-Small Validation Setup (Section 5.1), which connects the data curation to empirical evidence by describing the progressive token-resolution training strategy and architectural modifications that demonstrate the dataset's utility.

3.4 Detailed, Sentence-Based Technical Breakdown

This is a data infrastructure and empirical validation paper whose core contribution is a multi-stage processing pipeline that transforms raw, heterogeneous 3D assets into standardized, training-ready data packages, combined with an AIGC pipeline for synthetic data augmentation and a validation experiment showing that models trained on this data achieve competitive performance at reduced scale.

Full-Level Data Processing: Rendering, Conversion, Filtering, and Watertightening

The full-level pipeline (Section 4.2, Figure 3) is the foundation of the entire ecosystem. It takes arbitrary 3D assets from Objaverse and Objaverse-XL as input and produces three standardized outputs per asset: a watertight PLY mesh, multi-view RGB renderings, and a hybrid-sampled point cloud. The pipeline consists of three sequential phases.

Phase 1: Data Rendering and Format Conversion. The first step addresses the format heterogeneity problem described in Section 4. Input assets come from diverse modeling software (Blender, Maya, 3ds Max) with incompatible coordinate systems, node hierarchies, and file formats. The paper's solution combines manual annotation and automated conversion:

All assets are converted to single-frame static mesh representations — meaning any animation data, multi-frame sequences, or scene-graph hierarchies are collapsed into a single, static geometric representation. This is necessary because 3D generative models learn from static shape snapshots, not animated sequences, and the presence of animation bones, keyframes, or multi-object scenes would introduce irrelevant variation into the training distribution.
Orientations are aligned to a unified convention, though the specific alignment procedure is not detailed algorithmically. The paper notes that this standardization "eliminates coordinate system differences between different modeling software and excludes multi-view rendering inconsistencies caused by model animations" (Section 4.2).
Blender is used as the rendering engine to perform multi-view rendering with two camera modes: orthographic projection (where all projection lines are parallel, preserving relative sizes regardless of depth) and perspective projection (where objects farther from the camera appear smaller, matching human visual experience). Providing both modes ensures that downstream models can handle both types of visual input, expanding the dataset's utility.
The final static meshes are exported in PLY format — a flexible, widely-supported format that stores vertex positions, face connectivity, and optionally vertex colors and normals. The paper chooses PLY for its "excellent cross-platform compatibility and efficient storage characteristics" (Section 4.2).

Why these choices? The decision to collapse animations and standardize orientations is not cosmetic. A 3D VAE learning a latent representation of shape would need to expend capacity disentangling arbitrary coordinate conventions and animation states if they varied in the training data. By normalizing these factors during preprocessing, the latent space can focus on representing meaningful geometric variation — the shape of the chair, not whether the model happened to be exported with the seat facing +Y or +Z. The dual camera mode decision reflects an understanding that different downstream applications need different visual representations: orthographic for technical/engineering applications, perspective for visual content creation.

Phase 2: Assets Filtering. After rendering and conversion, the pipeline applies a multi-dimensional quality filter designed to exclude three categories of inadequate data. The filtering criteria are grounded in specific geometric and visual properties that the paper argues are detrimental to model training.

Filter Category 1: Poor geometric quality. The paper identifies "duplicated and overly simplified 3D assets" with "extremely low polygon counts, lack of necessary geometric details, and overly simple topological structures" (Section 4.2). The operational criterion is a polygon count threshold combined with a geometric complexity metric — though the exact threshold values are not specified in the paper. The rationale is that "retaining geometrically rich meshes with sufficient details can provide more valuable learning signals for the model." This matters because the 3D VAE's decoder must learn to reconstruct signed distance fields at $512^3$ resolution; training on meshes with too few triangles means the ground-truth SDF undersamples the true surface, producing aliasing artifacts that the decoder then learns to reproduce.

Filter Category 2: Poor texture quality. The paper excludes assets with "serious UV mapping problems; overlapping faces in the geometry causing abnormal texture display; excessively low texture resolution or missing texture maps" (Section 4.2). This is critical for image-conditioned generation pipelines: if the rendered images used for training show corrupted textures, the image encoder's conditioning signal will be unreliable, and the model may learn to ignore texture cues rather than learning accurate texture-to-geometry correspondences.

Filter Category 3: Large areas of thin structures. This is the most technically nuanced exclusion criterion. The paper argues that thin structures pose two distinct problems:

For implicit representations (SDF): "The Signed Distance Field at thin structures undergoes abrupt jumps, transitioning from positive to negative values within an extremely small spatial range, which significantly increases the difficulty of model learning and fitting and can easily lead to training instability" (Section 4.2). The physical intuition: in a thin sheet, a point just above the surface has a small positive SDF value, a point just below has a small negative value, and the transition between them is extremely sharp — requiring the SDF decoder to represent a high-frequency discontinuity that is fundamentally difficult for neural networks to capture smoothly.
For multi-view consistency: Thin structures "under certain viewpoints are difficult to observe or even completely invisible in 2D images (such as when viewing along the thin sheet direction), which reduces the stability and convergence speed of model learning" (Section 4.2). If a thin fin on a model is invisible in 70% of rendered views, the image-conditioned training signal for that feature is sparse and inconsistent.

Why is this filtering strategy more comprehensive than prior work? The paper contrasts this with Objaverse++, which performed quality filtering but didn't produce training-ready data. The key difference is that HY3D-Bench's filtering criteria are directly motivated by the downstream training requirements — polygon count matters because it affects SDF resolution, texture quality matters because it affects image-conditioning signal quality, thin structures matter because they create specific optimization pathologies — rather than being based on generic "looks good" criteria.

Phase 3: Post-Processing. After filtering, the retained assets undergo three transformations that make them directly usable for training 3D VAEs and diffusion models.

Post-Processing Step 1: Watertight Processing. This is the most algorithmically sophisticated step in the pipeline. A watertight mesh is one where every edge is shared by exactly two faces, creating a closed, manifold surface that cleanly divides space into inside and outside — a prerequisite for computing signed distance functions, since the SDF at a point is defined as the signed distance to the nearest surface, which requires unambiguous inside/outside classification.

The paper's watertightening procedure follows a four-stage algorithm:

Stage 1a: UDF computation. Given a potentially non-manifold, open artist-created triangle mesh, the pipeline first computes the Unsigned Distance Field (UDF) on a uniform grid at $512^3$ resolution. The UDF at each grid point is the minimum Euclidean distance to the mesh surface, without regard to inside/outside — this avoids the need for the original mesh to have consistent orientation or manifold topology.

The paper refers to computing the "Unsigned Distance Field (UDF) on a uniform grid with $512^3$ resolution" (Section 4.2).

Why UDF instead of SDF? Computing an SDF requires knowing which side of the surface is "inside," which is undefined for non-manifold meshes. The UDF sidesteps this by computing only absolute distances, which are always well-defined regardless of mesh quality.

Stage 1b: $\epsilon$ -contour extraction. From the computed UDF grid, the pipeline extracts an $\epsilon$ -contour thin shell mesh using Marching Cubes with $\epsilon = 1/512$ , where $\epsilon$ is a small isovalue. Marching Cubes is a classic algorithm that processes each grid cell independently, determining how a surface at a given isovalue intersects the cell based on which corners are above or below the threshold. By extracting the $\epsilon$ -contour (the surface at distance $\epsilon$ from the original mesh) rather than the 0-contour (the original surface), the algorithm produces a thin shell — a closed surface that wraps around the original mesh at a small offset. This shell is guaranteed to be watertight because Marching Cubes produces closed surfaces from scalar fields, even if the original mesh was non-manifold.

Stage 1c: Delaunay tetrahedralization. The pipeline samples points on the thin shell mesh $\mathcal{M}$ and applies Delaunay triangulation to construct a volumetric tetrahedral mesh. Delaunay triangulation connects the sampled points into tetrahedra such that no point lies inside the circumsphere of any tetrahedron — this property maximizes the minimum angle of all tetrahedra, avoiding "sliver" elements with extreme aspect ratios that would cause numerical instability in subsequent steps. The result is a volumetric decomposition of the space enclosed by the thin shell into tetrahedral cells.

Stage 1d: Graph-cut optimization and surface extraction. Following the approach of ConvexMeshing (Diazzi and Attene, 2021), the pipeline optimizes tetrahedral cell labels (0 for inner, 1 for outer) using graph-cut optimization. Graph-cut frames the labeling problem as an energy minimization: a data term encourages each tetrahedron's label to match some observation (e.g., proximity to the original mesh surface), while a smoothness term encourages neighboring tetrahedra to have the same label, with the cost of disagreement proportional to the shared face area. The globally optimal labeling is found via min-cut/max-flow, producing a clean partition of space into interior and exterior. The boundary surface between interior-labeled and exterior-labeled tetrahedra is extracted as the final watertight mesh.

Why this elaborate procedure instead of a simpler approach? Simpler watertightening methods (e.g., hole-filling via mesh editing operations) require heuristics for where to add triangles to close holes, which often fail on complex topology or introduce self-intersections. The UDF → Marching Cubes → Delaunay → graph-cut pipeline is more computationally expensive but produces guaranteed-watertight output with theoretically well-understood properties (the graph-cut labels are globally optimal for the chosen energy function). For a dataset intended as a foundation for 3D generation research, this robustness justifies the computational cost.

Post-Processing Step 2: Point Cloud Sampling. The 3D VAE described in Section 3 takes point clouds as input, not meshes directly, so the watertight meshes must be converted to point samples. The paper implements a hybrid sampling scheme combining two strategies:

Surface uniform sampling: Points are distributed uniformly over the mesh surface, ensuring that all regions are represented roughly equally regardless of local curvature or feature density. This provides good coverage of the overall shape.
Edge importance sampling: Additional samples are concentrated near geometric edges and high-curvature regions, ensuring that sharp features and fine details are captured in the point cloud representation.

The paper credits the sampling strategies of Dora (Chen et al., 2025) and Hunyuan3D-2.1 (Hunyuan3D et al., 2025a) as the basis for this approach.

Why hybrid sampling? Pure uniform sampling can miss sharp edges because edges occupy zero area on a continuous surface — as the number of uniform random points increases, the probability of a point falling exactly on an edge approaches zero. Yet edges and corners are precisely the features that define an object's identity (the corner of a table, the edge of a phone). Edge importance sampling explicitly adds points in these regions, ensuring the VAE's encoder receives information about sharp features. Conversely, pure edge sampling would undersample smooth regions (the flat seat of a chair), producing a sparse representation that misses large-scale shape. The hybrid approach balances both.

Coordinate system alignment. The paper notes that "we rotated the coordinate system to Y-up during the post-processing stage" (Section 4.2). This means the Y-axis points upward in the final coordinate frame, matching the convention used by many graphics and robotics applications. This is applied during post-processing rather than earlier to ensure consistency across all assets regardless of their original orientation conventions.

What the final output contains. For each full-level asset that passes all filtering stages, the pipeline produces:

A watertight PLY mesh at $512^3$ effective resolution (matching the UDF grid resolution)
Multi-view RGB renderings captured with both orthographic and perspective cameras
A point cloud sampled via the hybrid surface-uniform + edge-importance strategy, with $N$ points (the exact $N$ is not specified, but the VAE description in Section 3 uses a generic $N \times (3 + C)$ point cloud, where $C$ denotes surface normals)

These three representations form a complete training data package for the image-to-3D generation pipeline: the renderings provide the image conditioning signal, the point cloud provides the input to the VAE encoder, and the watertight mesh provides the ground truth for computing SDF supervision.

Part-Level Data Processing: Decomposition, Filtering, and Per-Part Rendering

The part-level pipeline (Section 4.3, Figure 4) extends the full-level processing by decomposing holistic watertight meshes into semantically meaningful constituent parts. This is fundamentally harder than full-level processing because it requires making decisions about what constitutes a "part" — a semantic question that geometric algorithms can only approximate. The pipeline consists of three phases, with careful filtering to ensure the resulting decompositions are useful for downstream training.

Phase 1: Part Splitting. The decomposition strategy operates in three steps.

Step 1a: Connected Component Analysis. The pipeline first performs Connected Component Analysis (CCA) on each static mesh. In a triangle mesh, two vertices are connected if there exists a path of edges between them. Connected components are maximal sets of mutually reachable vertices — in simple terms, separate "pieces" of the mesh that don't share any geometry. This algorithm "can automatically identify physically separated parts within the mesh, aligning the division of the holistic mesh with the semantic granularity designed by artists during the creation process" (Section 4.3).

Why connected components? The key insight is that artists typically model separate parts of an object as disconnected mesh components — the legs of a chair might be separate meshes positioned near the seat mesh, but without shared vertices or edges. Connected component analysis naturally recovers this artist-intended decomposition without requiring any semantic understanding, simply by analyzing mesh topology. However, this approach has a fundamental limitation: it can only detect parts that are geometrically disconnected. If an artist modeled a chair as a single connected mesh (e.g., the legs and seat share vertices at the joints), connected component analysis would see only one component, and the chair would be excluded from the part-level dataset (since it fails the component count threshold).

Step 1b: Preliminary Quality Filtering. Two thresholds are applied immediately after CCA:

Complex assets with >888 components are excluded. These typically contain "numerous trivial small parts or decorative elements" that would produce an excessively complex decomposition, increasing data processing difficulty without corresponding semantic value.
Indivisible assets with <2 components are excluded because they "cannot provide structural information at the part-level" — a single-component object has no part decomposition by definition.

Step 1c: Automatic Merging via Area Thresholds. The initial CCA decomposition often over-fragments objects — an artist might model a chair leg as five separate decorative rings for visual detail, but semantically these should be merged into a single "leg" part. To address this, the pipeline implements an area-based merging strategy:

The surface area of each component is calculated.
Area thresholds are set to identify small, trivial parts — components with area "significantly below the threshold" are merged into adjacent larger components based on spatial adjacency relationships.
After merging, the target component count for the "vast majority of assets is controlled between 10 and 40" (Section 4.3).

Why 10–40 components? The paper argues this range "both retains sufficient semantic granularity and avoids excessive complexity, making it highly suitable for the training requirements of part-level generation tasks" (Section 4.3). Too few components (2–5) lose the fine-grained structure needed for controllable editing; too many (>50) make the part generation task excessively difficult and the per-part meshes individually too simple to be informative.

Phase 2: Assets Filtering. After splitting and merging, three filtering criteria ensure only high-quality part decompositions are retained.

Filter 1: Component quantity reasonableness. Assets with ≤1 components (splitting failure) or >50 components (excessive complexity) are excluded. The >50 threshold is higher than the target range (10–40) to allow some assets with naturally many parts (e.g., complex mechanical assemblies) to remain while still excluding pathological cases.

Filter 2: Part scale balance. Assets where "the area of a single component exceeds 85% of the total area of the surface of the object" (Section 4.3) are excluded. These are cases where the decomposition is highly imbalanced — one massive dominant part plus several tiny auxiliary parts. The paper gives the example of "a large tabletop with tiny leg connectors." This imbalanced distribution is problematic because "it is detrimental to the model learning reasonable proportional relationships and compositional logic among parts" (Section 4.3). A part-aware generation model trained on such examples might learn that parts can be arbitrarily small relative to the whole, leading to unrealistic generated compositions.

Filter 3: Isolated small part quantity. Assets containing too many isolated small-area components are excluded. These isolated small parts "are often decorative trivial elements that typically do not provide valuable semantic information and can interfere with the model's learning of relationships among major parts" (Section 4.3). The proportion of such isolated small parts serves as a quality indicator.

Phase 3: Post-Processing. After filtering, each retained asset generates a comprehensive training data package.

Step 3a: Multi-view rendering with part masks. The pipeline renders each decomposed asset from multiple views, producing two complementary image types:

RGB texture images: Standard rendered images using the original texture maps, providing realistic appearance.
Part ID masks: Each part is assigned a unique integer ID, and for each rendered view, a 2D mask image is generated where "each pixel's value corresponds to the ID of the part it belongs to" (Section 4.3).

The paired RGB + mask images enable training of part-aware generation models: the RGB provides appearance information, and the corresponding mask provides the ground-truth part segmentation that the model should learn to predict or condition on.

Step 3b: Dual-level watertightening. Watertight processing is applied at two levels:

Holistic mesh watertightening: The complete merged object is watertightened as one unit, producing a topologically closed representation of the entire object.
Per-part mesh watertightening: Each individual part mesh is watertightened separately. This step is crucial because "many parts may have open boundaries at connection points after decomposition, and watertight processing can complete these boundaries, making each part an independent, complete 3D object" (Section 4.3).

Why per-part watertightening? After connected component splitting, parts that were originally connected (e.g., a chair seat with holes where legs attach) will have open boundaries — surfaces that end abruptly with no back face. These open surfaces are not valid 3D solids. Per-part watertightening closes these boundaries by adding the missing surfaces (the "cap" that fills the hole), transforming each part into a topologically closed solid. This is necessary for part-level generation models that need to represent each part as a complete 3D shape, not a partial surface.

Final output per part-level asset. Each retained asset produces:

A reasonable number of semantically consistent parts (mean 14.13, median 11, with 24.63% having 2–5 parts, 24.83% having 6–10, 27.00% having 11–20, and the remainder having 21–50)
Multi-view RGB images and corresponding part ID masks
Watertight meshes for both the holistic object and each individual part

This data package enables training of part-aware generation models, fine-grained 3D understanding models, and simulation environments for robotic manipulation — all applications that require knowing not just what an object is, but how it is composed.

Design choice: geometric vs. semantic part decomposition. The paper explicitly acknowledges that the connected-component approach produces geometric, not semantic, part decompositions. The parts are separated but not named, categorized, or assigned semantic labels. This is a deliberate tradeoff: geometric decomposition via CCA is fully automatic and scalable to hundreds of thousands of assets, whereas semantic part labeling would require human annotation at a scale that is currently infeasible. The paper positions this as a foundation that can be built upon — researchers can take the geometric part decompositions and add semantic labels for specific categories if needed, but the geometric separation provides the prerequisite structure.

AIGC Synthesis Pipeline: Text-to-Text, Text-to-Image, Image-to-3D

The AIGC pipeline (Section 4.4, Figure 5) operates on a fundamentally different principle from the curation pipelines. Instead of cleaning existing data, it generates novel 3D assets to address the long-tail distribution problem — rare product categories where real 3D models are scarce or nonexistent. The pipeline chains three generative stages, each leveraging a different type of foundation model.

Stage 1: Text Expansion (LLM-based semantic diversification). The pipeline begins with a manually constructed e-commerce product category system collected from "mainstream e-commerce platforms and product databases" (Section 4.4). After excluding service-oriented virtual products (insurance, membership services), the system retains 1,252 specific physical product categories.

For each category, an LLM generates detailed product descriptions guided by a prompt designed around three principles:

"Ensuring basic rationality and authenticity, generating physically and logically reasonable descriptions around the category; providing rich visual details, including key attributes such as the object's shape, material, color, and size proportions; expanding diversity, imaginatively expanding the product's form, materials, and other content within a reasonable range, setting aside limitations of actual craftsmanship, cost, and other factors" (Section 4.4)

Why LLM-based expansion? The key value of this stage is diversity generation. A single product category like "desk lamp" could correspond to thousands of visually distinct real products with different shapes, materials, colors, and styles. The LLM's role is to produce descriptions that cover this diversity space, providing varied conditioning signals for the subsequent image generation stage. The instruction to "set aside limitations of actual craftsmanship and cost" is particularly important — it encourages the LLM to imagine lamp designs that may not exist commercially but are physically plausible, expanding the diversity of the training distribution beyond what real-world data alone could provide.

The LLM used is not named or versioned in the paper, and the exact prompt template is not provided. This is a notable omission since the LLM's output quality directly determines the diversity and quality of the entire synthetic data pipeline.

Stage 2: Image Generation (Diffusion-based visual synthesis with LoRA fine-tuning). The text descriptions from Stage 1 are fed into Qwen-Image, a text-to-image diffusion model, to produce photorealistic product images. However, the paper identifies that generic text-to-image models produce outputs unsuitable for 3D generation downstream:

"As a general-purpose text-to-image model, it often generates images containing complex backgrounds, or viewpoints unsuitable for 3D generation" (Section 4.4)

To address this, the paper applies LoRA (Low-Rank Adaptation) fine-tuning to Qwen-Image with five specific quality objectives:

Clean background: Solid color or simple gradient backgrounds with no complex scene elements, facilitating separation of foreground objects for the subsequent 3D generation stage.
Complete object: The entire object must be visible in the frame, ensuring that "overall geometric features can be accurately captured" — partial objects would lead to truncated 3D reconstructions.
Appropriate position: The object is centered and occupies a suitable proportion of the frame, avoiding being too small (losing detail) or too large (being cropped).
Reasonable viewpoint: Three-quarter views or other "information-rich observation angles that can simultaneously display multiple faces of the object, providing sufficient geometric cues for 3D generation." A pure front-on view shows only one face, while a three-quarter view shows front, side, and top simultaneously — critical for single-image 3D reconstruction.
Information-rich: The image must clearly display "key structural features, material properties, and detail elements."

Why LoRA fine-tuning? LoRA adapts a pre-trained model by training low-rank weight matrices added to existing layers, rather than fine-tuning all parameters. This is computationally efficient (small number of trainable parameters) and preserves the base model's general image generation capability while steering it toward the specific output characteristics needed for 3D generation. Full fine-tuning would risk catastrophic forgetting of the base model's image quality capabilities, while prompting alone is insufficient to reliably produce clean backgrounds and appropriate viewpoints.

The paper does not provide details on the LoRA training data (what images were used, how they were collected or generated), the training hyperparameters (rank, alpha, learning rate, number of steps), or the dataset size. These are significant omissions for reproducibility.

Stage 3: 3D Generation (Image-to-3D reconstruction). The clean product images from Stage 2 are fed into HY3D-3.0 (Tencent, 2026), the industry-leading image-to-3D model from the same organization that developed the Hunyuan3D family of models. The paper describes the output characteristics:

"Fine geometry: The generated meshes possess rich geometric details, accurately reconstructing the object's shape features, including complex structures such as edges, bumps, and holes; Clear textures: Accurate texture mapping, with visual attributes such as color, material, and surface details highly consistent with the input image" (Section 4.4)

Why HY3D-3.0? The paper chooses this model because it represents the state-of-the-art in single-image 3D reconstruction at the time of writing, leveraging the same native 3D generation paradigm (3D VAE + diffusion model trained on large-scale 3D data) that the HY3D-Bench dataset is designed to support. Using the strongest available reconstruction model maximizes the quality of the synthetic assets. However, this creates an interesting circularity: the synthetic data pipeline uses a model that was trained on datasets like Objaverse, which HY3D-Bench is curating. The synthetic data is thus not fully independent of the real data distribution — it inherits any biases or limitations of the HY3D-3.0 model, which in turn reflects the biases of its training data.

End-to-end pipeline flow. The complete synthesis process for one product category works as follows: the category label (e.g., "desk lamp") enters the LLM → the LLM generates multiple diverse text descriptions with varied shape, material, and color attributes → each description enters the LoRA-fine-tuned Qwen-Image → one clean-background, three-quarter-view product image is generated per description → each image enters HY3D-3.0 → a textured 3D mesh is reconstructed per image. The result is 125k synthetic assets spanning 20 super-categories, 130 categories, and 1,252 fine-grained sub-categories.

Design tradeoff: synthetic vs. real data. Synthetic data offers unlimited category coverage but at the cost of potential domain gap — synthetically generated meshes may differ systematically from real scanned or artist-modeled meshes in geometric detail distribution, texture realism, or part structure. The paper implicitly acknowledges this by describing the synthetic data as a "supplement" to real data, not a replacement. The synthetic assets are most valuable for categories where real data is genuinely scarce, where the benefit of filling the distribution gap outweighs the cost of any synthetic-to-real domain shift.

3D VAE and Diffusion Model Background: What the Data Must Support

Section 3 of the paper provides the technical context for why the curated data takes the specific forms it does. Understanding these downstream model requirements is essential because they drive the preprocessing design choices.

3D Variational Autoencoder (VAE). The VAE is the component that learns a compressed latent representation of 3D shapes, analogous to how a 2D VAE compresses images for latent diffusion models.

Input representation. The VAE takes as input a point cloud:

$P \in \mathbb{R}^{N \times (3 + C)}$

where $N$ is the number of points sampled from the mesh surface, $3$ denotes the XYZ spatial coordinates of each point, and $C$ denotes additional feature channels — in this paper, surface normals (the direction perpendicular to the surface at each point, encoded as 3D vectors, so $C = 3$ ).

What this input represents: a sparse, irregular sampling of the continuous 3D surface, where each point carries both where it is in space (position) and what direction the surface faces at that location (normal). The normals are important because they encode local surface orientation — distinguishing a point on the flat seat of a chair from a point on the curved armrest, even if both are at similar spatial positions relative to the object center — which provides the VAE with information about local geometry beyond what position alone conveys.

Encoder and latent representation. The encoder processes the point cloud through point feature extraction and distribution estimation:

$Z = \mathcal{E}(P)$

The encoder $\mathcal{E}$ first extracts per-point features, then produces a latent vector set $Z \in \mathbb{R}^{L \times d}$ , where $L$ is the number of latent tokens and $d$ is the dimensionality of each token — this is the "VecSet" representation introduced by 3DShape2Vecset (Zhang et al., 2023). The set-of-vectors format is specifically designed to interface with transformer-based diffusion models (like DiT), where each token in the set becomes an input token to the transformer.

Why a set of vectors rather than a single vector? A single global latent vector (as in a standard VAE) compresses the entire shape into one fixed-size representation, which loses spatial information and makes it difficult to represent local details. The VecSet representation distributes the shape information across multiple tokens, each of which can specialize in representing different spatial regions — analogous to how a 2D VAE produces a spatial grid of latent features rather than a single global code.

Decoder and reconstruction target. The decoder $\mathcal{D}$ takes the latent vector set and produces a continuous field:

$F_{sdf} = \mathcal{D}(Z)$

where $F_{sdf}$ is the signed distance function (SDF) field — a scalar function defined over continuous 3D space that, for any query point $x \in \mathbb{R}^3$ , returns the signed distance to the nearest surface (positive outside, negative inside, zero on the surface).

What the decoder actually does: given the compressed latent representation of a shape, the decoder defines a mapping from any 3D coordinate to a signed distance value. This is queried on a dense grid of points, and the surface is extracted as the zero-crossing of this field — the set of points where the SDF transitions from positive to negative. This iso-surface extraction (using algorithms like Marching Cubes) produces the final explicit mesh output.

Why SDF as the reconstruction target? SDFs have several properties that make them well-suited for neural reconstruction:

They are continuous and differentiable everywhere (except exactly on the surface), which is friendly for gradient-based optimization.
The zero-level-set extraction is well-studied and numerically stable.
The SDF contains both geometric information (where the surface is, via the zero-crossing) and topological information (which regions are inside vs. outside), enabling the decoder to represent solid objects rather than just surfaces.

Training objective. The VAE is trained with a reconstruction loss that measures how well the decoder's predicted SDF matches the ground-truth SDF computed from the watertight mesh, plus a KL divergence term that regularizes the latent distribution toward a standard Gaussian prior. The exact loss formulation is not provided in the paper, but the standard VAE objective combines:

$\mathcal{L}_{\text{VAE}} = \mathcal{L}_{\text{recon}}(F_{sdf}^{\text{pred}}, F_{sdf}^{\text{gt}}) + \beta \cdot \text{KL}(q(Z|P) \| p(Z))$

where the reconstruction loss is typically L1 or L2 between predicted and ground-truth SDF values at sampled query points, and the KL term prevents the latent space from becoming degenerate.

Why this architecture drives the data preprocessing requirements:

The VAE needs watertight meshes because computing ground-truth SDF values requires unambiguous inside/outside classification. A non-watertight mesh with holes or non-manifold edges does not define a valid solid for which SDF can be computed.
The VAE needs point clouds with surface normals as input, driving the hybrid sampling scheme in the post-processing pipeline.
The VAE needs sufficient geometric detail in training meshes (driving the polygon count threshold in filtering), because the SDF at $512^3$ resolution can capture fine features that low-polygon meshes simply don't possess.

3D Diffusion Model. The diffusion model operates in the latent space produced by the VAE, learning to generate new shape latents conditioned on image embeddings.

Conditioning. An image encoder (the paper mentions DINO-v2 as an example) processes the input image to produce conditioning embeddings:

The model "first leverages an image encoder, such as DINO-v2, to capture image embeddings $c_i$ " (Section 3)

Flow matching objective. The paper's diffusion model uses flow matching rather than standard denoising diffusion. Flow matching (as used in Hunyuan3D-2.1) defines a continuous transformation from a simple base distribution to the data distribution:

$\mathbb{E}_{t, x_0, x_1, c} \| v_\theta(x, t, c) - (x_1 - x_0) \|_2^2$

where $t \in [0, 1]$ is the flow time, $x_0 \sim \mathcal{N}(0, I)$ is a sample from the noise distribution, $x_1 \sim \mathcal{D}$ is a sample from the data distribution (a VAE latent), $c$ is the conditioning information (image embeddings), $v_\theta$ is the learned vector field parameterized by the model, and $(x_1 - x_0)$ is the target velocity — the straight-line direction from noise to data.

What this loss computes: at each training step, a random time $t$ and a random pair of a noise sample $x_0$ and a real data sample $x_1$ are drawn. The current point $x$ is computed by interpolating between them: $x = (1-t)x_0 + t x_1$ (linear interpolation along the straight path). The model $v_\theta$ predicts a velocity vector at this intermediate point, conditioned on the image embeddings $c$ . The target velocity is simply the difference $x_1 - x_0$ — if you follow this direction, you travel from noise to data in a straight line. The loss is the squared L2 distance between predicted and target velocity.

Why flow matching over standard diffusion? Standard diffusion (DDPM) defines a stochastic forward process that gradually adds noise to data, and the model learns to reverse this process — which requires predicting the noise component at each step, a somewhat indirect objective. Flow matching defines a deterministic transformation (a continuous normalizing flow) that directly maps noise to data along straight paths, and the model learns to predict the instantaneous velocity of this transformation — a more direct objective that can enable faster sampling with fewer steps and potentially better sample quality. The straight-path property is particularly appealing because it means the optimal trajectory from noise to data is the shortest possible path in Euclidean space, which empirically leads to more stable training.

Why this drives data requirements:

The diffusion model needs paired image-3D data for conditioning, driving the multi-view rendering requirements — each rendered image serves as a potential conditioning input.
The diffusion model needs high-quality VAE latents, which depend on the VAE being well-trained, which depends on having high-quality watertight meshes — closing the loop on why the full-level processing pipeline is the foundation of the entire ecosystem.

Data Distribution, Splits, and Statistics

Section 4.5 specifies the quantitative characteristics of the released datasets, which are essential for researchers planning to use them.

Full-level data splits:

Training set: 252,000 samples (for model training)
Validation set: 276 samples (for hyperparameter tuning and early stopping)
Test set: 400 samples (for final evaluation and benchmarking)

The test set is notably small relative to the training set (0.16%), consistent with the paper's emphasis on the dataset as a training resource rather than primarily a benchmark. The 400-object test set is described as the foundation for the standardized evaluation framework.

Category taxonomy:

19 top-level categories (e.g., Animal, Weapon, Furniture)
74 mid-level subcategories (e.g., Animal-Virtual/Extinct Animals, Weapon-Firearms)
389 fine-grained classifications (e.g., Animal-Virtual/Extinct Animals-Anthropomorphic Animals, Weapon-Firearms-Guns)

This hierarchical taxonomy is inherited from Objaverse's annotations, not constructed by the authors. Figure 6 shows the top-level category distribution, though the exact per-category counts are in a figure that would need to be read visually.

Part-level data statistics:

Total samples: 240,524
Mean component count: 14.13
Median component count: 11
Component count distribution: 24.63% contain 2–5 components, 24.83% contain 6–10, 27.00% contain 11–20, and the remaining ~23.5% contain 21–50 components.

The paper notes an interesting artifact: "The prominent peaks at 16, 34, and 35 primarily stem from humanoid models that share identical geometric structures but differ in texture" (caption of Figure 8). These are likely rigged character models where the skeleton and mesh topology are standardized but the textures (clothing, skin, accessories) vary. The authors chose to retain these texture variants without deduplication, reasoning that "various research scenarios and application needs may require such texture variant data."

Synthetic data statistics:

Total samples: >125,000
Category coverage: 20 top-level categories, 130 mid-level subcategories, 1,252 fine-grained classifications

The synthetic data's category taxonomy is independent of the full-level data's taxonomy — it derives from the e-commerce product category system rather than from Objaverse's annotations. The 1,252 fine-grained classifications represent a much more detailed breakdown than the 389 classifications in the full-level data, reflecting the pipeline's goal of providing granular coverage of product categories.

Hunyuan3D-2.1-Small: Architecture and Training for Validation

The paper validates the utility of the full-level dataset by training a scaled-down version of Hunyuan3D-2.1 and evaluating its image-to-3D generation performance. This section details the architectural modifications and training strategy.

Model Architecture Modifications. Compared to the full Hunyuan3D-2.1 (1,238M parameters), the Small model incorporates two key changes:

Channel dimension reduction: The base channel dimension is reduced from 2048 to 1536 — a 25% reduction. In transformer-based architectures, the channel dimension determines the width of all linear layers, attention projections, and feed-forward networks, so this reduction significantly decreases parameter count and FLOPs.
Architecture simplification: MoE removal. The Mixture of Experts (MoE) structure is removed, and the model adopts a fully Dense architecture instead. MoE layers replace standard feed-forward networks with multiple "expert" sub-networks, where a learned router selects which expert(s) process each token. While MoE increases model capacity without proportionally increasing compute (since only a subset of experts are active per token), it adds architectural complexity and training instability. Removing MoE simplifies the model and may improve training stability at the cost of reduced capacity, which the higher-quality data is intended to compensate for.

Resulting model size: 832M parameters — approximately 67% of the full model's parameter count.

Progressive Training Strategy. The model is trained with a four-stage curriculum that progressively increases the number of latent tokens, following the strategy used in Hunyuan3D-2.1:

Stage	Tokens	Batch Size	Image Size	Learning Rate	Steps
1	512	512	224	1e-4	800k
2	2048	256	224	5e-5	400k
3	2048	256	518	5e-5	200k
4	4096	128	518	1e-5	400k

Why progressive token resolution? The number of latent tokens ( $L$ in the VecSet representation) controls the representational capacity and granularity of the compressed shape representation. More tokens means the latent space can capture finer geometric details. However, training with many tokens from the start is computationally expensive and can be unstable — the model must simultaneously learn to compress shapes well and to maintain consistency across a large token set. The progressive strategy starts with fewer tokens to establish a coarse but stable shape representation, then gradually increases token count to refine details. The learning rate is also reduced across stages (1e-4 → 5e-5 → 1e-5) to prevent the larger token sets from destabilizing the already-learned coarse representations.

Image size progression. Stage 3 increases the image size from 224 to 518 (matching the 518×518 rendering resolution used in Hunyuan3D-2.1) while keeping the token count at 2048. This lets the model adapt to higher-resolution conditioning images before adding more tokens. Stages 1–2 use smaller images (224) to reduce memory and compute during early training when the model is learning basic shape structure.

Total training compute: 800k + 400k + 200k + 400k = 1.8 million training steps, with batch sizes decreasing as token counts increase (to fit within GPU memory constraints).

Evaluation Metrics. The paper uses two metrics for evaluating image-to-3D consistency:

Uni3D-I (Zhou et al., 2023): Measures the similarity between image embeddings and 3D shape embeddings in a joint embedding space learned by the Uni3D model. Higher values indicate the generated 3D shape is more semantically consistent with the input image. The metric ranges roughly from 0.3 to 0.37 based on Table 2 values.
ULIP-I (Xue et al., 2023a): Similarly measures image-3D consistency but uses the ULIP embedding space trained with contrastive learning. Values range roughly from 0.21 to 0.25 in Table 2.

Both metrics are reference-free — they don't require ground-truth 3D models for the test images, which makes them suitable for evaluating generation quality on in-the-wild images where no corresponding 3D model exists. This is important because the test set consists of images from the curated data, not a separate benchmark with paired ground truth.

Results interpretation (Table 2). The Hunyuan3D-2.1-Small model achieves Uni3D-I = 0.3606 and ULIP-I = 0.2424, compared to the full Hunyuan3D-2.1 at 0.3636 and 0.2446 respectively. The gap is remarkably small: 0.0030 on Uni3D-I and 0.0022 on ULIP-I, despite using 33% fewer parameters. The paper frames this as evidence that data quality drives performance — the scaled-down model, when trained on the same high-quality curated data, nearly matches the larger model. The comparison also shows that the 832M-parameter Small model outperforms the similarly-sized 852M-parameter CraftsMan (Uni3D-I 0.3351), further supporting the claim that data quality, not model architecture or scale, is the differentiating factor.

4. Key Insights and Innovations

Innovation 1: Reframing the 3D Generation Bottleneck from Data Scarcity to Data Processing

The paper's most fundamental intellectual move is not the construction of any single pipeline or dataset, but rather the diagnostic reframing of what problem the 3D generation field actually has. Prior to this work, the dominant narrative in 3D generative modeling—particularly for the native generation paradigm that trains directly on 3D representations—was that the field suffered from data scarcity. ShapeNet (Chang et al., 2015) provided only ~50k models across 55 categories; PartNet (Mo et al., 2019) offered fine-grained part annotations but at even smaller scale. The release of Objaverse (Deitke et al., 2022) and Objaverse-XL (Deitke et al., 2023) was celebrated as solving this scarcity problem, providing millions of 3D assets spanning diverse categories.

HY3D-Bench argues that this narrative is wrong—or at least incomplete—in a precise way: the data exists, but it exists in a form that is so raw, heterogeneous, and low-quality that it is effectively inaccessible to most researchers. The paper's diagnosis is that the real bottleneck is not the volume of 3D models available, but the preprocessing gap between "a 3D model exists on the internet" and "a 3D model can be loaded into a training loop." This is a conceptual reframing that shifts the community's attention from collecting more data to making existing data usable.

What makes this reframing distinctive rather than obvious is its specificity about why preprocessing is the bottleneck, not just an inconvenience. The paper catalogs the failure modes of raw 3D assets (Section 4) with a level of detail that reveals how each category of defect maps to a specific training pathology: non-manifold geometry breaks SDF computation (because inside/outside is undefined), inconsistent coordinate systems force the VAE latent space to waste capacity on arbitrary conventions rather than meaningful shape variation, missing or corrupted textures degrade image-conditioning signals, and thin structures create high-frequency SDF discontinuities that neural networks struggle to fit. This is not a generic complaint about "messy data"—it is a precise engineering analysis of how specific geometric defects cause specific machine learning failures.

The contrast with prior dataset enhancement efforts sharpens this contribution. Objaverse++ (Lin et al., 2025a) recognized that quality filtering was needed and annotated 10,000 samples to train a quality classifier—but it only identified good assets without making them training-ready. Objaverse-OA (Lu et al., 2025) recognized that orientation inconsistency was a problem and annotated 14,000 orientation-aligned samples—but it only fixed one of many preprocessing dimensions. Objaverse-MIX (Qian et al., 2024) came closest by providing 900,000 samples with multiple representations, but the paper argues its fixed rendering viewpoints and single point cloud sampling strategy still fell short of what modern 3D VAEs and diffusion models need. Each prior work addressed one dimension of the preprocessing problem while leaving the others unsolved; HY3D-Bench's innovation is the recognition that these dimensions must be solved simultaneously and end-to-end because the downstream models depend on all of them being correct at once—a watertight mesh with poor orientation is still unusable, as is a well-oriented mesh that isn't watertight.

This reframing matters beyond academic taxonomy because it changes what researchers should invest in. If data scarcity were the bottleneck, the solution would be more data collection (bigger scrapes, more sources). If preprocessing is the bottleneck, the solution is better tools, shared infrastructure, and community standards—which is exactly what HY3D-Bench provides. The paper's validation strategy reinforces this reframing: by showing that a 832M-parameter model trained on well-processed data achieves a Uni3D-I score of 0.3606, competitive with the 1,238M-parameter Hunyuan3D-2.1 at 0.3636 (Table 2), the paper demonstrates that data quality improvements can substitute for model scale—implying that the community has been over-investing in scaling model size while under-investing in data quality, because the data quality variable was never controlled.

Innovation 2: The "Infrastructure-as-Contribution" Model for 3D Research

The paper's second distinctive contribution is methodological rather than technical: it establishes a template for how to contribute to the 3D generation field through infrastructure rather than algorithms. This is not a trivial packaging choice—it represents a different theory of what moves a field forward and what kinds of contributions deserve recognition.

The dominant contribution model in 3D generation research has been algorithmic: propose a new architecture (GAN-based, SDS-based, feedforward, native generation), demonstrate improved performance on standard benchmarks, and release code. HY3D-Bench inverts this: the primary contribution is the data and processing pipeline, and the algorithmic component (Hunyuan3D-2.1-Small) is positioned as validation of the data's quality rather than as a novel method in its own right. The paper's structure reflects this inversion—the algorithmic description in Section 3 is brief and references prior work for details, while the data processing pipeline in Section 4 receives exhaustive treatment with algorithmic detail, filtering criteria, and distribution statistics.

What makes this model distinctive is its theory of leverage. An algorithmic contribution benefits researchers who build directly on that algorithm; an infrastructure contribution benefits everyone who uses that infrastructure, regardless of their algorithmic approach. The paper makes this argument explicitly: "by offering this preprocessed, high-resolution 3D dataset, we aim to reduce the computational and technical burdens on researchers, lower the entry barrier for 3D generation research, and further facilitate the advancement of the field" (Section 2.2). The claim is that the marginal benefit of one more algorithmic improvement is smaller than the marginal benefit of making existing algorithms accessible to more researchers—and that the community has historically undervalued infrastructure contributions relative to algorithmic ones.

This contribution model also addresses the reproducibility crisis in 3D generation research, though the paper doesn't use that term. When every research group independently processes raw Objaverse data using their own filtering criteria, rendering configurations, and watertightening algorithms, it becomes impossible to determine whether performance differences between methods are due to algorithmic superiority or data processing differences. By providing a fixed, standardized dataset with released training configurations and pre-trained model checkpoints (Section 5.1), HY3D-Bench creates the conditions for fair comparison that algorithmic papers cannot individually create because they don't control what other groups do with data preprocessing.

The paper's specific design choices reinforce this infrastructure model: the 400-object test set with fixed evaluation protocols (ULIP and Uni3D) creates a shared benchmark; the release of training configurations and model checkpoints enables exact reproduction; the three-pillar structure (full-level, part-level, synthetic) provides resources for multiple research directions rather than optimizing for a single task. These are the choices of a platform builder, not an algorithm developer—they prioritize generality and reusability over task-specific optimization.

Innovation 3: Geometric Hardness as an Explicit Filtering Criterion for Training Data

The paper introduces a specific and non-obvious technical innovation in its quality filtering pipeline: the explicit exclusion of assets containing large areas of thin structures, justified through a concrete analysis of how thin geometry causes specific optimization pathologies in implicit neural representations. This is not a generic "remove bad data" heuristic—it is a theoretically motivated filtering criterion derived from understanding how the downstream model's loss landscape interacts with geometric properties of the training data.

Prior dataset curation efforts applied quality criteria based on human aesthetic judgment (Objaverse++'s manual annotation of quality dimensions like "transparency" and "single-object completeness") or generic geometric properties (polygon count thresholds, which the paper also uses). HY3D-Bench's thin-structure exclusion is different because it is motivated by the interaction between a specific geometric property and a specific model architecture. The paper provides a two-part justification (Section 4.2):

First, for implicit representations that learn signed distance functions: thin structures cause the SDF to undergo "abrupt jumps, transitioning from positive to negative values within an extremely small spatial range" (Section 4.2). This is a precise description of why thin geometry is hard for neural networks: a thin sheet of thickness d creates an SDF that changes from +d/2 to -d/2 over a spatial distance of d, producing a gradient of approximately 1.0 regardless of d. As d → 0, the SDF approaches a step function—infinitely sharp, with infinite frequency content. Neural networks, which are inherently smooth function approximators with a finite spectral bias (they learn low-frequency functions first, per the well-known spectral bias phenomenon), struggle to represent such discontinuities. Training on many thin-structure examples would force the model to expend capacity learning to approximate step functions rather than learning meaningful shape variation.

Second, for multi-view consistency: thin structures "under certain viewpoints are difficult to observe or even completely invisible in 2D images (such as when viewing along the thin sheet direction)" (Section 4.2). This creates an asymmetric training signal: the image encoder sees the thin structure in some views but not others, meaning the conditioning signal is intermittent for that geometric feature. The diffusion model, which learns to map from image embeddings to shape latents, receives inconsistent evidence about whether the thin structure should exist, potentially leading to unstable training or models that ignore thin features entirely.

What makes this an innovation rather than an obvious heuristic is the specificity of the diagnosis and the tradeoff it implies. Excluding thin structures improves training stability and convergence speed, but at the cost of removing valid geometric variation from the training distribution—models trained on this data may struggle to generate objects with thin features (blades, wings, fins, sheets). The paper implicitly accepts this tradeoff, prioritizing training quality over distribution completeness for this geometric class. The choice reflects a deeper principle: not all geometric diversity is equally valuable for model training, and some geometric properties are actively harmful because they create optimization landscapes that gradient-based learning cannot efficiently navigate. This principle generalizes beyond thin structures—it suggests that data curation for 3D generation should be informed by an understanding of which geometric properties cause training pathologies, not just which properties are "realistic" or "diverse."

The validation results in Table 2 provide indirect evidence for this choice: the 832M-parameter Small model achieves near-parity with the 1,238M-parameter full model, and the paper attributes this partly to data quality. While the thin-structure exclusion cannot be isolated as causal (the filtering pipeline applies multiple criteria simultaneously), the overall performance of models trained on this curated data supports the claim that aggressive, theoretically-motivated filtering improves training outcomes.

Innovation 4: AIGC-Driven Long-Tail Augmentation as a Complement to Data Curation

The paper's fourth distinctive contribution is the introduction of a synthetic data generation pipeline specifically designed to address the long-tail distribution problem in 3D datasets—a problem that data curation alone cannot solve because the missing categories simply don't exist in the source repositories in sufficient quantity. This is significant because it represents a conceptual shift from "curate what exists" to "generate what should exist," and it establishes a template for how foundation models (LLMs, image diffusion models) can be composed to bootstrap data for domains where data is genuinely scarce.

The long-tail problem in 3D data is structurally different from the quality problem. The quality problem (non-manifold geometry, poor textures, thin structures) can be solved by filtering and repairing existing assets—the assets exist, they're just in bad condition. The long-tail problem is that for many real-world product categories (the paper identifies 1,252 fine-grained e-commerce categories), there simply aren't enough 3D models in any repository, high-quality or not. No amount of cleaning can fix an absence. Prior datasets recognized this implicitly—ShapeNet's 55 categories and PartNet's 24 categories were an admission that only common object categories had enough data—but treated it as an unavoidable limitation. HY3D-Bench treats it as a solvable problem through generative synthesis.

What makes this pipeline intellectually distinctive is its compositional architecture: rather than training a single text-to-3D model (which would require paired text-3D data that doesn't exist for long-tail categories), the pipeline composes three separately-trained models—an LLM, a text-to-image diffusion model, and an image-to-3D model—each of which was trained on abundant data in its respective domain. The LLM was trained on internet-scale text and can generate diverse product descriptions for any category; the image diffusion model was trained on billions of image-text pairs and can render those descriptions; the image-to-3D model was trained on millions of 3D models with renderings and can reconstruct from single images. The compositionality is the key insight: by decomposing the hard problem (generate 3D models for arbitrary categories) into sub-problems where foundation models already exist, the pipeline sidesteps the need for paired text-3D data.

The LoRA fine-tuning of the image generation stage (Section 4.4) represents a second-order insight: even strong foundation models need task-specific adaptation to produce outputs suitable for downstream consumption. The paper's five quality objectives for LoRA training—clean background, complete object, appropriate position, reasonable viewpoint, information-rich—are not generic image quality criteria; they are specifically designed to make the generated images maximally useful for the subsequent image-to-3D stage. A clean background simplifies foreground extraction; a three-quarter viewpoint maximizes visible geometric information for reconstruction; centering ensures the object isn't cropped. This is a form of interface design between models: the image generation output is optimized not for human viewing but as input to another model, and the optimization criteria are derived from understanding that downstream model's requirements.

The 125k synthetic assets spanning 1,252 fine-grained categories (Figure 10) represent a scale of long-tail coverage that no manually-curated dataset has achieved. The paper notes that this category system "far exceeds existing real datasets, with coverage ranging from daily necessities and consumer electronics to professional industrial products" (Section 4.5). This breadth matters for applications like robotics simulation and e-commerce visualization, where the model must handle any object a user might encounter, not just the 55 categories ShapeNet provided.

However, this innovation comes with a significant and underexplored limitation: the synthetic data inherits biases from all three foundation models in the pipeline. The LLM's descriptions reflect the biases of its training data about what products look like; Qwen-Image reflects biases in image generation (potentially producing stereotypical or culturally-specific product appearances); and HY3D-3.0 reflects the biases of the 3D data it was trained on (predominantly Objaverse, which skews toward certain object types and styles). The paper does not analyze these compounding biases—a notable gap, since synthetic data used to train downstream models can amplify rather than reduce distributional skew. The synthetic pipeline is best understood as a supplement to real data, not a replacement, and its value is highest precisely where real data is absent—but in those absent categories, there is no ground-truth distribution to compare against, making bias impossible to measure.

5. Experimental Analysis

Evaluation Methodology

Dataset. All experiments use the full-level curated dataset described in Section 4.5: 252,000 training samples, 276 validation samples, and 400 test samples, sourced from Objaverse and Objaverse-XL and processed through the full-level pipeline (watertight meshes, multi-view renderings, hybrid point clouds). The test set of 400 objects serves as the fixed benchmark for comparing all methods.
Base model(s). The validation experiments train Hunyuan3D-2.1-Small, a scaled-down variant of Hunyuan3D-2.1 with 832M parameters — approximately 67% of the full model's 1,238M. The paper also compares against four open-source baselines: Michelangelo (Zhao et al., 2024; 105M parameters), CraftsMan (Li et al., 2024c; 852M parameters), Trellis (Xiang et al., 2024; 1,156M parameters), and the full Hunyuan3D-2.1 (Hunyuan3D et al., 2025a; 1,238M parameters). The Small model is chosen to demonstrate that data quality enables competitive performance at reduced scale — the core empirical claim of the paper.
Metrics. The paper evaluates image-to-3D generation quality using two reference-free embedding-consistency metrics:
- Uni3D-I (Zhou et al., 2023): Measures cosine similarity between image embeddings and rendered 3D shape embeddings in the Uni3D joint embedding space. Higher values (reported as decimal scores, ~0.30–0.37 in Table 2) indicate better semantic alignment between the conditioning image and the generated 3D shape.
- ULIP-I (Xue et al., 2023a): Similarly measures image-to-shape consistency in the ULIP embedding space trained with contrastive learning. Values range ~0.21–0.25 in Table 2.
Both metrics are computed on the 400-object test set. They are reference-free because they compare the generated 3D shape to the input conditioning image, not to a ground-truth 3D model — this makes them applicable to in-the-wild evaluation where paired image-3D ground truth is unavailable.
Baselines. The paper compares against four prior methods, all evaluated on the same 400-object test set with the same metrics:
- Michelangelo (Zhao et al., 2024): 105M parameters, 257 token VecSet length, representing an earlier generation of native 3D diffusion models.
- CraftsMan (Li et al., 2024c): 852M parameters, 2048 token length — the closest baseline in model scale to Hunyuan3D-2.1-Small (832M vs. 852M).
- Trellis (Xiang et al., 2024): 1,156M parameters, active voxel-based representation with average token length of ~10,000 — representing a different latent representation paradigm.
- Hunyuan3D-2.1 (Hunyuan3D et al., 2025a): 1,238M parameters, 4096 token length — the full-scale model from the same family, serving as the upper-bound reference.
All baseline results in Table 2 are presumably obtained by running each model's released checkpoint on the same test set, though the paper does not explicitly describe the evaluation procedure (e.g., whether models were retrained on HY3D-Bench data or evaluated using their original trained weights). The Michelangelo and CraftsMan results likely reflect their original training data (which may differ from HY3D-Bench's curated data), while Trellis and Hunyuan3D-2.1 results may reflect training on different subsets of Objaverse with different preprocessing — making direct comparison partially confounded by training data differences as well as architectural differences.
Generation budget / compute accounting. For the validation experiment, compute is measured in training steps: the Hunyuan3D-2.1-Small model is trained for a total of 1.8M steps across four progressive stages (Table 1), with batch sizes ranging from 512 (Stage 1) to 128 (Stage 4) and token counts increasing from 512 to 4096. The paper does not provide inference-time compute metrics (FLOPs per generation, generation time) — the evaluation is purely quality-focused. For comparing methods, the primary resource axis is model parameter count, with the key comparison being 832M (Small) vs. 1,238M (full Hunyuan3D-2.1) at comparable quality, and vs. 852M (CraftsMan) at comparable scale but different data.
Cross-validation / statistical protocol. The paper does not report any cross-validation, statistical significance testing, or confidence intervals. The 400-object test set provides a single accuracy number per metric per method. Given the test set size, differences of ~0.002–0.003 in Uni3D-I (the gap between Hunyuan3D-2.1-Small at 0.3606 and the full model at 0.3636, or between Small and Trellis at 0.3641) cannot be assessed for statistical reliability without variance estimates, which are not provided. This is a notable methodological limitation for interpreting the closeness of the results.

Main Quantitative Results

Image-to-3D Generation Quality: Full-Level Data Validation

The paper's central quantitative claim is that Hunyuan3D-2.1-Small, trained on HY3D-Bench's curated full-level data, achieves image-to-3D generation quality competitive with substantially larger models and substantially better than similarly-sized models trained on less carefully processed data. Table 2 reports the following results on the 400-object test set:

Method	Token Length	Model Size (M)	Uni3D-I ↑	ULIP-I ↑
Michelangelo	257	105	0.3169	0.2186
CraftsMan	2048	852	0.3351	0.2264
Trellis	~10000*	1,156	0.3641	0.2454
Hunyuan3D-2.1	4096	1,238	0.3636	0.2446
Ours (Hunyuan3D-2.1-Small)	4096	832	0.3606	0.2424

Headline comparison against the full Hunyuan3D-2.1. The Small model achieves Uni3D-I = 0.3606, within 0.0030 of the full model's 0.3636 — a gap of less than 1% — despite using 33% fewer parameters (832M vs. 1,238M). On ULIP-I, the gap is 0.0022 (0.2424 vs. 0.2446). This is the paper's primary empirical evidence that data quality can substitute for model scale: the curated HY3D-Bench data enables a substantially smaller model to approach the performance of the full-scale model trained by the original Hunyuan3D-2.1 team.

Comparison against Trellis. Trellis achieves the highest Uni3D-I at 0.3641, slightly exceeding both Hunyuan3D-2.1 variants. Trellis uses a different latent representation (sparse voxel hierarchies with ~10,000 active tokens on average, versus the 4,096 VecSet tokens used by Hunyuan3D) and has 1,156M parameters — 39% more than the Small model. The 0.0035 gap between Trellis (0.3641) and Hunyuan3D-2.1-Small (0.3606) is small in absolute terms, and the paper does not analyze whether this difference is statistically significant or attributable to architectural choices versus data differences.

Comparison against CraftsMan (the most directly comparable baseline). CraftsMan has 852M parameters — nearly identical to the Small model's 832M — but achieves a substantially lower Uni3D-I of 0.3351 (a gap of 0.0255, or ~7.6% relative improvement for HY3D-Bench-trained Small). This is the paper's strongest comparative evidence for data quality effects, because model scale is controlled: both models have ~850M parameters, and the primary difference is training data quality and model architecture. On ULIP-I, the gap is 0.0160 (0.2424 vs. 0.2264). The paper interprets this as demonstrating that "data quality plays a crucial role in 3D generation tasks" and that the curated dataset enables researchers to "focus more on algorithm innovation and model optimization rather than tedious data processing and preparation work" (Section 5.2).

Comparison against Michelangelo. Michelangelo's 0.3169 Uni3D-I and 0.2186 ULIP-I represent substantially lower performance, but this is expected given its much smaller model size (105M parameters) and earlier generation architecture. The comparison primarily establishes the performance range on this benchmark rather than serving as a competitive baseline.

Qualitative results (Figure 12). The paper provides visual comparisons of generated meshes across all five methods. The figure shows image-to-3D generations for several example objects, but the paper does not provide quantitative human evaluation or user study results — the visual comparison is purely illustrative and subject to selection bias (the examples shown are presumably chosen by the authors).

What these results do and do not demonstrate. The results in Table 2 demonstrate that Hunyuan3D-2.1-Small, trained on HY3D-Bench's full-level data, achieves Uni3D-I scores competitive with models having 39–49% more parameters (Trellis, Hunyuan3D-2.1) and substantially better than a model of similar scale (CraftsMan). However, several important caveats apply:

Training data is not isolated as the causal variable. The comparison between Hunyuan3D-2.1-Small and CraftsMan controls for model scale but not for architecture — Hunyuan3D-2.1 and CraftsMan use different VAE architectures, different diffusion backbones, and potentially different training recipes. The performance gap could arise from architectural superiority rather than data quality. An ideal ablation would train CraftsMan on HY3D-Bench data or train Hunyuan3D-2.1-Small on CraftsMan's data, but neither experiment is reported.
The comparison against Hunyuan3D-2.1 is not a clean data ablation either. The paper states that Hunyuan3D-2.1-Small is "trained on our open-sourced dataset" (Section 5.2), while the full Hunyuan3D-2.1 was trained on the original Hunyuan3D team's data. However, the original Hunyuan3D-2.1 was also trained on a curated subset of Objaverse with its own preprocessing pipeline — it's not trained on raw, unfiltered data. The paper does not characterize how the Hunyuan3D-2.1 training data pipeline differs from HY3D-Bench, making the comparison partially confounded: the Small model benefits from both a different training data pipeline and a smaller model size, and the relative contribution of each is unknown.
The metrics are reference-free embedding similarities. Uni3D-I and ULIP-I measure semantic consistency between images and rendered 3D shapes in learned embedding spaces. While useful for ranking methods, they do not directly measure geometric accuracy (e.g., Chamfer distance to ground truth), topological correctness (e.g., watertightness of generated meshes), or visual fidelity as perceived by humans. A model achieving high Uni3D-I could still produce meshes with geometric defects that a human evaluator would notice but the embedding space does not penalize. The paper does not report any geometry-level metrics like Chamfer distance, F-score, or normal consistency, which would provide complementary evidence about reconstruction quality.
The test set is 400 objects drawn from the same distribution as training. This is appropriate for evaluating generation quality on in-distribution objects, but it does not test generalization to out-of-distribution categories, real-world photographs, or substantially different object styles. The synthetic data pipeline (Section 4.4) is intended to address long-tail categories, but these are not evaluated in the experimental section — the synthetic data's impact on model performance is unmeasured.
No per-category breakdown is provided. The paper reports aggregate metrics across the entire 400-object test set but does not show performance by category. This matters because the full-level dataset has a known long-tail distribution (Figure 6), and aggregate metrics may be dominated by common categories, hiding poor performance on rare ones.

Ablation Studies and Robustness Checks

Progressive token resolution training strategy (Table 1): The paper reports the training curriculum but does not provide an ablation comparing progressive vs. fixed-resolution training. The four-stage progression (512 → 2048 → 2048(at higher image resolution) → 4096 tokens) is adopted from Hunyuan3D-2.1's training recipe, but the paper does not demonstrate that this strategy is necessary for the Small model or that alternative curricula would produce different results. This is a significant missing ablation because progressive training increases engineering complexity substantially; if similar performance could be achieved with fixed-resolution training at the final token count, the training recipe would be simpler.

Channel dimension reduction (2048 → 1536) and MoE removal: These are the two architectural modifications that distinguish Hunyuan3D-2.1-Small from the full model. The paper reports only the final model's performance, with no ablation isolating the individual contribution of each modification. It is unknown whether the performance is primarily limited by the channel reduction, the MoE removal, or the interaction between them. This matters for practitioners deciding how to scale down their own models — knowing whether MoE provides substantial benefit at this scale, or whether width reduction causes a sharper performance drop than expected, would inform architectural decisions.

Comparison across token lengths (Table 2): The paper reports token lengths for each method but does not control for this variable in comparisons. Michelangelo uses 257 tokens, CraftsMan uses 2,048, Hunyuan3D-2.1-Small uses 4,096, and Trellis uses ~10,000 active voxels. Token length is a direct determinant of representational capacity — more tokens means the latent space can encode finer geometric details. The paper's Small model benefits from having twice the token length of CraftsMan (4,096 vs. 2,048), making it impossible to attribute performance differences solely to data quality. A proper data quality ablation would control for or report performance at matched token lengths.

Data preprocessing pipeline quality — no baseline against raw or minimally-processed data: The paper's core claim is that the rigorous preprocessing pipeline improves training outcomes, but the only empirical evidence is the comparison against other models trained on their own data pipelines (CraftsMan, Michelangelo) or on the original Hunyuan3D team's data (Hunyuan3D-2.1). There is no experiment training Hunyuan3D-2.1-Small on raw Objaverse, on minimally-processed Objaverse (e.g., only format conversion without watertightening or quality filtering), or on each prior dataset enhancement pipeline's output (Objaverse++, Objaverse-OA, Objaverse-MIX). Such experiments would directly measure the marginal benefit of each preprocessing step and establish the value of the full HY3D-Bench pipeline over simpler alternatives. Their absence means the paper's effectiveness claims rest on cross-model comparisons that confound data, architecture, and training recipe differences.

Part-level and synthetic data — no generation experiments: The paper describes extensive part-level processing (240k assets) and AIGC synthesis (125k assets) but evaluates only the full-level data by training Hunyuan3D-2.1-Small. There are no experiments training part-aware generation models on the part-level data, no experiments evaluating whether the part masks and per-part watertight meshes improve fine-grained generation or editing, and no experiments training models on the synthetic data (alone or in combination with real data) to measure its impact on long-tail category performance. The paper states that the part-level data "lays a solid foundation for training powerful part generation models, fine-grained 3D understanding or editing models, and simulation environments supporting complex robotic manipulation" (Section 4.3), and that the synthetic data "provides a critical supplement for training models that can generalize to rare but crucial object categories" (Section 1) — but neither claim is empirically validated. The experimental validation is thus limited to only one of the paper's three stated data contributions.

Metric choice — no geometric fidelity metrics: The evaluation uses only embedding-space consistency metrics (Uni3D-I, ULIP-I). The paper does not report any metric that directly measures geometric quality of generated meshes: Chamfer distance (average nearest-neighbor distance between generated and ground-truth point clouds), Hausdorff distance (worst-case geometric deviation), normal consistency (accuracy of surface orientation), or watertightness rate (whether generated meshes are closed and manifold). The full-level pipeline specifically produces watertight meshes and optimizes for geometric quality, so it would be natural to evaluate whether models trained on this data actually produce more geometrically correct outputs. The omission of geometric metrics is particularly notable because the paper's filtering criteria (polygon count, thin-structure exclusion, watertightness) are explicitly motivated by geometric quality concerns.

Qualitative results — no diversity or failure case analysis: Figure 12 provides visual examples but does not systematically characterize failure modes, diversity of generation, or per-category variation. The paper does not show examples where the Small model fails, examples of mode collapse, or comparisons of geometric fidelity beyond rendered appearance. For a paper whose contribution is data quality, the absence of systematic analysis of how data quality improvements manifest in generation quality — and where they do not — is a significant gap. Do models trained on HY3D-Bench data produce fewer non-manifold outputs? Do they handle thin structures better or worse (given their exclusion from training)? Do they show better texture consistency? These questions are not addressed.

Critical Assessment

Does the full-level data enable competitive generation at reduced model scale? (Claim from executive summary: "Uni3D-I score of 0.3606—competitive with the full Hunyuan3D-2.1 model (0.3636) despite having ~33% fewer parameters")

The experiment in Table 2 supports a narrower claim than the paper makes. Hunyuan3D-2.1-Small does achieve a Uni3D-I score very close to the full Hunyuan3D-2.1 (gap of 0.0030), but this result cannot be cleanly attributed to data quality because the comparison is between models that differ in three ways simultaneously: (1) the Small model uses HY3D-Bench data while the full model used the original Hunyuan3D team's data pipeline; (2) the Small model has reduced channel dimensions and no MoE; (3) the models may have different training recipes, hyperparameters, and convergence criteria. The paper does not train the full-scale model on HY3D-Bench data (which would show whether HY3D-Bench data improves upon the original Hunyuan3D data pipeline at matched scale) or train the Small model on the original Hunyuan3D data (which would show how much performance degrades when data quality is reduced at fixed model scale). Without these experiments, the observed result is consistent with multiple explanations: data quality matters, but so might architectural choices (maybe MoE doesn't help much at this scale), hyperparameter tuning, or the interaction between model scale and data quality in ways the experiment doesn't disentangle.

The comparison against CraftsMan provides stronger evidence for data quality effects because model scale is approximately matched (832M vs. 852M) and the performance gap is substantial (0.3606 vs. 0.3351). However, architecture and training recipe still confound this comparison — the gap could reflect Hunyuan3D-2.1's architectural advantages over CraftsMan rather than HY3D-Bench's data advantages over CraftsMan's training data. The paper would be strengthened by training the same architecture on different data pipelines at matched scale, but this experiment is absent.

The claimed "~33% fewer parameters" is accurate (832M vs. 1,238M), but parameter count alone doesn't capture model capacity differences. The full model's Mixture of Experts architecture means its effective capacity per token may be different from parameter count alone, and the Small model uses 4,096 tokens (same as full model) rather than proportionally reduced tokens, meaning it may compensate for reduced per-token capacity with the same number of latent tokens. These nuances are not discussed.

The result is most accurately stated as: a scaled-down Hunyuan3D-2.1 variant trained on HY3D-Bench's curated data achieves near-parity with the full Hunyuan3D-2.1 and substantially outperforms a similarly-sized contemporary model (CraftsMan), but the experiment does not isolate the effect of data quality from architecture, training recipe, and other confounds.

Does the paper democratize access to 3D data resources? (Claim from executive summary: "democratizes access to robust data resources, aiming to catalyze innovation across 3D perception, robotics, and digital content creation")

This claim is partially supported by the data release itself — releasing 252k full-level assets, 240k part-level assets, and 125k synthetic assets as training-ready packages does lower the preprocessing barrier for researchers. However, the paper's experimental validation only demonstrates utility for one narrow slice of the claimed scope: full-level data for image-to-3D generation using a Hunyuan3D-family model. There is no experimental evidence that:

The part-level data improves part-aware generation or fine-grained perception (stated applications in Section 1).
The synthetic data improves long-tail category generalization (stated application in Section 1).
The data benefits 3D perception pre-training (stated in the contributions list).
The data benefits robotics simulation (stated in the contributions list).

These claims may be plausible given the data's characteristics, but they are untested in this paper. The "catalyze innovation" claim is a forward-looking statement about community impact that cannot be validated within the paper's scope — it requires evidence of downstream adoption and research enabled by the dataset, which will only emerge over time.

The release itself does democratize access in the sense that researchers no longer need to run the preprocessing pipeline themselves. However, the paper does not report data download size, storage requirements, or bandwidth considerations — practical barriers that affect whether resource-constrained researchers can actually use the data. If the full dataset requires terabytes of storage and high-bandwidth connections, the "democratization" may be limited to well-resourced labs, which would partially undercut the claim.

Does the standardized evaluation framework enable fair comparison? (Claim from abstract: "providing a unified platform for testing 3D generation algorithms")

The paper establishes a 400-object test set with fixed evaluation metrics (Uni3D-I, ULIP-I) and releases pre-trained model checkpoints. This does enable fairer comparison than the previous state, where different groups used different test sets, different preprocessing, and different metrics. However, the evaluation framework has several significant limitations as a "unified platform":

Single metric type. Uni3D-I and ULIP-I are both reference-free embedding consistency metrics. The platform does not include geometric accuracy metrics (Chamfer distance, normal consistency), human evaluation protocols, or diversity metrics. A method that optimizes for embedding consistency at the expense of geometric accuracy could achieve high scores on this benchmark while producing poor 3D meshes — an undesirable incentive.
No standardized evaluation protocol for baselines. The paper evaluates prior methods on its test set but does not specify whether those methods were retrained, whether their original checkpoints were used directly, or how the evaluation was conducted (e.g., rendering settings for the generated meshes). The comparison is thus not strictly standardized — a researcher trying to reproduce the baseline numbers might get different results depending on evaluation details.
No established baseline performance range. With only 4 baselines evaluated, there is no sense of what constitutes a "good" Uni3D-I score, what score represents random chance, or how the metric correlates with downstream task performance. The platform would be strengthened by including simple baselines (e.g., nearest-neighbor retrieval from the training set) and establishing performance bounds.
The 400-object test set is small. Statistical reliability for comparing methods with closely-spaced scores (~0.002–0.003 differences) requires either a larger test set or variance estimates, neither of which is provided. The paper cannot distinguish whether the 0.0035 gap between Trellis (0.3641) and Hunyuan3D-2.1-Small (0.3606) is meaningful or noise.
Domain-limited evaluation. The test set is drawn from the same Objaverse-derived distribution as the training data. The framework does not evaluate generalization to real photographs, sketches, or out-of-distribution categories — all of which matter for practical deployment.

What experiments would have strengthened the paper?

Several experiments are conspicuously absent and would substantially strengthen the paper's claims:

Training Hunyuan3D-2.1-Small on alternative data pipelines. Training the same model on raw Objaverse, on Objaverse++ filtered data, on Objaverse-OA oriented data, and on Objaverse-MIX data would directly measure the marginal value of each preprocessing dimension. This is the most important missing experiment for the paper's central claim about data quality.
Training the full Hunyuan3D-2.1 on HY3D-Bench data. If the full model trained on HY3D-Bench data significantly outperforms the original Hunyuan3D-2.1 reported in the paper, that would demonstrate that data quality improvements benefit larger models too (not just compensate for reduced scale). If there is no improvement, it would suggest the original Hunyuan3D-2.1 training data was already of comparable quality.
Geometric quality evaluation of generated meshes. Reporting Chamfer distance, normal consistency, watertightness rate, and mesh quality metrics for generated outputs would test whether training on HY3D-Bench's watertight, geometrically-clean data produces meshes with better geometric properties — a direct test of the data pipeline's design rationale.
Part-aware generation or editing experiments using the part-level data. A simple experiment training a model that conditions on part masks or generates part-segmented outputs would validate the part-level pipeline's utility and justify the effort spent constructing it.
Long-tail category evaluation with and without synthetic data. Training a model on real data only vs. real + synthetic data and evaluating on held-out long-tail categories would measure the synthetic data's contribution to generalization — a direct test of the AIGC pipeline's stated purpose.
Human evaluation. Given the limitations of embedding-space metrics, a user study comparing generated meshes (from the Small model vs. baselines) on visual quality, geometric accuracy, and texture fidelity would provide complementary evidence that the quantitative metrics capture meaningful quality differences.
Scaling analysis. Training the Small model on subsets of the data (10%, 25%, 50%, 100%) would reveal whether the dataset's size is a binding constraint or whether quality improvements plateau before the full 252k samples are used. Similarly, varying model scale at fixed data would reveal whether data quality improvements shift the compute-optimal model size toward smaller architectures — a direct policy implication of the paper's thesis.

The absence of these experiments does not invalidate the paper's contributions (a data release with one validation experiment is a legitimate contribution model), but it does mean the paper's empirical claims are narrower than its rhetorical claims. The paper establishes that HY3D-Bench data is sufficient to train a competitive model; it does not establish that the specific preprocessing choices cause the performance, that the data is necessary (vs. simpler preprocessing), or that the two-thirds of the data release not experimentally validated (part-level and synthetic) provide any benefit.

6. Limitations and Trade-offs

The Experimental Validation Covers Only One-Third of the Data Contribution

The assumption or constraint. The paper releases three data products — 252k full-level assets, 240k part-level assets, and 125k synthetic assets — but empirically validates only the full-level data through the Hunyuan3D-2.1-Small training experiment (Section 5). The part-level and synthetic data, which together represent ~60% of the released assets by count, are not tested in any downstream task. The paper acknowledges this indirectly in Section 6 by positioning these as resources for "future efforts," but the claims made about their utility are forward-looking rather than demonstrated:

The part-level data "lays a solid foundation for training powerful part generation models, fine-grained 3D understanding or editing models, and simulation environments supporting complex robotic manipulation" (Section 4.3).

The synthetic data "provides a critical supplement for training models that can generalize to rare but crucial object categories, which is particularly vital for the robustness of generation and the diversity of robotics simulation environments" (Section 1).

The consequence. A practitioner evaluating whether to invest in building on HY3D-Bench has no empirical evidence that the part-level decompositions meaningfully improve part-aware generation or editing, that the part ID masks are accurate enough to supervise segmentation models, that the per-part watertightening (which must cap open boundaries at connection points) produces parts that are individually plausible 3D solids, or that the AIGC-synthesized assets actually improve long-tail generalization rather than introducing synthetic artifacts that harm real-category performance. The part-level pipeline's area-threshold merging strategy (Section 4.3) makes heuristic decisions about which connected components to merge — without validation, a practitioner cannot assess whether these merges produce semantically coherent parts or whether the "10–40 component" target range (Section 4.3) is appropriate for their specific task. The synthetic data pipeline's output quality depends on three foundation models (an unnamed LLM, Qwen-Image with LoRA, HY3D-3.0), each of which introduces biases that compound through the pipeline — the paper does not analyze whether the synthetic meshes are geometrically or texturally distinguishable from real meshes in ways that could create dataset artifacts.

What evidence exists in the paper. None for part-level or synthetic data utility. The only experiment is the full-level image-to-3D generation evaluation in Table 2 and Figure 12. The paper does not train a part-aware model, evaluate part segmentation accuracy, measure synthetic data's effect on long-tail performance, or even provide basic statistics on synthetic data quality (e.g., Chamfer distance between synthetic meshes and artist-modeled meshes in categories where both exist, rates of watertightness or manifold violations in synthetic outputs).

Mitigation status. The paper does not attempt to address this limitation. Section 6 gestures at future work on "extending this framework to include dynamic assets and broader tasks" but does not specifically commit to experimental validation of the part-level or synthetic data. For practitioners, the practical implication is that the full-level dataset (252k assets) is the only component with any empirical backing; the part-level and synthetic data must be treated as speculative resources whose utility is unmeasured.

Difficulty Estimation for Filtering Is Not Validated, and Filtering Criteria Have No Ablated Performance Baseline

The assumption or constraint. The full-level data processing pipeline applies three categories of filtering criteria: poor geometric quality (via polygon count thresholds and "geometric complexity metrics"), poor texture quality (UV mapping problems, low texture resolution), and large areas of thin structures (Section 4.2). These are the criteria that determine which assets from the millions available in Objaverse/Objaverse-XL are retained to form the final 252k dataset. The paper provides geometric and learning-theoretic justifications for each criterion — particularly the thin-structure exclusion, which is motivated by SDF discontinuity arguments and multi-view consistency concerns (Section 4.2) — but does not report:

The specific threshold values used (polygon count minimum, geometric complexity metric definition and cutoff, texture resolution minimum, thinness metric definition and cutoff).
The fraction of Objaverse/Objaverse-XL assets rejected by each criterion.
Whether models trained on data filtered at different stringency levels show corresponding performance differences.
Whether a model trained on raw, unfiltered Objaverse data performs worse than one trained on HY3D-Bench filtered data — the most direct test of the filtering pipeline's necessity.

The consequence. A practitioner cannot determine whether the filtering criteria are well-calibrated. Overly aggressive filtering removes valuable training diversity — excluding all thin structures (Section 4.2) means the dataset likely underrepresents blades, fins, wings, sheets, and other thin-featured objects, and models trained on this data may struggle to generate such geometry. Overly permissive filtering retains assets that degrade training stability or produce artifacts. Without knowing the rejection rates per criterion, a practitioner cannot estimate how much of the original data distribution was preserved vs. discarded, or whether alternative filtering strategies (e.g., using adaptive polygon count thresholds per category rather than a global cutoff) would yield better coverage of challenging geometries.

The thin-structure exclusion is particularly consequential because the paper's justification is theoretical — thin structures cause SDF discontinuities that neural networks struggle to fit — but the theory does not specify a threshold. At what thinness does the SDF become "too sharp"? Could models learn thin structures if the data included them but with appropriate loss weighting or architectural modifications (e.g., higher-capacity decoders, frequency-based positional encodings)? The paper's choice to exclude rather than handle this challenging geometry class is a design decision that reduces training difficulty at the cost of distribution coverage, but the magnitude of this tradeoff is unmeasured.

What evidence exists in the paper. None. The filtering pipeline's design is described qualitatively in Section 4.2, but no ablation studies vary filtering criteria and measure resulting model performance. The positive Hunyuan3D-2.1-Small results (Table 2) demonstrate that HY3D-Bench data is sufficient to train a competitive model but do not demonstrate that the specific filtering choices are necessary — the same model might train equally well or better on less aggressively filtered data, or on data from prior curation efforts like Objaverse++ or Objaverse-MIX.

Mitigation status. Not addressed. The paper provides design rationale for the filtering criteria but treats the filtering pipeline as a fixed, validated component. Section 4.2 states the criteria are designed to "ensure the high quality of training data" but does not acknowledge that the criteria themselves are hypotheses about what quality means for downstream training, and that these hypotheses require empirical validation.

The Evaluation Metrics Measure Embedding Consistency, Not Geometric Fidelity

The assumption or constraint. The paper evaluates image-to-3D generation quality using Uni3D-I (Zhou et al., 2023) and ULIP-I (Xue et al., 2023a) — both are reference-free embedding-space consistency metrics that measure the cosine similarity between image embeddings and rendered 3D shape embeddings in learned joint embedding spaces (Section 5.1). The metrics do not require ground-truth 3D models for test images, which is an advantage for evaluating generation from in-the-wild images but means they measure semantic alignment (does the generated shape look like the right category of object?) rather than geometric accuracy (does the generated shape accurately reproduce the specific geometry of the target object?) or mesh quality (is the generated mesh watertight, manifold, free of self-intersections?).

The consequence. This metric choice creates a potential evaluation validity gap for HY3D-Bench specifically. The paper's entire data pipeline is motivated by geometric quality concerns — watertight mesh generation via UDF computation and Delaunay tetrahedralization (Section 4.2), exclusion of thin structures due to SDF fitting difficulty, polygon count thresholds to ensure sufficient geometric detail, hybrid point cloud sampling with edge importance to capture sharp features. These are all designed to produce geometrically better training data, which should lead to models that produce geometrically better output meshes. But the evaluation metrics cannot measure this: Uni3D-I and ULIP-I do not penalize non-watertight outputs, self-intersecting geometry, missing thin features, or poorly reconstructed edges and corners — the embedding space may assign high similarity to a semantically correct but geometrically flawed mesh.

A practitioner who needs watertight meshes for downstream applications (physics simulation, 3D printing, collision detection in robotics) cannot determine from the reported metrics whether training on HY3D-Bench data actually produces more watertight outputs than training on less carefully processed data. The paper's central claim that data quality matters for 3D generation is tested only through a lens (semantic consistency) that is partially orthogonal to the axis along which quality was improved (geometric fidelity).

What evidence exists in the paper. Table 2 reports Uni3D-I and ULIP-I for all methods, with the Small model achieving 0.3606 and 0.2424 respectively. Figure 12 provides qualitative visual examples but no systematic geometric analysis. The paper does not report Chamfer distance, Hausdorff distance, normal consistency, watertightness rate of generated meshes, edge preservation metrics, or any other geometry-level evaluation. The closest the paper comes to acknowledging this gap is a brief note in Section 5.1 describing the metrics as measuring "consistency between images and generated meshes" — which is accurate in scope but does not address the absence of complementary metrics.

Mitigation status. Not addressed. The paper does not discuss the limitations of embedding-space metrics or acknowledge the gap between the geometric quality of training data and the semantic quality measured by evaluation. The metric choice appears to be inherited from prior work (Hunyuan3D-2.1 uses similar evaluation) rather than selected through consideration of what the data pipeline was designed to improve.

The Compute-Optimal Data Scale Is Unknown, and the Dataset's Size May Exceed What Is Actually Needed

The assumption or constraint. The paper releases 252k full-level training samples (Section 4.5) but provides no analysis of how performance scales with dataset size. The Hunyuan3D-2.1-Small model is trained on the full dataset, and there is no experiment training on subsets (e.g., 25k, 50k, 100k, 200k) to determine whether performance saturates before the full 252k samples are used. The paper implicitly assumes that more curated data is better — the filtering pipeline retains assets that pass quality thresholds, and all retained assets are included — but this conflates data volume with data quality in a way that may hide diminishing returns.

The consequence. A practitioner downloading and storing HY3D-Bench faces a potentially unnecessary storage and bandwidth cost if model performance plateaus at, say, 100k samples. The paper does not report the total dataset size (in GB/TB), but with $512^3$ -resolution SDF data, multi-view renderings from multiple camera modes, hybrid-sampled point clouds, and watertight meshes per asset, the storage requirements are likely substantial. If a researcher could achieve 95% of the reported Uni3D-I score using 50% of the data, the full 252k release imposes a storage overhead with diminishing returns. Conversely, if performance continues to improve with more data, the paper provides no guidance on whether curating additional Objaverse assets (beyond the 252k) would yield further gains, or whether the filtering criteria have already captured all assets above the quality threshold.

The part-level data raises the same question more acutely: with 240k part-decomposed assets and a mean of 14.13 parts per object, the total number of individual part meshes is approximately 3.4 million. No experiment tests whether training on all 3.4 million part meshes is necessary or beneficial compared to a smaller subset.

What evidence exists in the paper. None. The training configuration (Table 1) uses the full 252k dataset without subset experiments. The paper does not report whether validation loss or downstream metrics continued to improve throughout training or saturated before the full 1.8M training steps.

Mitigation status. Not addressed. The paper does not discuss data scaling behavior or provide any guidance on whether the dataset's size is a binding constraint or an artifact of inclusive filtering. Section 6 mentions future extensions but not data scaling analysis.

The Part-Level Decomposition Is Geometric, Not Semantic, Limiting Downstream Controllability

The assumption or constraint. The part-level decomposition pipeline uses connected-component analysis followed by area-threshold merging (Section 4.3) to split holistic meshes into constituent parts. This produces geometrically distinct components but does not assign semantic labels, category names, or functional roles to parts. The paper explicitly describes this as "structured part-level decomposition" (Section 1) and positions it as providing "the granularity essential for fine-grained perception and controllable editing" (Abstract), but the decomposition is fundamentally geometric — parts are identified by mesh topology, not by what they are or what they do. A chair decomposed via connected components yields separate meshes for legs, seat, and back, but the system does not label which component is which, nor does it guarantee that components correspond to semantically meaningful units (a single "leg" component might actually be an artist-modeled leg assembly containing multiple disconnected decorative elements that CCA fails to merge appropriately).

The consequence. For applications requiring semantic part control — "make the chair legs longer" or "replace the table top with a glass surface" — the geometric decomposition is insufficient without additional semantic labeling. A controllable generation model trained on these decompositions learns to manipulate geometrically-distinct components but cannot map natural language part descriptions ("leg," "armrest," "blade") to specific components without an external semantic annotation layer. The paper's own discussion of prior work (Section 2.1) includes numerous semantic part segmentation and part-aware generation methods (PartSLIP, SAMPart3D, PartCrafter, HoloPart, etc.) that require exactly the semantic labels HY3D-Bench does not provide. This creates a gap between the data's structure (geometric parts) and the research frontier's requirements (semantic parts).

Additionally, the connected-component approach has a fundamental coverage limitation: it can only decompose objects where the artist modeled parts as disconnected mesh components. Objects modeled as single connected meshes — where chair legs share vertices with the seat, or a car body is a single continuous surface including doors and panels — cannot be decomposed by CCA and are excluded from the part-level dataset (via the <2 component filter in Section 4.3). This introduces a selection bias: the part-level dataset represents only objects with disconnected part geometry, which may systematically differ from connected-part objects in shape complexity, artist modeling style, or object category.

What evidence exists in the paper. The paper provides component count statistics (mean 14.13, median 11, Section 4.5) and describes the merging strategy qualitatively (Section 4.3), but does not report:

What fraction of the full-level assets are excluded due to the <2 component filter (making them undecomposable by CCA).
How often the area-threshold merging produces semantically coherent parts vs. over-merging distinct functional components or under-merging decorative elements.
Whether the geometric part boundaries correspond to functional part boundaries (e.g., does a "leg" component actually end where the leg meets the seat, or does it include portions of the joint?).
Category-specific analyses of decomposition quality (are chairs well-decomposed but vehicles poorly decomposed?).

Mitigation status. Partially acknowledged. The paper states that the connected-component approach "aligns the division of the holistic mesh with the semantic granularity designed by artists during the creation process" (Section 4.3), which is a claim about artist intent rather than a guarantee of semantic correctness. The area-threshold merging is described as an automatic strategy, but the paper does not characterize its failure modes. Section 6 does not specifically address semantic labeling as future work, though the broader statement about "extending this framework to include dynamic assets and broader tasks" could encompass it.

The Difficulty Estimation Cost for Replicating the Pipeline Is Not Characterized

The assumption or constraint. The paper describes a multi-stage preprocessing pipeline (Sections 4.2 and 4.3) that includes Blender-based rendering, UDF computation at $512^3$ resolution, Marching Cubes extraction, Delaunay tetrahedralization, graph-cut optimization, connected-component analysis, area-threshold merging, and dual-level watertight masking. The paper states that this processing "demands enormous GPU and CPU computational resources" (Section 2.2) and that the dataset is released precisely to spare researchers from having to run this pipeline themselves. However, the paper does not quantify:

The total compute cost (GPU-hours, CPU-hours) to process the full 252k assets.
The per-asset processing time and its variance (do complex assets take 10× longer than simple ones?).
The storage footprint of intermediate computations (the $512^3$ UDF grid per asset alone is $512^3 \approx 134$ million floating-point values).
The memory requirements for key pipeline stages (Marching Cubes on a $512^3$ grid, Delaunay triangulation of millions of tetrahedra).
The hardware configuration used (number of GPUs, CPU cores, RAM, storage).

The consequence. This limitation matters for two distinct audiences. For practitioners who want to reproduce or extend the preprocessing pipeline — to process additional assets beyond the released 252k, to apply different filtering criteria, or to adapt the pipeline to a different source repository — the paper provides no practical guidance on compute requirements. A research group considering whether they can afford to curate their own Objaverse subset using the paper's methods has no cost estimate to guide their decision. For researchers evaluating whether storing and using the released dataset is practical, the absence of storage footprint information is a barrier: if the full dataset with multi-view renderings, watertight meshes, point clouds, and part decompositions requires several terabytes, downloading it may be infeasible for groups with limited storage or bandwidth.

The paper's core claim — that HY3D-Bench "democratizes access to robust data resources" (Abstract) — implicitly depends on the released data being practically accessible. If the storage cost is prohibitive, the democratization is incomplete: the preprocessing pipeline is too expensive to run, and the processed data is too large to download, leaving researchers in the same position they were in before the release.

What evidence exists in the paper. None. Section 4.2 describes the pipeline algorithms in detail but provides no compute accounting. Section 2.2 notes the general principle that "processing large-scale training datasets (often involving millions of 3D models) demands enormous GPU and CPU computational resources," but this is stated as motivation for the data release, not as a quantified characterization of the pipeline's cost.

Mitigation status. Partially addressed by the data release itself. The paper's response to the preprocessing cost problem is to do the preprocessing once and release the results, which does mitigate the cost for researchers who can use the released data as-is. However, the absence of compute and storage characterization means researchers cannot assess whether they can use the released data (due to storage constraints) or what it would cost to process additional data (if they need assets beyond the 252k released). The paper does not suggest future work on reducing the pipeline's computational cost or providing lighter-weight data formats for resource-constrained users.

7. Implications and Future Directions

How This Work Changes the Landscape

HY3D-Bench shifts the 3D generation field's self-understanding from a data-scarcity problem to a data-processing-bottleneck problem. This is not merely a terminological change — it alters which investments the community should prioritize, which contributions are valued, and where new researchers encounter barriers. Before this work, the dominant narrative held that the primary limitation on 3D generative models was the sheer number of available 3D assets, and that the release of Objaverse (millions of models) had largely solved the data problem, leaving model architecture and training scale as the remaining frontiers. HY3D-Bench demonstrates, through both exhaustive characterization of raw-data defects (Section 4) and empirical evidence that a 832M-parameter model trained on carefully curated data nearly matches a 1,238M-parameter model trained on an alternative pipeline (Table 2: Uni3D-I 0.3606 vs. 0.3636), that data quality — not data volume or model scale — is the binding constraint at current scales.

The field-level implications are concrete and potentially disruptive:

The "more parameters" default is weakened. The dominant research strategy in 3D generation for the past several years has been to scale model size and training compute, following the trajectory set by 2D generative models. HY3D-Bench provides evidence — albeit from a single experiment on a single model family — that improving data quality can substitute for parameter scaling, achieving near-parity with 33% fewer parameters. This does not mean parameter scaling is irrelevant, but it does mean that a paper reporting improved performance from a larger model cannot attribute that improvement to model capacity alone unless it controls for training data quality. The implication for reviewers and practitioners: a 0.36 Uni3D-I achieved with 1.2B parameters on an unspecified data pipeline is less informative than a 0.36 Uni3D-I achieved with 800M parameters on HY3D-Bench, because the latter isolates model capability from data quality.

Preprocessing becomes a first-class research contribution. Prior to HY3D-Bench, the preprocessing pipeline was treated as invisible infrastructure — something every lab implemented independently, rarely documented in detail, and never published as a contribution in its own right. HY3D-Bench establishes that a preprocessing pipeline can be a paper's primary contribution, with the algorithmic component serving as validation rather than novelty. This legitimizes a category of research — data engineering for 3D — that has historically been undervalued relative to model architecture design. The detailed algorithmic specification of the watertightening procedure (UDF → Marching Cubes → Delaunay → graph-cut, Section 4.2), the connected-component decomposition strategy (Section 4.3), and the multi-criterion filtering pipeline (geometric quality, texture quality, thin-structure exclusion, Section 4.2) collectively constitute a replicable specification that the community can standardize around, improve upon, or critique — exactly the role that a well-specified model architecture plays in algorithmic papers.

The AIGC synthesis pipeline normalizes synthetic data generation as a complement to curation. The three-stage pipeline (LLM → LoRA-fine-tuned image diffusion → image-to-3D, Section 4.4) demonstrates a template for addressing long-tail category gaps that no amount of data cleaning can solve. This is significant because it breaks the implicit assumption that 3D datasets must be sourced from real, artist-modeled assets. The 125k synthetic assets spanning 1,252 fine-grained categories (Section 4.5) show that composition of separately-trained foundation models can bootstrap 3D data for categories where manual modeling is economically infeasible. The methodological contribution is not the individual models (LLMs, image diffusion, image-to-3D all existed before), but the interface design between them — the LoRA fine-tuning objectives that optimize image outputs for downstream 3D reconstruction rather than human viewing (clean backgrounds, three-quarter viewpoints, complete objects, Section 4.4) — and the recognition that synthetic data is most valuable precisely where real data is most scarce, making it a targeted supplement rather than a wholesale replacement.

Fair comparison becomes newly tractable. The fragmentation of evaluation protocols in 3D generation — different groups using different Objaverse subsets, different preprocessing, different rendering configurations, different metrics — has made head-to-head comparison scientifically suspect. HY3D-Bench's 400-object test set, fixed preprocessing pipeline, standardized rendering, released model checkpoints, and fixed metrics (Uni3D-I, ULIP-I) create the conditions for reproducible comparison that have been absent from the field. This matters not just for benchmarking competitions but for the scientific accumulation of knowledge: when a new method reports improved Uni3D-I on HY3D-Bench, the community can reasonably attribute that improvement to the method rather than to undocumented differences in data preprocessing. This standardization is not complete (the metrics are limited to embedding consistency, geometric fidelity metrics are absent, and the test set is only 400 objects — see Section 6), but it represents a substantial improvement over the prior state of no standardization at all.

What directions become more attractive, and which become less so. The paper implicitly argues that:

More attractive: Data quality research (better watertightening algorithms, semantic part labeling at scale, thin-structure handling without exclusion, automated quality assessment), infrastructure sharing (standardized data releases, community benchmarks, reproducible processing pipelines), and synthetic data pipelines (especially composition of foundation models for domains with scarce real data).
Less attractive (relative to prior): Pure model scale increases without controlled data quality (because the marginal benefit of more parameters may be smaller than the marginal benefit of better data), and SDS-based optimization methods that sidestep the need for 3D training data (because native generation with high-quality data now achieves competitive or superior quality with dramatically faster inference — the Hunyuan3D-2.1-Small model generates in a single forward pass rather than requiring per-instance optimization).

Reconciliation of prior conflicts. The paper does not resolve a specific prior contradiction (unlike, for example, the compute-optimal inference paper that reconciled conflicting findings about self-correction), but it does resolve a latent tension: why have some 3D generation models achieved impressive results while others, with similar architectures and scales, have underperformed? The paper's framing suggests that undocumented differences in data preprocessing quality — not just architecture or training scale — explain a substantial fraction of the performance variance, and that HY3D-Bench provides the controlled foundation needed to finally separate model quality from data quality in comparative evaluations.

Follow-Up Research This Work Enables

Training the same model architecture on multiple data pipelines to isolate the effect of each preprocessing step. The paper's central claim — that HY3D-Bench's preprocessing pipeline produces better training data than prior pipelines — is supported by cross-model comparisons (Hunyuan3D-2.1-Small vs. CraftsMan, Table 2) that confound architecture and data. The most important follow-up experiment is to train the same model architecture (ideally Hunyuan3D-2.1-Small, since it is released and reproducible) on data from each prior curation effort: raw Objaverse with minimal processing, Objaverse++ filtered data, Objaverse-OA oriented data, Objaverse-MIX multi-representation data, and HY3D-Bench data. Comparing Uni3D-I and geometric metrics (Chamfer distance, watertightness rate) across these conditions would directly measure the marginal value of each preprocessing dimension — quality filtering, orientation normalization, watertightening, render quality, and point cloud sampling strategy. The experiment would also reveal whether the benefits compound multiplicatively (full pipeline >> sum of individual improvements) or whether one preprocessing step dominates, guiding resource allocation for future data curation efforts. The paper does not do this experiment, and it is the single most important missing piece for validating the paper's thesis.

Geometric quality evaluation of generated meshes to test whether better training data produces better output geometry. The paper's filtering pipeline is motivated by geometric quality concerns (watertightness, polygon count, thin-structure exclusion, Section 4.2), but evaluation uses only embedding-space consistency metrics (Uni3D-I, ULIP-I) that do not measure geometry directly. A follow-up study should evaluate the generated meshes from Hunyuan3D-2.1-Small against those from CraftsMan, Michelangelo, and the full Hunyuan3D-2.1 on: (a) watertightness rate (fraction of generated meshes that are closed and manifold), (b) Chamfer distance to ground-truth meshes on a paired image-3D benchmark (if available) or to the conditioning image's source mesh where known, (c) normal consistency between generated and ground-truth surfaces, (d) edge preservation metrics measuring whether sharp features in the input image are recovered as sharp edges in the output mesh, and (e) thin-feature generation capability — can the model generate thin structures (blades, wings, fins) despite their exclusion from training data, or does the exclusion create a permanent capability gap? This experiment would test whether training on HY3D-Bench's watertight, geometrically-clean data shifts the distribution of output mesh quality (fewer degenerate outputs, better surface normals) or only shifts the mean of embedding-space metrics, with different implications for downstream applications.

Part-aware generation or segmentation experiments using the part-level data to validate the decomposition strategy. The part-level dataset (240k assets, mean 14.13 parts, Section 4.5) is released without any experimental validation. A minimal validation experiment would train a part-conditioned generation model — for example, a variant of Hunyuan3D-2.1 that conditions on part ID masks in addition to RGB images, producing meshes with per-part labels — and measure: (a) whether the generated part boundaries correspond to semantically meaningful divisions (evaluated via human annotation on a subset of generated outputs), (b) whether the model can perform part-level editing (e.g., "enlarge the chair legs while keeping the seat unchanged") using the geometric part decomposition as the manipulation granularity, and (c) how often the connected-component decomposition fails for specific categories (chairs, vehicles, electronics) by comparing HY3D-Bench's geometric parts against human-annotated semantic parts from PartNet (Mo et al., 2019) on overlapping categories. This third analysis would quantify the selection bias introduced by CCA-based decomposition (only objects with disconnected part geometry are included) and identify categories where geometric decomposition is a poor proxy for semantic decomposition, guiding users on which categories the part-level data is suitable for.

Long-tail category generalization with and without synthetic data to measure the AIGC pipeline's contribution. The AIGC pipeline generates 125k synthetic assets across 1,252 fine-grained categories (Section 4.4) specifically to address long-tail distribution gaps, but the paper provides no experiment measuring whether synthetic data actually improves performance on rare categories. A follow-up experiment should: (a) identify the 100 most rare categories in the full-level dataset (those with fewest training examples, using the category distribution in Figure 6), (b) train Hunyuan3D-2.1-Small on real data only vs. real + synthetic data (matching total training samples to control for dataset size), and (c) evaluate Uni3D-I and geometric metrics specifically on held-out examples from those 100 rare categories. The hypothesis is that synthetic data improves rare-category performance by filling the distribution gap. A negative result — synthetic data does not improve or even harms rare-category performance — would suggest that the synthetic-to-real domain gap (from HY3D-3.0's biases, Qwen-Image's biases, and the LLM's descriptive biases) outweighs the benefit of additional training examples, and that synthetic data pipelines need better domain adaptation (e.g., adversarial training to match real data statistics) before they can serve as effective supplements.

Thin-structure generation as a stress test for the filtering strategy. The paper's explicit exclusion of assets with large areas of thin structures (Section 4.2) is one of its most consequential design decisions, justified by SDF discontinuity arguments and multi-view consistency concerns. A follow-up study should systematically stress-test this choice: (a) curate a small "thin structure test set" of 50–100 objects with prominent thin features (blades, wings, fins, sheets, wires) that were excluded from HY3D-Bench training, (b) evaluate Hunyuan3D-2.1-Small on these objects — can it generate thin structures at all, or has their exclusion from training created a permanent capability gap? (c) train an ablation model on HY3D-Bench data augmented with the excluded thin-structure assets (at varying ratios: 1%, 5%, 10% of training data) and measure whether training stability degrades (higher validation loss, more non-manifold outputs) and whether thin-structure generation capability emerges, and (d) compare against a model trained from scratch on data that includes thin structures but uses architectural modifications to handle them — e.g., higher-capacity SDF decoders, frequency-based positional encodings, or specialized thin-feature loss terms. This experiment would determine whether thin-structure exclusion is a necessary preprocessing choice (training fails without it) or a convenient shortcut (training is harder with it but the capability gap it creates is worse than the training difficulty it avoids).

Scaling analysis to determine whether HY3D-Bench's size is compute-optimal for 3D generation. The paper releases 252k training samples but provides no analysis of how performance scales with dataset size. A follow-up should train Hunyuan3D-2.1-Small on random subsets of HY3D-Bench at sizes of 10k, 25k, 50k, 100k, 150k, and 252k samples, measuring Uni3D-I, ULIP-I, and geometric metrics at each size. This would reveal: (a) whether performance saturates before 252k (if so, storage and download costs could be reduced), (b) the scaling exponent — does performance follow a power law in dataset size, and if so, what is the exponent? Comparing this exponent to published scaling laws for 2D image generation would characterize how data-hungry 3D generation is relative to 2D, and (c) whether different categories scale at different rates — do common categories (chairs, tables) saturate early while rare categories continue to improve, or do all categories benefit similarly from more data? This analysis is essential for practitioners deciding how to allocate limited storage and training compute budgets, and it would establish whether HY3D-Bench's 252k assets represent a point of diminishing returns or a point on a still-steep scaling curve.

Practical Applications and Downstream Use Cases

Rapid prototyping of 3D generative models for research labs. The most immediate practical use case is enabling academic and small-industry research groups to train competitive 3D generation models without investing in the specialized data engineering infrastructure (Blender scripting, mesh repair, multi-view rendering pipelines, SDF computation, watertightening) that previously consumed months of setup time before any model training could begin. The paper estimates that processing millions of models "demands enormous GPU and CPU computational resources" (Section 2.2) — a cost measured in thousands of GPU-hours and weeks of engineering time. By releasing 252k training-ready assets with watertight meshes, multi-view renderings, and hybrid-sampled point clouds, HY3D-Bench eliminates this upfront cost entirely. A new PhD student entering 3D generation can download the dataset, use the released Hunyuan3D-2.1-Small checkpoint as a baseline, and begin iterating on model architecture or training strategies within days rather than months. The pre-trained model checkpoint (832M parameters, Uni3D-I 0.3606, Table 2) provides a reproducible starting point that was not available before — prior baselines like Michelangelo (105M parameters, Uni3D-I 0.3169) and CraftsMan (852M parameters, Uni3D-I 0.3351) were either too weak or trained on different data, making incremental improvements hard to measure.

Robotics simulation with watertight, part-decomposed assets. Robotics simulators (Isaac Sim, MuJoCo, PyBullet) require watertight meshes for collision detection and grasp planning — non-manifold geometry, holes, or self-intersections cause physics engines to fail or produce undefined behavior. The HY3D-Bench full-level dataset provides 252k watertight meshes guaranteed to be closed and manifold (via the UDF → Marching Cubes → Delaunay → graph-cut pipeline, Section 4.2), directly usable in simulation without repair. The part-level dataset (240k assets, mean 14.13 parts, Section 4.5) enables a specific robotics capability: training manipulation policies that reason about object parts. A robot grasping a mug needs to distinguish the handle (graspable) from the body (containment); a robot assembling furniture needs to understand how legs attach to a seat. The per-part watertight meshes and part ID masks (Section 4.3) provide the geometric and visual supervision needed to train part-aware perception models that can identify these functional components from sensor data. The AIGC synthetic data (125k assets, 1,252 fine-grained categories, Section 4.4) addresses a long-standing robotics simulation gap: the lack of diverse objects for training manipulation policies that generalize across product categories. A warehouse robot trained only on chairs and tables will fail when encountering a standing desk or a floor lamp; the synthetic data's category coverage (daily necessities to industrial products) provides the diversity needed for robust generalization.

E-commerce 3D product visualization at scale. For e-commerce platforms, creating 3D models of every product in a catalog spanning 1,252 fine-grained categories (Section 4.4) is economically infeasible through manual modeling — the cost of artist time per product multiplied by the catalog size exceeds any plausible return on investment. The AIGC synthesis pipeline (LLM → Qwen-Image + LoRA → HY3D-3.0, Section 4.4) demonstrates a scalable alternative: given a product category label, generate a photorealistic product image with clean background and appropriate viewpoint (LoRA fine-tuning objectives, Section 4.4), then reconstruct a textured 3D mesh via image-to-3D. The 125k synthetic assets released with HY3D-Bench can serve as pre-generated product visualizations for long-tail categories, or the pipeline itself can be deployed to generate 3D models on-demand for new products as they are added to the catalog. The quality requirements for e-commerce visualization (recognizable shape, plausible texture) are less stringent than for engineering or simulation applications, making synthetic data particularly well-suited to this use case. The full-level dataset's multi-view renderings (orthographic and perspective, Section 4.2) can also serve directly as product images for categories where 3D models exist but product photography is unavailable — a single 3D model yields dozens of high-quality product views without requiring a photo studio.

Standardized benchmarking for 3D generation competitions and leaderboards. The fragmentation of evaluation protocols in 3D generation has made it impossible to maintain a meaningful leaderboard — different papers report numbers on different test sets, different preprocessing, and different metrics, so "state-of-the-art" is undefined. HY3D-Bench's 400-object test set with fixed evaluation protocols (Uni3D-I and ULIP-I, Section 5.1), fixed preprocessing (all methods evaluated on the same test set with the same rendering configuration), and released baseline checkpoints (Hunyuan3D-2.1-Small, Hunyuan3D-2.1, Trellis, CraftsMan, Michelangelo — Table 2) creates the infrastructure for a community leaderboard analogous to what PapersWithCode provides for 2D vision tasks. A new method can be evaluated by the community on the same test set with the same metrics, producing numbers that are directly comparable to the baselines in Table 2. This lowers the barrier to entry for new methods (no need to run your own evaluation on your own data split to claim improvement) and increases the reliability of claimed improvements (the fixed test set prevents accidental or intentional cherry-picking of favorable test splits). The released model checkpoints also enable a specific fair-comparison practice: when a new method reports Uni3D-I on HY3D-Bench, the community can independently verify that number against the released baselines, making results reproducible in a way that was previously impossible when every group used their own data pipeline.

When to Prefer This Method

HY3D-Bench is not a "method" in the conventional sense — it does not propose a new algorithm for 3D generation and does not compete directly against existing generation models on a quality-vs-speed tradeoff. It is a data infrastructure release with a validation experiment, making the "when to prefer" framing somewhat unnatural. However, the paper does articulate implicit tradeoffs that guide when to use HY3D-Bench data versus alternatives:

Prefer training on HY3D-Bench data when:

You are developing a new 3D generative model and want a reproducible, community-standard training set that enables fair comparison against published baselines (Table 2 provides five reference points: Michelangelo, CraftsMan, Trellis, Hunyuan3D-2.1, and Hunyuan3D-2.1-Small).
You need watertight meshes for downstream applications (physics simulation, 3D printing, collision detection) and cannot afford the per-asset watertightening pipeline yourself — HY3D-Bench guarantees watertightness via the UDF → Marching Cubes → Delaunay → graph-cut procedure (Section 4.2).
You need part-decomposed assets for part-aware generation, fine-grained editing, or robotic manipulation, and geometric decomposition (connected-component-based, Section 4.3) is sufficient for your task — HY3D-Bench provides 240k pre-decomposed assets with per-part watertight meshes and part ID masks.
Your application requires coverage of long-tail product categories (e-commerce, robotics in diverse environments) where real 3D data is scarce — the 125k AIGC-synthesized assets (Section 4.4) provide category coverage (1,252 fine-grained classifications) that no real dataset matches.

Prefer alternative data sources when:

You specifically need to generate or reconstruct thin structures (blades, wings, fins, wires) — HY3D-Bench explicitly excludes assets with large areas of thin structures (Section 4.2), and models trained on this data may have a capability gap for thin-feature generation (this gap is hypothesized but not experimentally characterized in the paper).
You need semantic part labels (e.g., "chair leg," "car door") rather than geometric part decomposition — HY3D-Bench's parts are identified by mesh topology, not functional role (Section 4.3), and using them for semantic part control requires an additional labeling step that the paper does not provide.
Your model architecture or training pipeline has specific preprocessing requirements that differ from HY3D-Bench's choices — for example, if you need Signed Distance Fields at a resolution other than the implicit $512^3$ used for watertightening, or if you need specific rendering configurations (lighting, materials, camera trajectories) not covered by HY3D-Bench's orthographic and perspective multi-view setup (Section 4.2). In this case, the raw Objaverse data or an alternative curated subset may be more appropriate as a starting point.
Storage or bandwidth constraints make the dataset infeasible — the paper does not report the total download size, but with 252k assets each containing watertight meshes, multi-view renderings, and point clouds, the total is likely multiple terabytes. A researcher with limited storage may need to work with a smaller curated subset (e.g., ShapeNet's 50k models) or train on raw Objaverse with lighter preprocessing.