Native 3D Generative Models: MeshGPT, Trellis, Hunyuan3D

Last lesson's pipeline — multi-view diffusion → feed-forward reconstruction → mesh extraction — is fundamentally 2D-lifting. The model never reasons in 3D; it generates 2D views that happen to be consistent with one another, and a separate module hallucinates geometry from them.

Native 3D flips this: the generative model produces a 3D representation directly. The training signal is 3D, the loss is in 3D, the output is 3D. No image priors leaking in, no view-consistency tricks.

Why this matters in 2026: the multi-view recipe gets you 80% of the way there cheaply, but its ceiling is bounded by what 2D priors can express. Native models — Trellis, Hunyuan3D-2, MeshGPT — are the methods crossing that ceiling. They're also harder to train, which is why they arrived later.

Three concrete wins that justify the harder engineering.

• Topology. A 2D-lifted mesh is whatever marching cubes spits out of an SDF — a fine-but-noisy triangle soup. A native autoregressive mesh model emits triangles directly, in an order, with control over face count. The output looks closer to how an artist would build it.
• Sharp features and thin parts. Voxel/SDF-based pipelines are limited by their grid resolution; anything thinner than a few voxels gets eaten. Native mesh models don't have a grid — a sword can be one triangle wide if it needs to be.
• Parameter efficiency. A 5,000-triangle dragon is a few thousand tokens to an autoregressive mesh model. That same dragon as a 256³ SDF is 16M voxels' worth of latent. Native representations are dramatically more compact for the same geometry.

The pricetag: 3D data scarcity is real (Objaverse-XL is large but still tiny next to LAION-5B), and the architectures have to fight for every win.

MeshGPT (2023, Siggraph 2024 best paper finalist) was the proof-of-concept: tokenize a mesh as a sequence of triangles, train a GPT-style transformer to predict the next triangle, condition on text/image.

The tokenization is the crucial part. MeshGPT runs a graph convolutional VQ-VAE on triangles, quantizing each triangle into a discrete codebook entry — 6 tokens per triangle (one per vertex coordinate-axis). A 4,000-triangle mesh becomes ~24,000 tokens. A standard transformer learns the distribution.

The descendants pushed the recipe further:

• PolyGen (2020) — earlier autoregressive mesh model, vertices and faces predicted separately.
• MeshXL (2024) — scaled MeshGPT up, demonstrated cleaner scaling laws.
• MeshAnything (v1, v2) — replaced the GCN VQ-VAE with a more efficient tokenizer, brought sequence length down by 2-3×.
• EdgeRunner (2025) — token-efficient autoregressive generation with edge-based traversal, currently the best topology-quality tradeoff in open-source.

All of them share a key property the 2D-lifting school can't match: you can prompt them to hit a target triangle budget.

Why does mesh tokenization keep getting research papers? Because meshes are hostile to the GPT recipe.

The naive scheme — emit each vertex coordinate as a token, then each face's vertex indices — produces astronomically long sequences. A 10k-triangle mesh has 30k vertex coordinates, plus 30k index tokens, plus separator tokens. You're at ~80k tokens for a single mid-quality asset. Attention is $O(n^2)$ in sequence length.

The state-of-the-art tricks:

• Vertex quantization. Discretize coordinates to a 7-bit or 8-bit codebook. Lossy but recoverable.
• Face-level tokens. Don't emit vertex coordinates raw; tokenize the whole triangle through a learned VQ codebook.
• Canonical traversal order. Choose a deterministic edge-walking order (EdgeRunner) so the next-token distribution is sharper and easier to learn.
• Triangle strips. Emit shared edges only once, like an OBJ strip — roughly halves sequence length on dense meshes.

The result of stacking these: 5,000-triangle output meshes in 8-16k tokens — within reach of standard transformer training stacks.

Trellis (Microsoft Research, Dec 2024) is the other path: rather than autoregressive triangles, use a diffusion / flow-matching transformer on a structured latent representation.

The Trellis recipe:

