acceptodds
Under review as a conference paper at ICLR 2027

LoomMesh: Feed-forward Meshsplatting

Abstract

3D Gaussian Splatting methods enable efficient optimisation and rendering, but are not natively supported by widely used, highly optimised mesh-based graph- ics engines (e.g., Unity, Blender). To exploit these engines, mesh-based neural rendering with triangle primitives has recently emerged, yet it typically relies on per-scene optimisation over many posed views, making it slow and hard to scale. We study feed-forward mesh splatting: creating a mesh directly from a single pair of posed images in one forward pass. This is challenging due to (1) sparse obser- vations and (2) the need to jointly infer vertex positions (i.e., geometry) and their connectivity (i.e., surface). To this end, we propose LoomMesh, which unpro- jects every pixel of each view to a 3D vertex carrying geometry and appearance features. We then connect the vertices in a candidate graph, linking each vertex to its same-view neighbours by pixel location and to its cross-view neighbours by geometric reprojection. To learn vertex geometry and connectivity jointly, we introduce a topology reasoning operator that, shared across all vertices, refines each vertex’s depth and decides which candidate faces to keep, passing evidence between neighbours along surfaces but not across their boundaries. The resulting mesh is rendered differentiably, so LoomMesh is trained end to end and needs no ground-truth meshes. Extensive experiments show that LoomMesh outperforms per-scene optimised methods in both visual fidelity and inference cost, as well as alternatives that combine feed-forward reconstruction with mesh conversion.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
feed-forward 3D reconstruction, sparse-view reconstruction, mesh reconstruction, novel view synthesis, differentiable rendering

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_MNDpOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

LoomMesh reconstructs a textured triangle mesh from two posed images in a single forward pass, trained end-to-end from images only. Each pixel of a DepthSplat-style feature is unprojected to a 3D vertex with SH color; a candidate graph links pixel neighbors and cross-view reprojection neighbors. A topology reasoning operator runs a gated GRU exchange over the graph: each edge carries a conductance combining a coplanarity evidence term with a learned vote. Face opacity is the minimum conductance of its three edges. The same conductance weights message passing and makes faces differentiably deletable by the photometric loss; inference binarizes opacities so the exported mesh is what was rendered. The paper claims this is the first "feed-forward mesh splatting" method, demonstrates SOTA mesh-rendered NVS on RealEstate10K/DL3DV versus TSDF-meshed feed-forward Gaussian baselines and per-scene MeshSplatting, and ablates the operator.

Critical strengths
  1. Joint depth–connectivity reasoning is well motivated and ablated. App. B.1 precisely explains why naive end-to-end mesh training stalls, and Fig. 5 shows the matcher stays trainable only with the operator. Table 3 (a) 19.29 → (g) 22.09 dB isolates its value at 0.03% extra parameters. This is the paper's most convincing, reusable contribution.

  2. What is trained is what is exported. The renderer (analytic ray–triangle hits with exact per-ray ordering; soft band outside the triangle, no annealing schedule unlike 2DTS/MeshSplatting) makes the exported mesh identical to the rendered one. The Blender/Bullet demo is a concrete mini-deployment check. Measured efficiency is large: best mesh-rendered NVS (22.22 dB @ 256² RE10K; 18.92 dB zero-shot DL3DV) with ≈15–27× fewer vertices than the TSDF-meshed baselines (Tables 1–2). This advantage over TSDF-converted baselines is well established; its distinctiveness relative to other native-mesh feed-forward models remains to be shown (see Weakness 1).

