acceptodds
Under review as a conference paper at ICLR 2027

Order-Agnostic Artistic Mesh Generation via Local Expansion

Abstract

We introduce MeshExpand, an order-agnostic and local framework for generating artistic meshes from input 3D shapes at high resolution. Recent learning-based methods formulate mesh generation as global sequence prediction, which couples generation to a predefined serialization order and can require long contexts as mesh resolution grows. Instead, we formulate mesh generation as learned local surface expansion. Starting from one or more seed triangles, MeshExpand iteratively selects an open boundary edge and predicts the opposite vertex from a bounded neighborhood of nearby faces and point samples, together with a global shape prior. This formulation maintains a constant-size local context per generation step that is independent of the output mesh resolution. Representing previously generated faces as an unordered set further removes dependence on a fixed generation order and enables the same model to support arbitrary growth directions, partial mesh completion, and local editing. MeshExpand also provides global and local resolution control by coupling triangle size with input point density, and uses online geometric validation and resampling to suppress invalid mesh configura- tions during generation. Experiments show that MeshExpand scales to meshes with up to 120K faces using less than 2 GB of GPU memory, transfers to out-of-distribution scanned and generated shapes with fewer degradation and improves geometric fidelity, orientation consistency, and manifoldness. Our code and model weights will be made publicly available upon paper acceptance.

Primary area:
generative models
Keywords:
3D generation, artistic mesh generation

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_kWuVOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

MeshExpand presents a framework for artistic mesh generation from oriented point clouds through learned local surface expansion. Starting from seed triangles, the model selects an open boundary edge and predicts an opposite vertex or a boundary token, conditioned on nearby faces, local point samples, and a global shape representation. An unordered local face representation removes the requirement for a fixed generation sequence, while geometric validation and resampling filter candidate triangles. The training procedure combines masked pretraining, randomized traversal contexts, and point-density conditioning. Experiments evaluate reconstruction quality, generalization, alternative growth orders, mesh completion, and memory usage.

Critical strengths
  1. A coherent local formulation that enables flexible mesh completion and editing. The model conditions on a bounded spatial neighborhood rather than a fixed global sequence prefix. This allows the same trained model to operate under different boundary-selection orders and continue generation from existing partial meshes. Tables 3 and 4 provide meaningful evidence for these capabilities. The bounded neural context also offers a clear architectural advantage for controlling per-step memory requirements as the output grows.
  2. Strong reported cross-domain results, supported by informative component ablations. On the combined GSO and Trellis evaluation in Table 1, MeshExpand achieves the best reported results across all five metrics. The ablations also identify substantial benefits from the training and validation components: removing MAE pretraining reduces normal consistency from 0.92 to 0.59, while geometric validation and resampling reduce the average numbers of self-intersecting faces and open boundaries from 6.3 to 0.41 and from 639.7 to 19.7, respectively. These results support the practical value of combining learned local prediction with geometric filtering.
Critical weaknesses
  1. The evaluation does not adequately distinguish geometric fidelity from mesh density or establish artistic mesh quality. Table 1 reports reconstruction metrics without output face counts or comparisons at matched mesh complexity, although MeshExpand explicitly controls resolution through input point density. The qualitative examples also raise the possibility that some improvements in geometric fidelity are obtained through denser triangulations. Without controlling for this factor, it is difficult to determine whether the gains reflect better mesh structure or a larger geometric approximation budget. This distinction is particularly important given the paper’s positioning as artistic mesh generation: low reconstruction error alone does not establish compactness, clean edge flow, or editability. The completion demonstrations and artist case study are useful, but do not resolve this ambiguity. Reporting quality–face-count trade-offs, together with topology-focused comparisons at comparable face counts, would better substantiate the claimed advantage for artistic mesh creation.
  2. The claims about artifact-free output exceed the demonstrated validity of the generated meshes. The conclusion states that geometric validation ensures artifact-free outputs. However, Table 2 reports an average of 0.41 self-intersecting faces and 19.7 open boundaries even on a subset whose reference meshes are watertight and self-intersection-free. These results demonstrate substantial defect reduction, but not artifact-free generation. Moreover, the paper does not report the fraction of completely valid outputs or separate measurements of vertex manifoldness and orientability. Since geometric validity is central to the proposed workflow, the remaining defects and the scope of the validation guarantees require clearer characterization.
