acceptodds
Under review as a conference paper at ICLR 2027

MeshSplatBench: A Unified Benchmark for Triangle- and Mesh-Based Neural Rendering

Abstract

Triangle- and mesh-based neural rendering aims to bridge neural scene representations and existing graphics engines (e.g., Unity, Blender) by leveraging triangle primitives compatible with standard rasterization hardware. There have been several such methods driven by parallel efforts, developed and evaluated under inconsistent settings, with little or no comparison with each other; critically, most even have never used graphics engines for evaluation nor considered deployability in practice – significantly undermining the objective and motivation. To address these issues, we introduce MeshSplatBench, the very first benchmark of its kind that enables both systematic evaluation of graphics engine based deployment and Non-Engine Render evaluation for triangle- and mesh-based neural rendering methods. Importantly, a deployment protocol with two rendering options is introduced: (1) Standard deployment – a conventional opaque mesh pipeline with vertex colors and hardware Z-buffering; (2) Dedicated deployment – adding method-specific engine implementations supporting the retained appearance and compositing features (e.g., alpha blending), so that the characteristics of each specific model can be taken into account. For mesh splatting, we further propose a structural audit of exported surfaces, diagnosing topological and geometric integrity toward downstream graphics assets. We highlight several results: (1) Graphics engine deployment would incur image-quality degradation under both deployment options. Among all methods tested, mesh splatting methods degrade the least under standard deployment. (2) The way of deployment matters – dedicated deployment can keep the majority of fidelity at about 630 slowdown. (3) About mesh splatting, the current approaches to explicit connectivity and shared indexing are still limited: shared vertex indexing alone does not ensure manifoldness or global connectivity. From this benchmark, we validate that rasterizability is merely part of graphics readiness, and highlight the significance of assessing the graphics engine deployment process (e.g., the degree of engine compatibility). Source code will be released.

Primary area:
datasets and benchmarks
Keywords:
neural rendering, novel view synthesis, triangle-based rendering, computer graphics, benchmark

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_jLibOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This submission describes MeshSplatBench, a benchmark that explores how triangle and mesh-based scene representations actually perform inside a real graphics engine. The motivation behind this effort is that these methods are pitched as "game-engine ready" since they use triangle primitives that are theoretically compatible with standard rasterization but have actually never been tested inside an engine under a unified evaluation protocol.

Concretely, 2DTS, Triangle-Splatting, MeshSplatting, and DiffSoup are rendered and evaluated across three different modes. Each method is evaluated under a "non-engine render" mode which just uses the method's native renderer outside of the graphics engine (the authors treat this as an "upper bound" on quality), a "standard deployment" mode that treats method outputs as a plain opaque mesh with vertex colors within the engine (no opacity, no view-dependent color, etc), and a "dedicated deployment" mode where the submission authors re-implement custom Unity renderers for each method's features (this is the main engineering contribution of the paper). The authors do an additional mesh structure audit measuring vertex reuse, manifoldness, and global connectivity on MeshSplatting only.