Critical weaknesses
  1. The "first feed-forward mesh splatting" claim is contradicted by existing public work. The paper frames its problem definition as its contribution ("a novel, more promising 3D reasoning problem"; "the very first solution"). Public work already exists: TriSplat (arXiv:2605.26115, May 2026; code and checkpoints released) — a feed-forward network whose native representation is oriented triangle primitives, directly exporting simulation-ready meshes with no intermediate extraction, trained/evaluated on the same RealEstate10K + DL3DV — and FTSplat (arXiv:2603.05932, Mar 2026) — feed-forward prediction of continuous triangle surfaces from calibrated views, no per-scene optimization or post-processing. Both predate the ICLR 2027 submission window and are uncited. TriSplat is also the stricter counterexample: it works in the more general unposed setting (camera poses are predicted jointly rather than given), and it makes the same argument the paper uses for its export-fidelity advantage — Gaussian baselines lose quality under lossy TSDF fusion, while a native-mesh model does not — so that advantage is not unique to LoomMesh either. What remains novel is narrower than claimed: learned, shared-vertex connectivity (gated faces) versus their point-map + normal-anchored triangles with export-time vertex merging — an incremental mechanism on an existing problem, so the vertex-for-Gaussian swap and pixel-adjacency prior (range-image meshing, Turk & Levoy 1994) cannot carry the framing the abstract and contributions rest on.

  2. Every baseline number in Tables 1–2 is TSDF-degraded; the baselines' actual quality is absent. All Gaussian competitors are evaluated solely after depth-TSDF fusion + marching cubes (DepthSplat 16.13 dB, MVSplat 16.44, MeshSplat 16.55 on RE10K), whereas their original published two-view Gaussian rendering on RE10K is far higher: MVSplat 26.39 dB, DepthSplat 27.44 dB — levels comparable to or above LoomMesh's own mesh-rendered 22.22 dB (not a direct comparison: different test subset and mesh-vs-splat rendering, which is exactly why a reference column is needed). The "all methods evaluated as meshes" protocol is internally consistent, but "outperforms Gaussian-based methods in visual fidelity" is not inspectable without each baseline's original splatting-quality number beside the meshed one — especially since the paper itself criticizes TSDF conversion as a lossy separate step whose output is not what the network rendered. The per-scene MeshSplatting baseline is likewise taken outside its many-view operating regime and granted only two views.

  3. The coplanarity gate caps representable protruding (convex) geometric detail. Eq. 5 cannot distinguish a depth discontinuity from a sharply raised detail: with the learned vote at initialization g_e = 0, any edge whose endpoints exceed each other's tangent plane by more than ρ* = 4 resolvable units is cut as a "boundary" — so small bumps are flattened by default. The gate therefore faces a dilemma between boundary identification and geometric detail: the only escape, the learned tolerance widening (up to ≈218 units), conversely keeps spurious faces across true boundaries (the App. B.1 failure mode). No experiment probes protruding/high-frequency geometric detail, and App. D's limitation list (image-grid mesh growth, occluded regions) does not mention this dilemma.

Questions for authors
  1. Given TriSplat (arXiv:2605.26115) and FTSplat (arXiv:2603.05932), please (a) justify the "first"/"new problem" claims or withdraw them, and (b) provide a quantitative head-to-head with TriSplat under matched settings on RE10K/DL3DV — since TriSplat already claims the same TSDF-degradation argument used for your export-fidelity advantage, only a matched comparison can establish what learned gated connectivity adds over native triangle primitives.

  2. Please add each Gaussian baseline's original (pre-TSDF) NVS numbers as a reference column in Tables 1–2, so the mesh-vs-original trade-off each method makes is visible.

  3. With g_e forced to 0 (pure geometric gate), what fraction of edges at sharp convex details (e.g., a small bump spanning a few pixels) is cut? A small probe would pin the representation ceiling that Weakness 3 asserts.

  4. For the baselines with different backbones (3DGS, 2DGS, MVSplat), how much of the geometry-metric gain comes from the coupled Depth Anything V2/V3 + DINOv2 priors rather than the mesh formulation (e.g., weaker-backbone ablation, or evaluation on a GT-mesh dataset such as DTU/ScanNet)? I recognize the DepthSplat comparison is backbone-matched and already controls for this factor.

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

The paper introduces LoomMesh, a feed-forward approach that reconstructs a mesh given two images as input. The entire operation is executed as a forward pass by the network, unlike current approach that require a separate post-processing step to obtain the mesh, typically by applying TSDF fusion on the rendered depth maps. An important aspect of LoomMesh is that it does not require ground truth depth or normals as supervision. Experimental validation is well designed.

Critical strengths

The key idea of the paper, that a mesh can be directly predicted in feed-forward fashion from two images, is a strength. This is accomplished by placing two triangles in each square formed by pixels in each input image, creating a predictable structure in which the edges can be enumerated and appropriate variables can be assigned to each edge. The network can then predict which edges should be retained in the final model. To infer the final mesh the two per-view meshes are connected by projecting vertices from one view to the other and using them to create new triangles with vertices from both views.

The experiments are well designed and performed on widely used datasets against diverse, competitive baselines. LoomMesh outperforms the baselines without test-time optimization, which is claimed as one of the strengths of the method. The videos in the supplement are convincing by showing the output of LoomMesh used directly in physics simulations.

Critical weaknesses

LoomMesh can only be applied on two views due to the way the two partial, per-view meshes are connected. This is implemented by projecting vertices from one view to the other and inserting them as vertices in the triangles they intersect. This is a 2.5-D algorithm that is not straightforward to extend to be applicable to more views. This by itself is not grounds for rejection since there are no other similar methods, but the limitation should have been stated clearly.