Questions for authors
  1. Mesh density and artistic mesh quality Could you report the output face counts for the methods in Table 1 and clarify whether MeshExpand’s geometric advantages persist at comparable face counts? Some qualitative examples suggest that denser triangulations may contribute to the improved reconstruction fidelity. Given the paper’s emphasis on artistic meshes, what evidence demonstrates better compactness, edge flow, or editability beyond surface reconstruction accuracy? A comparison at matched face counts would help distinguish improved mesh structure from increased geometric resolution.
  2. Geometric validity and residual defects Table 2 reports residual self-intersections and open boundaries despite online geometric validation. Could you explain why these defects remain, particularly whether the generation-time and evaluation-time intersection checks use different tolerances or adjacency rules? Does the non-manifold check cover vertex manifoldness as well as edge manifoldness? If available, please report the fraction of outputs that are simultaneously manifold, watertight, and self-intersection-free on the closed-surface evaluation subset. This would clarify the practical reliability and scope of the validation mechanism.
2 comments

Q1: Face-budget-controlled Comparisons. We have added face-budget-controlled comparisons on Objaverse in Table 1. Our default setting uses a face budget (2.5k) comparable to the ground-truth (2.6k) and lower than most of the baselines. With a reduced budget of 1.7K faces(Ours-Low), MeshExpand still outperforms MeshAnything V2 and BPT under comparable budgets. These results demonstrate that MeshExpand's geometric advantages are not attributable to denser triangulations, but from more effective triangle placement and organization. To evaluate mesh structure beyond geometric accuracy, we introduce an edge-flow orthogonality metric in Table 1, along with additional topological metrics in Tables 2 and 4. These complementary evaluations provide evidence of comparable edge-flow and improved topological validity beyond surface reconstruction accuracy.

Q2: (1) Self-intersection. During inference, we use a self-implemented 1-to-N single-direction test, whereas the results in Table 2 are obtained using a bidirectional N-to-N intersection test. The small non-zero discrepancies are primarily attributed to floating-point numerical instability in our implementation, intersect(a,b)!=intersect(b,a). (2) Manifoldness. Our half-edge-based construction enforces edge manifoldness and consistent face orientations. Vertex manifoldness is not explicitly checked during generation for efficiency, but non-manifold vertices are easier to repair through vertex splitting. (3) Topological metrics. We report the percentages of orientable and watertight meshes, along with the average numbers of non-manifold vertices and edges in Table 2 and Table 4. MeshExpand achieves approximately 75% watertightness in mesh completion and 22% in mesh generation. Notably, 20% of MeshExpand outputs in generation are simultaneously manifold, watertight, and self-intersection-free, doubling DeepMesh's 10%. Among the remaining non-watertight meshes, MeshExpand significantly reduces the number of their boundary edges, indicating fewer and/or smaller holes and thus less manual effort for subsequent repair.

  • Artifact-Free. We agree that our original claim of "artifact-free outputs" was too strong and have revised it to emphasize substantial artifact reduction and improved mesh validity. As shown in Table 2, our construction guarantees edge manifoldness and orientability, and ensures self-intersection-free generation under an exact intersection test. In practice, numerical precision limitations may lead to minor residual intersections. Watertightness and vertex manifoldness are improved but not guaranteed.

Thank you for the response and the revision. The added face counts, the Ours-Low setting, the extended Table 2, and the revised conclusion address most of my concerns. In particular, MeshExpand outperforming baselines with 24k–32k faces on GSO+Trellis while using 12k–19k resolves the density question for geometric fidelity, and the scope of the validity guarantees is now clear.