1. Structured Latent (SLAT). Each shape is encoded as a sparse set of active voxels with per-voxel latent vectors. The structure is determined by where there's geometry; the latents store the local detail.
2. Two-stage generation. A first transformer generates the structure (which voxels are active). A second transformer generates the latents at those voxels. Both stages are flow-matching, à la Stable Diffusion 3.
3. Multi-format decoders. From the same latent, Trellis decodes to a mesh, a 3D Gaussian Splat, or a radiance field. This is the 'hybrid output' trend in practice.

Why this won attention: Trellis hit SOTA on geometric quality benchmarks while remaining single-pass and tractable on a single H100. Microsoft also published the model openly — it became a baseline for everything that followed.

Trellis was Microsoft's structured latent. Hunyuan3D-2 (Tencent, Jan 2025) and TripoSG (Tripo, 2025) are the two open-source successors that closed the gap to the best closed platforms.

Hunyuan3D-2 (open weights, generous license):

• Stage 1: Hunyuan3D-DiT. A flow-matching diffusion transformer over a continuous, single-codebook latent learned by a ShapeVAE on signed distance functions. Conditioned on a single image. Produces SDF; marching cubes to mesh.
• Stage 2: Hunyuan3D-Paint. A separate multi-view diffusion model textures the mesh produced by stage 1. Importantly, decoupled from shape generation — you can re-texture without re-shaping.

TripoSG (Tripo's flagship): rectified-flow transformer over an SDF latent, single-stage for geometry, similar quality. Available via API.

The common thread: flow matching (a simpler, often-faster cousin of diffusion) on a clean SDF or structured latent. The community converged on this recipe by mid-2025 and it's still the dominant shape of new releases in 2026.

Architectural shape of the two dominant native-3D approaches.

What kinds of inputs can drive native 3D generation in 2026.

• Single image. The dominant production conditioning. Both Hunyuan3D-2 and TripoSG take a single reference image and produce a 3D model that matches its silhouette and detail.
• Text prompt. Usually a two-step in practice — text-to-image (Flux / SD3 / Imagen 3) then image-to-3D. End-to-end text-conditioned native 3D exists (MeshGPT, MVDream) but commercial pipelines still prefer the explicit image hop because users want to see the image first.
• Multi-view images. When the user supplies several photos, dedicated models (Wonder3D, Era3D) consume them as conditioning.
• Sketches / line drawings. A growing capability — Tripo and Meshy both ship sketch-to-3D in 2026. Quality is good for clean line art, fragile for messy strokes.
• Point clouds. Used for refining a rough capture into a clean mesh. Models like Make-A-Shape consume sparse point clouds as a conditioning signal.
• Bounding box + text. Layout-conditioned 3D, useful when generating a scene of multiple objects.

The pattern: the more constrained the conditioning, the higher the fidelity to user intent — and the more rerolls you save.

If you're choosing a model in 2026, here's the honest landscape.

For product engineering, the realistic choice is: Hunyuan3D-2 self-hosted for control and unit economics, or a closed API for time-to-market plus the integrated downstream features (texturing, rigging, asset library). The pure-quality gap between best open and best closed is the smallest it has ever been; the gap in product surface is still meaningful.

Honest limits as of mid-2026, useful when sizing the technology for a specific use case.

• Scale to scenes. Native models handle single objects well — chairs, characters, props. Generating an entire room with multiple coherent objects is mostly an unsolved problem; most platforms compose scenes by placing single-object outputs.
• Articulated objects. A door with a hinge, a robot with joints, a character with separable limbs — native 3D doesn't natively understand articulation. Rigging is bolted on afterwards.
• Exact-spec geometry. CAD-style 'this hole is 4.20 mm wide' is the wrong abstraction for these models. Diffusion and autoregressive models are fundamentally fuzzy; engineering tolerances need a different tool.
• Hard surfaces with crisp edges. A perfectly square block with a perfectly sharp 90° edge is harder than it looks. Flow-matching models tend to soften crisp features unless the latent grid is high-resolution.
• Internal structure. What's inside a closed object? Most native 3D models only learn surfaces. Volumetric internal structure — gears, cabling, anatomical interiors — is mostly out of scope.

Knowing these in advance is how you avoid promising a customer something the model fundamentally can't deliver.