The loss, and in particular the lack of intuition behind it, is a weakness of the paper. My comments are based on Section 3, where the loss is shown in Eq. (13), and Appendix A.

The LPIPS term is very unusual; I do not believe I have seen it in hundreds of radiance field papers. Even though the term is differentiable, it is multi-scale and entangles large numbers of pixels and triangles. It is unclear to me how effective backpropagation through the layers of the LPIPS network is. If this term is indeed more effective than the most common SSIM loss, some analysis is needed.

The LgmL_{gm} term penalizes the ratio of D to A. D stands for depth, while A is coverage which according to Eq. (12) is equal to 1−Tk+11-T_{k+1} where T is transmittance. Line 292 mentions depth and coverage errors. I do not understand how coverage errors can be defined. Based on the text of Section 3 and the results, every pixel should be “covered” and there is no for of supervision on opacity. What is a coverage error? Why does it make sense to formulate a loss using the D/A ratio? The explanation of the term does not help at all: “LgmL_{gm} is blind to global scale and responds mainly to edges the mesh has missed or invented, so absolute depth stays with the cost volume and the photometric loss.”

Finally, I am missing the intuition about when edges, and as a result, faces are removed. Is loss computed on pixels that are not covered by the rendering of the mesh? If it is, it is unclear how to compute the various terms of the loss. If it is not, wouldn’t the network prefer to suppress all/most of the triangles to reduce the loss?

A second important weakness is that the technical descriptions suffer from major flaws. Terms are used without definition or consistency, while important steps of the algorithm are not described with sufficient detail and precision. The large number of such errors raises concerns about the validity of the method and findings. The list below is not exhaustive, but contains the most important of these issues.

Arguably, the term that is used most inconsistently is topology, followed by operator. Despite its title, Section 3.3 does not discuss topology and does not present an operator. It presents a sequence of steps that I would call an algorithm, but not an operator. The algorithm is complicated and the various steps are not described clearly. The section starts with a motivation paragraph whose first sentence is “Trained end to end, feed-forward Gaussian models keep refining their depth, because a Gaussian renders acceptably wherever its depth places it.” According to standard terminology, trained feed-forward Gaussian models generate a representation of the scene in a single pass. I cannot interpret the second part of the sentence.

Other inconsistencies include:

Lines 65-66: “A circularity stalls end-to-end training when we infer one from a moving estimate of the other.” I cannot parse this either.

Lines 71-72: “Each edge carries a conductance that compares its coplanarity residual with a tolerance shifted by a learned vote, and a face is as opaque as its weakest edge.” The term vote is used several times, but I have not been able to find a definition for it. I am also having difficulty with the term “learned vote.” Renaming this concept would probably be helpful.

Line 237: “Each edge reads the vote of its gate (equation 6) from the states at both ends,”

Line 215: “Topology improvement stalls early and the matching posterior saturates.” It is unclear what a topology improvement is. I guess removing a triangle that is almost parallel to rays and connects different surfaces would result in a topology change and an improvement in novel view synthesis. Still, the text is very imprecise as written.

Lines 220-22: “The state gathers three kinds of evidence: the vertex’s own matching evidence EiE_i, messages MiM_i from vertex’s neighbours, and its own inputs xix_i.” xix_i is defined later, but the description is very confusing.

Lambda is overloaded unnecessarily: it represents barycentric coordinates, edge lengths, term weights in Eq. (13). Lower-case c is also overloaded.

Line 297: “In the feed-forward setting the scene changes at every step.” This cannot be true since there is only one step.

Line 347: The L1 error between normals is meaningless compared to the cosine similarity that is also reported.

Questions for authors

I would like to see a detailed response to my comments on the loss. Having said that, in my opinion, the flaws in the presentation are too many to be corrected within the review process, which is why I recommend rejection.

I also suggest the following two references, which I consider relevant. It should be noted that LoomMesh is clearly different from these papers and this is a suggestion, not a major weakness.

W Wang, Z Li, J Shi, Z Zhang, B Ye, M Pollefeys, DY Chen, B Zhuang. Trisplat: Simulation-ready feed-forward 3d scene reconstruction. arxiv 2026.

Dai et al. SurfelSplat: Learning Efficient and Generalizable Gaussian Surfel Representations for Sparse-View Surface Reconstruction. NeurIPS 2025.

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

The paper introduces LoomMesh, which predicts an explicit, textured triangle mesh from two posed images in a single forward pass, with no per-scene optimisation and no separate surface extraction.