A few points for the final version:

  1. On GSO+Trellis, θ is 16.9° versus 12.7° for Advancing Front, and degrades from 10.0° on Objaverse. This should be discussed, and the claims about artistic quality on out-of-distribution inputs scoped accordingly. Please also unify the units of θ in Tables 1 and 4.
  2. Ours-Low is worse than MeshAnything V2 and BPT on HD, so "outperforms" should be qualified.
  3. Please report the subset sizes for Tables 2 and 4, and state the 22% watertight / 20% fully valid rates as a limitation.

I am raising my rating to 3.

Reviewer_hhcUOpenReview ↗
Rating
2
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

MeshExpand generates triangular meshes from point clouds with normals and seed triangles. It grows the mesh one face at a time by selecting a boundary edge and predicting the opposite vertex, using a bounded local context together with a global shape prior. Unordered face features allow the same model to support different growth orders and partial mesh completion. The paper also introduces density-based resolution control and online geometric checks. Experiments cover Objaverse, GSO, and Trellis, with ablations and reported generation up to 120K faces using less than 2 GB of GPU memory.

Critical strengths
  1. Keeping the local context bounded could be a good way to reduce GPU memory as meshes get larger. The reported generation up to 120K faces with less than 2 GB of GPU memory is interesting (lines 407–412).

  2. I like that the same model supports different growth directions and can continue from partial meshes (Tables 3–4). This is useful for an artist who wants to keep an existing region and generate the rest. The density-control examples also offer a simple way to put more triangles where they are needed.

Critical weaknesses
  1. Lacks key citations and discussions: (1) MeshRipple [1] seems particularly close, since it also generates artist meshes by progressively expanding the existing mesh. I would like a clearer discussion of the technical differences and a comparison where feasible. (2) FACE [2] is also relevant to the face-level representation, though its encoder is not the same as the one here (lines 243–249). (3) MeshFIM [3] is relevant to the local completion and editing discussion (lines 453–458). For me, the main concern is whether MeshExpand brings a clear advance over closely related approaches, rather than the missing citations alone.

  2. The word of “order-agnostic” seems ambiguous to me. I initially expected a more general any-order AR method. Table 3 does show that one model supports several growth orders, but generation is still restricted to expanding existing boundaries. More importantly, I could not clearly understand how different growth fronts are joined or what topology restrictions this introduces (lines 199–210 and 268–280). These details matter for the claim of completion from arbitrary open boundaries.

  3. The qualitative visual results seem to be far less appealing compared with examples from QuadGPT [4], Tripo T1/T2, and Meshy SmartTopology (T2). I realize these are not matched comparisons. Still, the main metrics (lines 348–356) and the defect counts in Table 2 say relatively little about edge flow or triangle quality. A small comparison with matched inputs and comparable polygon budgets would help me judge the practical value other than geometric reconstruction.

References:

[1] Lin et al. “MeshRipple: Structured Autoregressive Generation of Artist-Meshes.” CVPR, 2026.

[2] Wang et al. “FACE: A Face-based Autoregressive Representation for High-Fidelity and Efficient Mesh Generation.” arXiv:2603.01515, 2026.

[3] Yang et al. “MeshFIM: Local Low-Poly Mesh Editing via Fill-in-the-Middle Autoregressive Generation.” arXiv:2605.08744, 2026.

[4] Liu et al. “QuadGPT: Native Quadrilateral Mesh Generation with Autoregressive Models.” ICLR, 2026.