The methods are evaluated across these deployment modes on Mip-NeRF 360 and Tanks and Temples (the authors exclude DiffSoup from standard mode because of its neural feature decoder) along with 3DGS/2DGS in non-engine mode and 2DGS in standard mode. DTU and NeRF-Synthetic are also evaluated in the non-engine render setting. When evaluated in the non-engine render setting, the authors reproduce the published numbers within 0.075 dB PSNR on average, and no method consistently dominates across quality and speed. MeshSplatting does best in the standard deployment setting (since it's trained to use opaque triangles as opposed to soft, semi-transparent primitives like 2DTS and Triangle-Splatting). 2DTS/Triangle-Splatting are narrowly best in dedicated rendering mode, although their PSNR drops 4-5 dB compared to non-engine rendering. Overall the dedicated rendering mode gives visually better results than the standard mode but the authors report 6-30x slower rendering speeds. The mesh structural analysis performed on MeshSplatting finds that its meshes look regular but aren't very clean (18% of edges and 65% of vertices are non-manifold, which would make remeshing/UV mapping/etc difficult, and scene splits into 710k disconnected pieces on average).

Critical strengths

I think the big value of this paper is flagging that currently a lot of methods that claim compatibility with graphics engines should actually be tested within a more realistic deployment framework. To that end, developing a standard benchmarking protocol is a valuable contribution to the field. At a high level, asking "how well do these methods perform with/without custom shaders" makes a lot of sense. This would be the main thing that would convince me to advocate accepting the paper.

As a secondary contribution, the dedicated deployment implementations of the baselines are potentially useful if released and upstreamed into the relevant repositories.

Critical weaknesses

My main concerns around this submission revolve around the soundness and usefulness of the evaluation protocol (I initially rated soundness as 2 but feel it's close to 1). As currently designed the "standard deployment" mode doesn't feel very informative or useful - 2DTS/Triangle-Splatting being worse than MeshSplatting is not surprising considering they use semi-transparent triangles by default and the latter doesn't. The protocol for that mode feels overall arbitrary - why exclude DiffSoup and not bake its neural features into color when 2DGS is already going through similar baking + TSDF meshing? A more useful set of evaluation modes would be: (a) adapting the methods as much as possible to render well without custom shaders and (b) writing custom shaders that best render the methods (the current "dedicated deployment" protocol). To compound my concerns, Triangle Splatting's official repo has a "train_game_engine.py" mode (which prunes low-opacity triangles and adds a loss that increases opacity) that this submission doesn't seem to use. 2DTS has a similar opaque mode. Triangle Splatting+ [1] (a preprint and thus technically not required to cite/compare against) in fact evaluates Triangle Splatting in game-engine mode and reports 21.05 dB PSNR on Mip-NeRF 360 instead of this paper's 14.77 dB finding.

Since the dedicated deployment mode relies on the submission authors' implementations (which I could not find in the supplement), it is also difficult to interpret these results and why there is such a quality drop from the non-engine render mode. It is critical for the authors to provide a convincing analysis as to why this is the case before I would be comfortable recommending acceptance.

Other soundness issues include:

  • The 2DGS results look suspiciously bad in Table 4 - and no explanation/visuals are provided (Triangle Splatting+ reports 15.36 dB on M360 for 2DGS-derived meshes)
  • The FPS timings in Table 4 and Table 6 are inconsistent - all of the Table 4 entries roughly match 1000 divided by the median GPU time in Table 6 except for Triangle-Splatting under the dedicated deployment protocol (Table 4 lists it at 70FPS while Table 6 implies 263). Sec 4.2 suggests that the latter includes CPU sorting overhead but it would then be unclear to list the other methods' GPU-only timings.

These issues are compounded by the fact that several closely related works are missing, most notably MILo [2], which proposes a mesh-based NVS formulation that scores a reconstruction by rendering its opaque mesh (essentially this submission's standard deployment mode), and nvdiffrec [3], which optimizes triangle meshes and materials end-to-end for use in standard graphics engines. Other established 3DGS/NeRF-to-mesh pipelines, such as Gaussian Opacity Fields [4] and Binary Opacity Grids [5], are also related, and including them would strengthen the analysis.

The writing of this paper is much more complicated than it needs to be to the extent that I look more negatively on the submission than I otherwise would (I am rating presentation as 2 because I think it's fixable). The core thesis of the paper (evaluate neural scene representations in a realistic deployment setting) is clean, but wording like "A three-dimensional audit protocol across visual, computational, and structural dimensions" (lines 245-247) and "Resolves the academic-to-engine impedance mismatch through five modular pillars" (Fig 4 caption) needlessly obscures the paper's message. There are many examples of this (Eq. 1 formalizing "export a checkpoint to a file", "Multi-modal audit" in Figure 1, "engine contract" in line 397, "tier-dependent losses in visual fidelity" in line 402). I would strongly encourage the authors to do a full pass of the paper, drop as much jargon as possible, and make sure the writing is as clean, concise, and legible as can be.

On a more minor note, the figures in the paper could be nicer (especially Figures 1 and 4 that are text-heavy diagrams) and I'd recommend the authors make them more aesthetically pleasing (such as a figure showing a scene rendered across all three modes) ahead of a potential camera-ready.

References:

  • [1] Jan Held et al. Triangle Splatting+: Differentiable Rendering with Opaque Triangles. arXiv 2025.
  • [2] Antoine Guédon et al. MILo: Mesh-In-the-Loop Gaussian Splatting for Detailed and Efficient Surface Reconstruction. SIGGRAPH Asia, 2025.
  • [3] Jacob Munkberg et al. Extracting Triangular 3D Models, Materials, and Lighting From Images. CVPR 2022.
  • [4] Zehao Yu et al. Gaussian Opacity Fields. SIGGRAPH Asia 2024.
  • [5] Christian Reiser et al. Binary Opacity Grids: Capturing Fine Geometric Detail for Mesh-Based View Synthesis. SIGGRAPH 2024.
Questions for authors

As mentioned in the weaknesses section, the paper needs to convincingly explain the rendering gap from non-engine to dedicated deployment and why their custom shader implementations are a credible measure of these methods.

The action that is otherwise most likely to move my rating upwards would be a more useful "standard deployment" evaluation where the authors make a fair effort to adapt these methods to standard rendering (bake DiffSoup textures, use the proper configrations for Triangle Splatting and 2DTS) and provide updated numbers and analysis.

Other questions:

  • Lines 295-297 implies that DiffSoup uses 4x downsampling whereas the methods use 2x and 4x downsample. If true, this suggests that the FPS measurements are not comparable across methods. Could the authors clarify?
  • Clarification on the Table 4 vs Table 6 discrepancy
  • Clarification on why 2DGS quality is so low
Reviewer_8ybaOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes a benchmark for triangle- and mesh-based neural rendering on reconstructed scenes. It evaluates the exported reconstructed scenes in Unity under standard and dedicated deployment, and compared to the reference rendering produced by the original rendering pipeline. The benchmark reveals the gap in rendering research and engineering deployment.

Critical strengths
  1. It asks a practical but often skipped question: whether "rasterizable" representations are actually usable in a graphics engine. The three-tier protocol is a clean way to measure this.
  2. There are some engineering effort behind setting up the whole benchmark and evaluations.
Critical weaknesses
  1. The Dedicated results mainly measure the authors' own Unity renderer. But it's unsure if the author's version is optimal in both quality and performance. The 'standard' deployment is also too trivial, excluding too much things that could easily be added back like opacity.
  2. The paper's argument is that "using triangle based representation != compatible with rendering engines". But there are actually plenty of well-engineered GS rendering deployments, like the addon developed by KIRI and the Blender's official 4DGS project. So there are deployable neural rendering methods, it's just that they are not triangle-based. This means that the paper's scope is limited to only refuting the ideas of triangle-based methods. Moreover, by finding the gap, the paper did not proposed a novel-enough solution/contribution to mitigate this gap, which make the paper's contribution more limited.
Questions for authors
  1. I would suggest expanding the evaluation pipeline to include GS-based rendering methods. Or try to propose a method to resolve the gap in triangle based rendering methods.
  2. The test scene are also limited, only Mip-NeRF 360 and Tanks and Temples are tested. I would expect test on more scenes.
  3. Another big issue in deploying in engines is that these representation are not full reflectance modeling (they have baked appearance as radiance, and does not support relighting), so relightable reconstructed scenes are also worth testing, and would make the paper stronger.
Reviewer_4mtnOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper presents MeshSplatBench, a unified benchmark for evaluating triangle- and mesh-based neural rendering methods, with a particular focus on their practical deployment in graphics engines. The benchmark standardizes non-engine evaluation across four representative methods (2DTS, Triangle-Splatting, MeshSplatting, and DiffSoup) and four datasets. It further introduces a unified asset translation layer and two Unity deployment protocols: Standard Deployment, which uses conventional opaque mesh rendering with baked vertex colors, and Dedicated Deployment, which employs method-specific shaders to preserve additional appearance and compositing features.

The authors evaluate rendering fidelity, computational efficiency, memory consumption, and geometric accuracy, alongside a structural topology audit for exported meshes. Experimental results reveal substantial fidelity degradation after engine deployment, with method rankings changing across rendering conditions. Dedicated Deployment generally preserves higher visual quality at increased computational cost, while MeshSplatting achieves the best fidelity under Standard Deployment. The topology analysis further reveals that shared vertex indexing does not necessarily guarantee manifoldness or global connectivity. Overall, the benchmark highlights the distinction between research-level rendering performance and practical graphics-engine deployability.

Critical strengths

1.The paper addresses a meaningful gap between neural rendering performance in research environments and practical graphics-engine deployment. Its unified evaluation framework considers visual fidelity, runtime efficiency, and deployment compatibility, offering a useful perspective beyond conventional novel-view synthesis benchmarks.

2.The authors integrate four representative methods across multiple datasets, reproduce published baselines with reasonable accuracy, and provide detailed deployment measurements. The additional topology analysis highlights the distinction between visual rendering quality and mesh structural integrity. These efforts provide a potentially valuable foundation for future research on deployable neural representations.

Critical weaknesses

There's Insufficient validation of the deployment benchmark's scientific validity. The proposed benchmark aims to characterize the gap between research renderers and graphics-engine deployment. However, the dedicated engine implementations explicitly do not aim for numerical equivalence with the original rendering kernels, and the paper does not adequately establish which observed fidelity losses arise from deployment constraints versus implementation-specific approximations. Since programmable graphics engines can, in principle, reproduce the relevant rendering operations, substantial quality degradation is not an inherent consequence of engine deployment. Without rendering-equivalence validation or a controlled fidelity–efficiency analysis, the reported deployment gaps and method rankings may primarily characterize the authors' particular implementations rather than generalizable properties of the representations.

Questions for authors
  1. Validity of the Dedicated Deployment comparisons. The paper reports substantial fidelity degradation (e.g., 4–5 dB PSNR for 2DTS and Triangle-Splatting) even when method-specific rendering features are preserved. Since equivalent rasterization and compositing operations should, in principle, produce consistent rendering results across implementations, what specifically causes these losses? To what extent do they reflect inherent engine constraints versus implementation-specific approximations in depth sorting, coverage evaluation, or attribute sampling? Is there evidence that the dedicated implementations faithfully reproduce the original rendering semantics? This distinction is critical to determining whether the benchmark measures generalizable deployment limitations or artifacts of particular implementations.

  2. Representativeness of the Standard Deployment protocol. The Standard Deployment protocol removes opacity, soft coverage, and other rendering features essential to several evaluated methods. However, I think modern graphics engines do support programmable shaders and conventional transparency mechanisms. Why is opaque vertex-colored rendering chosen as the representative standard deployment setting? Will the reported fidelity degradation and ranking reversals persist under other reasonable engine configurations? This clarification is important for understanding the generalizability of the benchmark's central conclusions.

  3. Fairness and consistency of the evaluation. The paper states that DiffSoup uses 4× image downsampling while other methods use different resolutions. How are training and evaluation resolutions controlled to ensure comparable fidelity and efficiency measurements? Additionally, Tables 3/8 report a PSNR of 17.45 dB for DiffSoup on Tanks and Temples, whereas Table 11 reports 18.90 dB for the MeshSplatBench reproduction. What explains this discrepancy? Resolving these issues is important given that evaluation standardization and reproducibility are central contributions of the paper.

1 comment

Thank you for the clarification and additional experiments. I appreciate the matched-resolution evaluation of DiffSoup and the correction of the numerical inconsistency, which address part of my concerns.

However, my main concern remains unresolved. The authors attribute the substantial fidelity losses in Dedicated Deployment to differences between rendering pipelines, but provide little explanation of the underlying mechanisms. Especially since the authors explicitly emphasize this as a new finding, I think it is reasonable to expect some meaningful analysis of why these differences occur. Without identifying whether the losses arise from inherent engine constraints or implementation-specific approximations, simply reporting these gaps offers limited insight or practical guidance for graphics rendering development.

I agree that benchmarking practical deployment under specific engine configurations can be valuable. However, the current results remain difficult to interpret beyond the particular implementations evaluated.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.