LoomMesh builds on DepthSplat and turns every pixel of each view into a vertex with spherical-harmonic colour. Each vertex is linked to its image-grid neighbours (two triangles per pixel quad) and, by reprojection at the current depth, to at most eight cross-view neighbours. Candidate faces are the 3-cliques of this graph. Each edge has a conductance. A face's opacity is the minimum conductance of its edges. One GRU-based gated message-passing step on the coarse grid, which also reads the matching log-posterior around the current depth (as in RAFT). It outputs a bounded depth step and the edge votes. A differentiable ray–triangle renderer with a soft band outside each triangle enables end-to-end training with photometric, normal, gradient-matching and warp losses. At test time opacities are binarised, so the rendered mesh is the exported one. Extensive experiments have demonstrate the effectiveness of the proposed method.

Critical strengths

It is a new, well-posed problem with a coherent end-to-end design. LoopMesh is a novel scene-level feed-forward method whose output is the rendered mesh itself. MeshSplat, by contrast, renders Gaussians and extracts its mesh separately by TSDF fusion. In LoomMesh, binarising αf\alpha_f and setting σ\sigma = 0 at test time makes the evaluated rendering identical to the exported mesh.

The components are motivated rather than ad hoc:

  • the gate normalises the coplanarity residual by the cost volume's depth resolution;
  • the votes are zero-initialised, so training starts from pure geometry;
  • Fig. 5 diagnoses a specific failure: with fixed connectivity, the matching posterior saturates within ~1k steps and the soft-argmax stops passing gradient to the matcher. The RAFT-style lookup fixes it.

Tab. 3 supports this design. Removing the operator drops PSNR from 22.09 to 19.29 dB; depth refinement accounts for most of this (19.33 dB without it), and connectivity refinement and gating add a further 0.9 and 0.7 dB and lower the normal error, all from a 0.11M-parameter module. This is the main reason I see value in the paper.

Critical weaknesses

W1. The baselines and conversion protocol inflate the margins, and the simplest baseline is missing.

  • Conversion. Every Gaussian baseline is meshed by TSDF fusion (MeshSplat's protocol, one shared setting), keeping only the 50 largest components. On DL3DV they reach only 9.5–9.9 dB, and Figs. 4 and 7 show large holes rendered white. The PSNR gap thus likely reflects coverage lost in conversion more than reconstruction quality.
  • Missing baseline. The obvious baseline meshes DepthSplat's per-pixel depth directly with a discontinuity threshold (range-image meshing, which the paper cites). Tab. 3(a), without the operator, already reaches 19.29 dB, 2.7 dB above every baseline in Tab. 1. About half of the 5.7 dB gain may thus come from per-pixel meshing, not from the operator.
  • Scale and cost. Each dataset has only 20 test scenes, with no variance. The abstract claims lower inference cost, but no timing or memory is reported.

W2. No ground-truth geometry or mesh-quality evaluation.

  • Normal metric only. Geometry is scored only against Metric3D-v2 monocular normals, on pixels where both normals are valid. This ignores position errors and excludes the baselines' holes. LoomMesh is trained against normals from Depth Anything 3 depth and a teacher depth (App. A, contradicting Sec. 3.5's "no depth or normal labels"), so the metric partly rewards agreement with a similar prior. There is no depth error or Chamfer distance against ground truth.
  • Mesh quality unassessed. Vertex counts equal 2HW exactly (131K, 229K), so "fewer vertices" follows from resolution, not efficiency. Face counts (265K; 655K) reach or exceed the grid-face totals (~260K; ~456K), suggesting a double-layered overlap region. Manifoldness, self-intersections and components are not reported, so "engine-ready" rests on one demo.
Questions for authors
  1. Which losses use Depth Anything 3 outputs? Is the teacher depth z_T in L_gm (Eq. 14) also from DA3? Please reconcile this with Sec. 3.5's claim that no depth or normal labels are used.
  2. Why does the full model differ (22.22 vs. 22.09 dB in Tab. 1 vs. Tab. 3)? Are the ablations trained for 100k iterations, and with how many seeds?
  3. Face counts (265K; 655K) are close to or above the number of grid faces (~260K; ~456K). Are overlapping regions covered by both views' surfaces? How many connected components, non-manifold edges and self-intersections does a typical exported mesh have?
  4. Were the TSDF voxel size, truncation and depth range tuned for each baseline? What is baseline PSNR when the Gaussians themselves are rendered (before meshing)? This would separate reconstruction quality from conversion loss.
  5. What are the runtime and memory per scene for LoomMesh and for the baselines?
Reviewer_6x4uOpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