Questions for authors
  1. Are there topology restrictions beyond the 2-manifold assumption? In particular, how are existing vertices reused when different growth fronts meet (lines 199–210 and 268–280)?

  2. How exactly is the next boundary edge selected in Algorithm 1? Line 775 only specifies pick(E).

  3. What is the end-to-end generation time for a 120K-face mesh, including geometric checks and resampling (lines 268–280 and 407–412)?

  4. Are the test-time seed triangles taken from the reference meshes? Lines 345–346 mention a seed for training and generation, while lines 471–475 explain that each connected component needs one.

  5. What is the main technical difference from MeshRipple [1] that accounts for MeshExpand’s advantages?

1 comment

Q1: Topology Restrictions. Beyond the 2-manifold edge constraint, we also explicitly reject detected self-intersections and degenerate triangles during generation. Non-manifold vertices are not explicitly checked for efficiency. As shown in the newly added Fig. 12 in the Appendix. When a predicted vertex coincides with an existing vertex, we reuse the existing vertex and connect the new triangle to it. This is feasible because our discretized vertex space allows exact vertex matches. New edges are merged with existing edges sharing the same vertex pair if the merging preserves edge manifoldness. Otherwise the vertices will be resampled. These operations are performed online with a half-edge structure, maintaining edge manifoldness and orientability throughout generation. Table 4 adds quantitative results on connecting partial meshes.

Q2: Next Boundary. We clarify that "order-agnostic" refers to the flexibility in selecting which existing boundary edge to expand, rather than unrestricted triangle generation at arbitrary locations. By default, we use DFS, selecting the most recently created boundary edge. Algorithm 1 omits this selection policy, for it can be freely changed at inference time. Table 3 shows that BFS, bottom-up, and top-down strategies achieve comparable performance, demonstrating flexibility across growth orders. Table 4 shows mesh competition results under different configurations.

Q3: Generation Time. MeshExpand achieves an average generation time of 0.036~0.056 s/face, including geometric verification and resampling. This is comparable to BPT (0.069 s/face), MeshAnything V2 (0.059 s/face), and DeepMesh (0.048 s/face). Since the original 120K-face generation did not record runtime statistics, we repeated the experiment and got a slightly larger mesh (~136K faces). The complete generation took approximately 1.3 hours. We provide a detailed runtime profiling in the Appendix, showing that neural network inference dominates the total cost(~78%), while data retrieval and geometric verification 22%. Q4: Seed. MeshExpand requires at least one seed triangle per connected component. Since disconnected components are split into separate meshes, we use one seed per mesh, sampled from the reference mesh.

Q5: MeshRipple. We have added MeshRipple, FACE, and MeshFIM to Related Work, focusing on the two most closely related methods: (1)Unlike MeshRipple's active-boundary attention, MeshExpand uses spatially localized context that includes both boundary, interior faces and faces from other components, providing geometric cues for gap filling and collision avoidance. More importantly, its unordered face representation and online topology updates enable flexible growth orders and completion within the same generation framework, with bounded memory. In practice, MeshRipple reports requiring approximately 50 GB for 100K faces, while MeshExpand uses about 2 GB. Quantitative results on Objaverse are also added to Table 1, while evaluations on GSO and Trellis are still in progress. (2) MeshFIM. MeshFIM formulates completion as an in-context prediction task by serializing context and missing regions, similar to code completion. However, its capabilities for large-scale completion, multi-hole filling, bridging, and full mesh generation remain unclear. In contrast, MeshExpand unifies mesh generation and completion within a single autoregressive framework, with bounded memory usage and improved topological quality.

  • Qualitative Comparisons. Commercial systems differ substantially in training data and computational budgets, making visual comparisons difficult to control. Our focus is scalable, low-memory mesh generation and flexible completion. We therefore provide matched-budget comparisons and additional structural metrics to evaluate these contributions.

  • Mesh Quality. We have added orientability, watertightness, and non-manifold vertex/edge statistics in Tables 2 and 4, along with edge-flow orthogonality in Table 1. These complementary metrics show substantial reductions in self-intersections and non-manifold defects, together with improved watertightness, while providing a more comprehensive assessment beyond geometric fidelity.

  • Face-budget Comparison. We have added face-budget-controlled comparisons in Table 1. Our default setting uses fewer faces than most baselines. At a reduced budget (Ours-Low), MeshExpand outperforms MeshAnything V2 and BPT at comparable face counts in Objaverse.

