💻 computer science

Nexus: Native Mesh Generation with Diffusion

Nexus is a novel diffusion-based framework that generates high-quality 3D meshes by decoupling the process into coarse-to-fine vertex generation via octree-based sparse voxels and global topology recovery using continuous per-vertex embeddings, thereby outperforming traditional autoregressive methods in both quality and robustness.

Original authors: Hanxiao Wang, Ying-Tian Liu, Yuan-Chen Guo, Qi-Yuan Feng, Zi-Xin Zou, Ding Liang, Biao Zhang, Yan-Pei Cao

Published 2026-07-16

📖 9 min read🧠 Deep dive

CC BY 4.0

Original authors: Hanxiao Wang, Ying-Tian Liu, Yuan-Chen Guo, Qi-Yuan Feng, Zi-Xin Zou, Ding Liang, Biao Zhang, Yan-Pei Cao

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a 3D world, like the ones you see in your favorite video games or movies. To make these worlds look real, computers use "meshes"—invisible nets made of tiny triangles that wrap around objects to give them shape. For a long time, the best way to teach a computer to draw these nets was to make it act like a very fast, very strict robot that builds the object one tiny piece at a time, in a specific order. It's like trying to build a house by laying down every single brick one by one, from the bottom left corner to the top right, without ever being allowed to jump ahead or look at the whole picture. If the robot makes a mistake with the first brick, the whole house might end up crooked, and it takes a long time to finish because it can't skip steps.

But what if the computer could just "dream" the whole shape into existence all at once? This is the big question researchers in computer graphics are asking. They want to move away from that slow, brick-by-brick building style and instead use a method called "diffusion." You can think of diffusion like watching a cloud of fog slowly clear up to reveal a statue underneath. Instead of building the statue piece by piece, the computer starts with a messy cloud of noise and gradually refines it until a perfect 3D object appears. The challenge has been that 3D shapes are tricky; they aren't just flat pictures, and they have a "skeleton" (the triangles) that needs to connect perfectly. If the computer gets the shape right but the skeleton wrong, the object falls apart.

This is where a new paper called "Nexus" comes in. The researchers behind Nexus decided to stop building 3D meshes like a robot laying bricks and start treating them more like a sculptor shaping clay. They created a new system that generates 3D meshes in two big, parallel steps, completely skipping the need to sort the pieces in a specific order. First, they use a special "fog-clearing" process to figure out where the points (vertices) of the object should be, building the shape from a rough blob into a detailed model. Second, they use a clever new math trick to figure out how those points should connect to each other to form the triangles, without ever having to guess the order.

The paper suggests that this new way of thinking solves the biggest problems of the old methods. The old "brick-by-brick" approach often leads to errors piling up, where one mistake ruins the whole model, and it takes a long time to generate complex shapes. Nexus, however, seems to avoid these traps. In their tests, the system generated high-quality 3D models that looked better and had fewer mistakes than the best previous methods. The researchers even asked real 3D artists to look at the results without knowing which computer made them, and the artists overwhelmingly preferred the shapes made by Nexus. The paper shows that by letting the computer see the whole shape at once and using this new "fog-clearing" technique, we can create complex, artistic 3D worlds much faster and more reliably than before.

The Old Way: The Robot with a Bad Memory

To understand why Nexus is a big deal, let's look at how computers used to make 3D shapes. Imagine you are trying to describe a complex sculpture to a friend over the phone. The old way of doing this was to say, "First, put a dot here. Then, put a dot there. Now, connect them. Then, put another dot..." You had to list every single point and connection in a strict line, one after another. This is called an "autoregressive" process.

The problem with this line-by-line approach is that it's like playing a game of "telephone" with a very long list of instructions. If you make a tiny mistake on the first instruction, the next one might not make sense, and the whole sculpture ends up looking like a twisted mess. Also, because the computer has to wait for one step to finish before starting the next, it takes a long time to build anything complicated. It's like trying to paint a massive mural by only being allowed to paint one tiny square inch at a time, waiting for the paint to dry before moving to the next square.

The New Way: Dreaming the Shape

Nexus changes the game by saying, "Why build it piece by piece when we can dream the whole thing at once?" The researchers call their method "diffusion." Think of it like this: imagine you have a jar filled with swirling, colorful fog. Inside that fog, a hidden shape is waiting to be revealed. The computer starts with a jar full of random, messy fog. Then, it takes a step back and asks, "If I remove a little bit of this fog, what shape is starting to show?" It does this over and over, slowly clearing away the noise until a perfect 3D object pops out.

But there's a catch. A 3D object isn't just a smooth blob; it's made of a net of triangles. The computer needs to know two things: where the points are (the geometry) and how they connect (the topology). The old diffusion methods struggled with the "how they connect" part because the number of triangles can change from object to object, and the computer got confused trying to guess the order.

The Two-Step Magic of Nexus

Nexus solves this by splitting the job into two separate, super-fast tasks that don't need to wait for each other.