This paper targets feed-forward mesh reconstruction from two posed images. LoomMesh builds on the DepthSplat backbone, lifts every pixel of both views to a vertex, and links vertices through image-grid and cross-view candidate edges. A geometric coplanarity gate plus a learned vote decides which faces are kept, and a small shared operator (a GRU with conductance-gated message passing and a RAFT-style lookup into the matching posterior) refines depth and predicts the votes. The mesh is trained end to end through a differentiable triangle renderer. On 20 RealEstate10K scenes, mesh renderings reach 22.22 dB PSNR versus 16.55 dB for MeshSplat; on 20 DL3DV scenes (zero-shot), 18.92 dB versus 9.5–9.9 dB for Gaussian baselines meshed by TSDF fusion.

Critical strengths
  • The goal is practical: the network outputs the exported mesh itself, and the same mesh is rendered during training, so no separate surface-extraction step is needed.
  • The method is described in detail, and App. B.1 / Fig. 5 give a useful diagnosis of why end-to-end mesh training stalls.
Critical weaknesses
  1. The experiments do not isolate the contribution of the proposed method. All Gaussian baselines are converted to meshes by TSDF fusion of rendered depth (App. A, p.14); on DL3DV this leaves large regions empty (Figs. 4 and 7). LoomMesh is itself a per-pixel depth mesh, so the natural control is missing: a baseline's own per-pixel depth (e.g., DepthSplat, whose backbone LoomMesh uses), grid-triangulated with the same fixed gate (g_e = 0) and rendered with the same renderer. The paper's own ablation suggests that a large part of the margin does not come from the proposed operator: the variant without it reaches 19.29 dB (Table 3a), compared with 16.55 dB for MeshSplat (Table 1); learned connectivity alone adds 0.04 dB (Table 3b), and adds 0.92 dB on top of depth refinement (Table 3c vs. 3g).

  2. The main text misstates the supervision, and this confounds the geometry results. The paper says training uses images only and that "no depth, normal or topology labels are used" (pp. 2, 6). According to App. A (p.14), L_normal is supervised with normals computed from Depth Anything V3 depth, and L_gm compares rendered depth gradients with the same teacher depth, which signals where faces should be cut. Geometry is evaluated only against Metric3D-v2 pseudo-normals (p.7), another monocular prior, whereas MVSplat and DepthSplat receive no such supervision. Without an ablation of L_normal and L_gm, the normal-accuracy gains (e.g., cosine 0.895 vs. 0.745) cannot be attributed to the method.

  3. The evaluation is small and contains no real geometry. Each dataset has 20 scenes and a single run with no variance estimate. Geometry is measured only against pseudo-reference normals; there is no depth error or Chamfer/F-score on data with ground-truth geometry. The full model's results also differ between Table 1 (22.22 dB) and Table 3 (22.09 dB) without explanation.

  4. The novelty claims are overstated. The paper presents feed-forward mesh splatting as a novel problem with "the very first solution" (p.2), but closely related work is not discussed. Worldsheet (Hu et al., ICCV 2021) predicts a mesh sheet feed-forward from a single image and trains it on RealEstate10K through differentiable mesh rendering without 3D supervision. 3D Photography (Shih et al., CVPR 2020) meshes a depth image and cuts it at depth discontinuities. MeshLRM and InstantMesh predict object-level meshes feed-forward with mesh-rendering losses. Range-image meshing (Turk & Levoy, 1994) is cited but not used as a baseline. Relative to this work, the new element is a learned correction to the edge-cutting rule together with cross-view faces, and point 1 suggests its measured effect is limited.

Questions for authors
  1. Does Table 3 use the same 20 scenes as Table 1? Why do the full-model numbers differ?
  2. Since Depth Anything V3 already supervises training, how does LoomMesh compare with the teacher itself: DA3 run on the two posed input views, grid-triangulated with the fixed gate?
  3. What is the per-scene TSDF scaling rule on DL3DV? Could you report a coverage metric for all methods? Normal metrics are computed only where both normals are valid (p.14), so holes do not affect them but dominate PSNR. Fig. 7 also suggests that LoomMesh meshes the sky as a surface; how is the sky handled?
  4. Without the operator, the matching posterior collapses within about 1k steps (Fig. 5). Would a no-operator variant initialised from pretrained DepthSplat separate topology reasoning from simply restoring matcher gradients?
  5. The abstract claims lower inference cost, but no runtime is reported. Could you report end-to-end time and peak memory, including the TSDF step for the baselines?
  6. In App. B.3, k_e = σ((η_e − g_e)/τ) puts the switch point at ρ* e^{−g_e}, but the text gives ρ* e^{−τ g_e} and the range [0.07, 218]. Which form does the implementation use?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.