Reviewer_BfHTOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

MeshExpand formulates artistic mesh generation as learned local surface expansion. Starting from seed triangles, it repeatedly selects an open boundary edge and predicts the opposite vertex using nearby faces, local point samples, and a global shape prior. Its unordered local representation allows the same model to operate under different growth orders and supports completion from partial meshes. Density-aware training provides control over mesh resolution, while online geometric validation rejects invalid candidate triangles. The paper reports generation of meshes with up to 120K faces using less than 2 GB of GPU memory, together with improved geometric fidelity, orientation consistency, and generalization on the evaluated datasets.

Critical strengths

The ability to generate high-resolution meshes with a small, bounded predictor context is the strongest contribution. Rather than extending a global token sequence, MeshExpand repeatedly solves a local geometric prediction problem. Generating up to 120K faces with reported GPU memory below 2 GB makes this formulation practically interesting. Although high face counts have also been demonstrated by patch-based methods, achieving this scale through direct surface growth without predefined patch decomposition is a meaningful contribution and the main reason for my positive recommendation.

The local formulation offers useful flexibility for mesh completion. Conditioning on an unordered spatial neighborhood allows the same model to grow from different boundaries and under different traversal strategies. This provides a plausible foundation for artist-guided completion and local editing. The reported experiments across growth orders, together with the improvement in orientation consistency from MAE pretraining, provide initial evidence that this flexibility is supported by the learned model.

Critical weaknesses

The experimental coverage is not yet sufficient to establish the breadth and reliability of the proposed local generation framework. The paper evaluates different traversal orders, MAE pretraining, and geometric validation, but several important architectural and operational choices remain insufficiently examined. These include the adaptive window, local context limits, global shape conditioning, candidate sampling budget, and density-guided resolution control. More importantly, the completion experiments do not systematically cover the configurations naturally suggested by the method: multiple seed triangles or separate seed patches within one connected surface, simultaneous filling of several holes with different sizes and spatial arrangements, and growth from seeds belonging to multiple disconnected components. These cases can expose collisions between growing fronts, inconsistent connections, premature termination, and incomplete coverage. Their absence limits confidence in the claimed generality of arbitrary-boundary completion.

The scalability evaluation and comparison with closely related methods should be more complete. The reported 120K-face examples and low GPU memory usage are compelling, but the memory plot covers a much smaller face-count range, and complete generation times are not reported. Local prediction bounds the model context, while neighborhood retrieval, geometric validation, resampling, and mesh storage may still become costly as the output grows. Furthermore, MeshMosaic should be cited and compared: it also uses local generation with boundary conditioning and has demonstrated meshes exceeding 100K faces. A matched comparison would clarify the benefits of direct face expansion over boundary-conditioned patch generation, particularly in memory, runtime, topology, and completion flexibility. The related-work discussion is also incomplete and should include MeshMosaic, MeshFlow, Meshy T2, and Strips as Tokens. MeshMosaic is particularly relevant because it already uses boundary-conditioned local generation and demonstrates meshes exceeding 100K faces. The other methods also provide important context for native mesh generation, efficiency, and structured outputs. The authors should clarify the differences in generation granularity, conditioning inputs, output structure, and scalability, rather than broadly characterizing existing approaches as global prediction.

Questions for authors
  1. How robust is generation when several seed triangles or seed patches are placed on the same connected surface? How are collisions and connections between independently growing fronts handled?
  2. Can the model simultaneously fill multiple holes of different sizes and handle multiple disconnected components? Please report completion success, remaining boundaries, self-intersections, and preservation of the supplied geometry across these configurations.
  3. How sensitive are the results to local window size, context limits, global conditioning, and candidate sampling budget? In particular, how much quality and computational cost come from the predictor versus geometric validation and resampling?
  4. What are the full generation time, peak GPU memory, and CPU memory at increasing face counts up to 120K? A comparison with MeshMosaic under comparable output budgets would help establish the practical scalability advantage.