Step 1: The Octree Sculptor (Finding the Points)
First, the system figures out where the points of the object should be. Instead of looking at the whole object at once, it uses a "hierarchical octree." Imagine a giant 3D Rubik's cube. The computer starts by looking at the whole cube. Is the object inside? If yes, it splits that cube into eight smaller cubes. It checks each small cube. If a small cube has part of the object, it splits that one into eight even tinier cubes. It keeps doing this, getting more and more detailed, until it finds the exact spots where the points should be.

This is like a sculptor who starts with a big block of stone, chips off the corners to get a rough shape, then chips off smaller bits to get the curves, and finally uses a tiny tool to carve the fine details. The computer does this "fog-clearing" process at every level of the cube, building the shape from a rough blob to a sharp, detailed object. Because it does this in layers, it's very efficient and doesn't get confused by the size of the object.

Step 2: The Spacetime Weaver (Connecting the Dots)
Once the points are found, the computer needs to connect them to make triangles. This is the hardest part. The researchers invented a new math trick called the "Spacetime Interval."

Imagine you have a bunch of dots floating in space. In normal math, if two dots are close to each other, they are "connected." But in 3D shapes, two dots can be close but not connected (like two points on opposite sides of a thin sheet of paper). The old math got confused by this.

The "Spacetime Interval" is like a special ruler that has two sides: a "space" side and a "time" side. The computer gives every dot a secret code that has both a space part and a time part. To see if two dots should be connected, it doesn't just measure the distance between them. It measures the difference between their space distance and their time distance. If the space part is bigger than the time part, they get connected. If the time part is bigger, they stay apart.

This sounds weird, but it works like magic. It allows the computer to handle complex shapes where dots are close but shouldn't touch, or far apart but should be connected. It's like having a special pair of glasses that lets you see the invisible strings connecting the dots, even when the dots look like they are in the wrong places. By using this trick, the computer can figure out the entire web of connections all at once, without having to guess the order.

What the Results Show

The researchers tested Nexus on huge datasets of 3D models, including thousands of toys and objects from the internet. They compared it to the best existing methods, which still used the old "brick-by-brick" approach.

The results were clear: Nexus made better shapes. The models had fewer holes, fewer broken parts, and looked more like real objects. When they asked 3D artists to pick their favorite models without knowing which computer made them, the artists chose the Nexus models 93% of the time. That's a huge win.

The paper also showed that Nexus is very tough. Even if the input data was messy or had noise (like a bad 3D scan), Nexus still managed to make a clean shape. It could also handle objects with thousands of triangles, which used to take a long time with the old methods. In fact, it could generate a complex scene with up to 20,000 triangles in about 60 seconds on a single computer chip.

Why This Matters

This paper suggests that we don't need to force computers to build 3D worlds like robots. By letting them use a "dreaming" process (diffusion) and giving them a new way to understand connections (Spacetime Interval), we can create 3D shapes that are more beautiful, more accurate, and much faster to make.

The researchers admit that their method isn't perfect yet. It still takes about a minute to generate the points, and sometimes the faces of the object need a little extra fixing to make sure they are facing the right way. But the core idea—that we can generate complex 3D meshes without sorting them in a specific order—seems to be a powerful new direction for the future of 3D art and gaming. It opens the door for computers to create entire worlds that feel as natural and fluid as the ones we see in our dreams.

Technical Summary: Nexus: Native Mesh Generation with Diffusion

Problem Statement

The generation of high-quality triangle meshes is critical for film, gaming, and interactive 3D applications. Current state-of-the-art methods predominantly rely on mesh serialization and autoregressive processes, where meshes are represented as 1D discrete token sequences. This approach faces three fundamental limitations:

Inefficiency: As mesh complexity increases, the sequence length grows linearly, requiring numerous autoregressive steps and resulting in minute-level generation times.
Error Accumulation: The sequential nature makes the process highly sensitive to early errors; a single incorrect token can render the subsequent mesh sequence meaningless.
Permutation Sensitivity: Meshes inherently lack a natural ordering. Autoregressive methods impose arbitrary sorting orders (e.g., Z-order), leading to inconsistent results based on the chosen traversal path.

While some diffusion-based methods exist, they often struggle with modeling the distribution of token sets with variable lengths or are restricted to raw space representations that hinder flexible scaling. The core challenge addressed by this work is whether it is possible to generate artistic meshes as a holistic structure while bypassing the difficulties of modeling variable-length token sets and avoiding serialization.

Methodology

The authors propose Nexus, a fully diffusion-based framework that eliminates serialization entirely by decoupling mesh generation into two parallelizable stages: hierarchical vertex generation and vertex-conditioned topology generation.

1. Hierarchical Octree Vertex Generation

Instead of treating vertices as a 1D sequence, Nexus models them as sparse occupancy signals within an octree structure.

Representation: Vertices are quantized into $D$ -bit coordinates, forming a tree $O = \{O_0, O_1, \dots, O_D\}$ . The final vertex set is extracted from the occupied leaf nodes of the finest level.
Process: The generation follows a coarse-to-fine probabilistic process factorized across tree depths: $p(V|C) = \prod p(O_d | O_{d-1}, C)$ .
Model: A unified diffusion transformer (DiT) predicts the occupancy of child nodes for each occupied parent node. The model uses flow matching with velocity prediction, 3D RoPE for position encoding, and depth embeddings.
Inference: Starting from a root node, the model iteratively predicts occupancy for deeper levels conditioned on the input (point clouds or images) and the previously generated levels.

2. Topology Generation via Spacetime Interval

To generate topology (edges and faces) conditioned on the generated vertices, the authors introduce a novel geometric indicator called the Spacetime Interval.

Topology Autoencoder: A hybrid architecture (interleaved Graph Convolution and Transformer blocks) encodes mesh topology into per-vertex latent embeddings ( $Z$ ).
Spacetime Embeddings: Each vertex embedding $z_v$ $z_{v}$ is split into spatial ( $s_v$ $s_{v}$ ) and temporal ( $t_v$ $t_{v}$ ) components.
- 1st Order (Edges): The edge indicator is defined as the difference of squared distances: $d_{u,v} = \|s_u - s_v\|^2 - \|t_u - t_v\|^2$ . A positive value indicates an edge (space-like separation), while a negative value indicates no connection (time-like).
- 2nd Order (Faces): The face indicator extends this to squared areas: $d_{u,v,w} = A_{s, u,v,w}^2 - A_{t, u,v,w}^2$ .
Advantage: Unlike Euclidean metrics which impose transitive proximity (clustering bias), the indefinite metric signature (Minkowski space) allows the model to represent complex, non-manifold topologies where nodes share neighborhoods without being connected.
Diffusion: A diffusion model generates these continuous per-vertex latents conditioned on the vertex set and input.
Recovery: During inference, edges are recovered by computing pairwise intervals, and faces are identified by finding closed 3-cycles in the edge graph and verifying them with the 2nd-order interval. This "edges-first" strategy reduces complexity from $O(|V|^3)$ to $O(|V|^2)$ .

Key Contributions

Sort-Free Framework: Nexus is the first framework to achieve holistic mesh generation without serialization, eliminating the bottlenecks of autoregressive ordering and error accumulation.
Hierarchical Octree Diffusion: A novel method for generating vertex structures efficiently in a coarse-to-fine manner, leveraging spatial sparsity.
Spacetime Interval: A geometric indicator designed to encode arbitrary topology (including non-manifold) into continuous per-vertex features, enabling diffusion-based topology generation.
State-of-the-Art Performance: The method outperforms existing autoregressive and two-stage baselines on large-scale datasets (Objaverse, Toys4K) and in-the-wild images.

Experimental Results

The authors evaluated Nexus on Objaverse and Toys4K datasets, as well as with in-the-wild images.

Quantitative Metrics: Nexus achieved superior performance in Hausdorff Distance (HD) and Chamfer Distance (CD) compared to baselines like MeshAnything, BPT, and FastMesh. For example, on Objaverse, Nexus achieved a CD of 0.031 versus 0.040 for the next best method (FastMesh).
Robustness: The model demonstrated stability across varying point cloud densities (512 to 16,384 points) and was robust to input noise (Gaussian noise $\sigma=0.003$ caused less than 10% degradation in CD).
User Study: A blind pairwise study with 1,221 comparisons from 3D practitioners showed a 93.0% preference rate for Nexus over baselines, with a significantly higher Elo rating (1440.4). Practitioners noted superior edge flow, structural integrity, and reduced artifacts.
Image-Conditioned Generation: When compared to TRELLIS (a structured latent isosurface method), Nexus produced sharper geometric details and cleaner edge flows, outperforming TRELLIS in both geometric metrics and 3D-aware semantic similarity (ULIP-Sim, UNI3D-Sim).
Ablation Studies: Removing the spacetime interval (replacing with Euclidean or Spherical metrics) caused massive topological degradation (Face F1 dropped from ~0.999 to ~0.859). Removing graph convolutions or global attention also significantly harmed performance, validating the necessity of the hybrid encoder.

Significance and Claims

The paper claims that Nexus represents a fundamental shift in 3D generative modeling by treating mesh generation as an order-agnostic, holistic process. By decoupling geometry and topology into efficient, parallelizable diffusion processes, the method:

Circumvents inherent limitations of sequential modeling, such as permutation sensitivity and error accumulation.
Enables robust scaling to complex meshes with arbitrary topologies (up to 20,000 faces) without the need for sorting.
Provides a new perspective on modeling non-Euclidean structures through continuous diffusion, paving the way for more scalable 3D generative models.

The authors acknowledge limitations, including the generation time for the vertex stage (approx. 1 minute for 512 resolution) and the need for a post-processing orientation correction step for face normals, as the current model does not predict normals directly. However, they assert that the proposed approach successfully eliminates the need for serialization while maintaining high-quality, artist-friendly mesh outputs.