2 comments

Q1: Bridging. During MAE pretraining, the model predicts triangles under random face configurations. During subsequent training, we retain 10% of future triangles rather than masking them entirely. These strategies expose the model to triangles on the opposite side of the current growth direction, teaching it to bridge gaps between independently growing fronts. At inference time, the local 3D window captures nearby triangles from opposing fronts and provides them as context. When the fronts meet, coincident vertices are reused and matching edges are merged if edge manifoldness is preserved; otherwise, the candidate triangle is rejected and resampled. This allows MeshExpand to connect the fronts while minimizing self-intersections and preserving edge manifoldness. We added Fig.12 in the appendix to detail this merging process. Examples of successfully connected components are also shown in the second and third columns of the last row of Fig. 1.

Q2: (1) Topological Metrics. We add watertightness, self-intersection, remaining boundary edge in Table 2 and 4. MeshExpand achieves avg. 74% watertightness in completion. Worth to notice the input geometry is completely preserved, and only open boundaries are expanded. (2) Multiple components. We introduce a completion experiment by removing the middle one-third of each mesh and asking MeshExpand to bridge the upper and lower parts. As shown in Table 4, MeshExpand achieves 83% watertightness, with only 1.05 boundary edges on average, indicating relatively small residual hole. (3) Multiple holes. Creating valid holes manually is time-comsuming. We therefor adopt a similar setup to evaluate multi-hole completion. Retaining the middle one-third of mesh creates at least two open boundaries corresponding to the upper and lower part. MeshExpand successfully closes both boundaries, achieving 68% watertightness (Table 4).

Q3: (1) Ablation. We ablate the local window size, context limit and global conditioning in Table 3. Global conditioning provides important information for generation. Reducing the window size or context limit slightly decreases completeness. Reducing the sampling budget to 1 creates more open boundaries and reduces watertightness. Quantitative result for resolution control is added to Table 1(Ours-Low). (2) Runtime Breakdown. We provide a detailed runtime profiling in the appendix. The profiling shows that neighborhood retrieval and geometric validation collectively account for only approximately 22% of the total runtime, while the majority of the computational cost remains attributable to neural network inference. Batched sampling introduces only 2% runtime overhead.

Q4: Profiling. MeshExpand achieves an average generation time of 0.036–0.058 s/face, comparable to BPT (0.069 s/face), MeshAnything V2 (0.059 s/face), and DeepMesh (0.048 s/face). Since runtime and CPU memory were not recorded for the original 120K-face mesh, we repeated the experiment and got a slightly larger mesh (~136K faces). This run took approximately 1.3 hours, with peak GPU and CPU memory usage of 1.9 GB and 2.5 GB. We also collected additional statistics at large face counts and extended the memory plot in Fig. 4 accordingly.

  • MeshMosaic. We thank the reviewer for pointing out this related work. We have added MeshMosaic and others to Related Work. Experimental results for MeshMosaic are also added. Both MeshMosaic and MeshExpand use boundary-awarded local generation but differ in granularity. MeshMosaic generates semantic patches sequentially and assembles them through boundary alignment and displacement compensation. In contrast, MeshExpand directly expands existing boundaries face by face, with online topology check. This eliminates the need for semantic patch decomposition, mesh stitching or a predefined patch order, enabling flexible completion, local editing, and improving topological correctness, offering a different form of scalability. We have also added MeshMosaic to Table 1 and 2. The results show that MeshExpand outperforms MeshMosaic in geometry and topology while using only half face count.
Reviewer_BfHTOpenReview ↗

Read

Thanks for addressing my concerns,

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.