TriSplat: Differentiable Triangle Splatting

• TriSplat is a family of differentiable splatting frameworks that replace Gaussian or volumetric primitives with explicit surface triangles to enable mesh-ready scene reconstruction.
• It employs a smooth, gradient-friendly rendering approach with progressive sharpening and joint optimization of vertex positions, colors, and opacities to achieve simulation-ready outputs.
• Integrating feed-forward prediction and online RGB-D SLAM, TriSplat systems facilitate real-time, editable mesh reconstruction that integrates with standard graphics pipelines.

TriSplat is a recent arXiv label associated primarily with differentiable splatting systems that replace Gaussian or volumetric primitives with surface triangles, and more broadly with splatting frameworks designed for mesh-ready reconstruction, SLAM, or universal-camera rendering. In "Triangle Splatting+" the representation is a set of opaque triangles optimized end-to-end in a differentiable splatting framework and exported directly as a semi-connected mesh (Held et al., 29 Sep 2025). In the feed-forward reconstruction work titled "TriSplat," oriented triangle primitives, camera poses, and optional intrinsics are predicted from sparse unposed RGB images in a single forward pass (Wang et al., 25 May 2026). Related work extends the same naming pattern to dense RGB-D SLAM with a triangle-soup map (Fry et al., 29 May 2026) and to a HEALPix-based reformulation of 3D Gaussian Splatting for universal cameras under the name "UniTriSplat" (Zhu et al., 29 Jun 2026).

1. Nomenclature and antecedents

In current arXiv usage, "TriSplat" does not denote a single canonical algorithm. It appears across several closely related but technically distinct splatting systems, most of them centered on explicit triangle primitives and direct compatibility with standard graphics pipelines. A plausible implication is that the term functions as a family label for mesh-oriented splatting rather than a single fixed architecture.

Work	Primitive or setting	Stated output or emphasis
"TRIPS: Trilinear Point Splatting for Real-Time Radiance Field Rendering" (Franke et al., 2024)	Point splats in a screen-space image pyramid	Real-time radiance field rendering
"Triangle Splatting+" (Held et al., 29 Sep 2025)	Opaque triangles with shared vertices	Semi-connected mesh usable in standard graphics engines
"TriSplat: Simulation-Ready Feed-Forward 3D Scene Reconstruction" (Wang et al., 25 May 2026)	Feed-forward oriented triangle primitives from sparse views	Simulation-ready mesh scenes from a single forward pass
"Triangle Splatting SLAM" (Fry et al., 29 May 2026)	Triangle soup for dense RGB-D SLAM	On-the-fly connected mesh for editing and collision checking
"UniTriSplat" (Zhu et al., 29 Jun 2026)	3D Gaussian Splatting on the unit sphere via HEALPix	Universal-camera 3DGS

The immediate antecedent is TRIPS, which rasterizes points into two adjacent levels of a screen-space image pyramid, reconstructs a hole-free image with a lightweight neural decoder, and keeps the entire rendering pipeline differentiable. TRIPS renders 1920×1080 novel views at approximately 11 ms and large 70 M-point clouds at 15 ms on an RTX 4090, while reporting LPIPS $=0.213$ on Tanks & Temples and LPIPS $=0.233$ on MipNeRF-360 (Franke et al., 2024). This suggests a direct lineage from differentiable point splatting with learned post-processing toward triangle-native splatting with explicit surface outputs.

2. Triangle-native scene representation and rasterization

The core technical move in the triangle-based TriSplat literature is to replace anisotropic Gaussians with explicit surface triangles. In "Triangle Splatting+," the scene is parameterized by a shared vertex set

$$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$

where each vertex stores 3D position, RGB or spherical-harmonic color, and opacity; each triangle is an index triplet $T_m=(i,j,k)$ (Held et al., 29 Sep 2025). Because multiple triangles may share a vertex index, connectivity is enforced directly in the representation, and gradients from adjacent triangles accumulate on shared vertices during backpropagation.

Rendering is formulated through a smooth image-space window induced by a 2D signed-distance field. For a projected triangle with SDF $\phi(\mathbf p)$ and incenter $\mathbf s$, the window is

$$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$

so that the weight is $1$ at the incenter, decays to zero at the boundary, and vanishes outside the triangle (Held et al., 29 Sep 2025). Colors are barycentrically interpolated across the face, and all triangles are composited in depth order using

$$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$

At convergence, the intended regime is sharp, opaque triangles, so each pixel is governed by the frontmost surface element.

A closely related formulation appears in Triangle Splatting SLAM, which also represents the scene as an unstructured triangle soup with vertex positions, RGB colors, and opacities, and also uses a signed-edge SDF, the same style of smooth inside-triangle weight, barycentric color interpolation, and front-to-back alpha compositing (Fry et al., 29 May 2026). The implementations differ in some modeling details: "Triangle Splatting+" defines triangle opacity as $\min\{o_i,o_j,o_k\}$, whereas Triangle Splatting SLAM defines face opacity as the average of the three vertex opacities. That difference reflects a broader split between offline photorealistic mesh optimization and online RGB-D mapping, not a contradiction in the basic splatting formalism.

3. Optimization schedules, pruning, and differentiability

Triangle-based splatting depends on keeping rasterization differentiable while gradually moving from soft visibility to hard surfaces. In "Triangle Splatting+," the global sharpness parameter $=0.233$0 is annealed from $=0.233$1 to $=0.233$2 over training, and opacity is reparameterized with an opacity floor $=0.233$3 that starts at $=0.233$4 and is gradually increased so that all vertex opacities approach $=0.233$5 by the end of optimization (Held et al., 29 Sep 2025). The method also hard-prunes triangles with $=0.233$6 at iteration $=0.233$7, subsequently prunes triangles whose maximum rendered weight falls below $=0.233$8, and performs midpoint subdivision on sampled triangles every few thousand iterations. The resulting loss is

$=0.233$9

with typical hyperparameters $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$0, $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$1, and $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$2. Training runs for roughly 40 minutes on an NVIDIA A100, with learning rates of $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$3 for positions and $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$4 for colors and opacities (Held et al., 29 Sep 2025).

TRIPS provides a point-based precursor to this fully differentiable philosophy. It makes projection, bilinear and trilinear weighting, alpha blending, gated convolutions, spherical-harmonic evaluation, and tone mapping differentiable, allowing joint optimization of point positions, world-space radii, descriptors, opacities, camera intrinsics and extrinsics, and tone-mapper parameters (Franke et al., 2024). Its training loss combines VGG, SSIM, and MSE terms,

$$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$5

with early emphasis on MSE and SSIM and later activation of the perceptual VGG term. This suggests continuity between differentiable point splatting and later triangle-native optimization schedules: both rely on soft, gradient-friendly rendering early in training and progressively sharpen the representation into a direct geometric scene model.

4. Feed-forward TriSplat and simulation-ready reconstruction

"TriSplat: Simulation-Ready Feed-Forward 3D Scene Reconstruction" reframes the problem as single-forward-pass prediction from sparse unposed RGB images rather than iterative scene fitting (Wang et al., 25 May 2026). The network consumes a sparse set of images and outputs per-pixel 3D point maps, per-pixel triangle attributes, camera poses and optionally intrinsics, and a ready-to-use triangle mesh. Its backbone is a DINOv2 ViT followed by a lightweight transformer decoder that alternates intra-view self-attention and cross-view joint attention. Three heads are then used: a point-map head, a camera head, and a triangle-attribute head.

The point-map head predicts unconstrained scalars $$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$6, with depth parameterized as

$$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$7

and the 3D point in camera coordinates given by

$$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$8

The triangle-attribute head predicts a density logit, three scale logits, a quaternion, spherical-harmonic appearance coefficients, and a blur parameter. Rather than regressing triangle orientation as an unconstrained latent variable, the method constructs geometry normals from the predicted point maps, refines them with an image-conditioned normal head, and converts them into stable local frames for triangle parameterization (Wang et al., 25 May 2026). Geometry-anchored normals are obtained from finite differences,

$$\mathcal V=\{\mathbf v_i\in\mathbb R^3\mid i=1\ldots N\},\quad \mathbf v_i=(x_i,y_i,z_i,c_i,o_i),$$9

followed by a small U-Net refinement and a mono-normal bootstrap from a pretrained Omnidata DPT teacher.

Training uses progressive sharpening through opacity and blur scheduling. Opacity is driven toward binary values by an exponent schedule and a temperature sharpening step, while blur is scheduled by

$T_m=(i,j,k)$0

with $T_m=(i,j,k)$1 decaying from $T_m=(i,j,k)$2 to $T_m=(i,j,k)$3 over $T_m=(i,j,k)$4 steps (Wang et al., 25 May 2026). The total loss combines photometric, camera, and normal terms. After a forward pass, mesh extraction discards triangles below an opacity threshold such as $T_m=(i,j,k)$5, corrects face winding, and merges nearby duplicate vertices via quantized position hashing with precision $T_m=(i,j,k)$6. The exported result is described as a standard watertight, up to small holes, triangle soup in OBJ or PLY format for immediate use in Unity, Unreal, NVIDIA Isaac Sim, physics engines, collision detectors, and standard rasterizers.

Empirically, this feed-forward TriSplat reports on RealEstate10K with 6 input images a Chamfer Distance of $T_m=(i,j,k)$7, F1 of $T_m=(i,j,k)$8, and mesh PSNR of $T_m=(i,j,k)$9 dB versus $\phi(\mathbf p)$0 dB for the strongest Gaussian baseline. On DL3DV it reports surface F1 $\phi(\mathbf p)$1 versus $\phi(\mathbf p)$2 at 6 views, and in zero-shot transfer to ScanNet it reports depth AbsRel $\phi(\mathbf p)$3 and mean normal error $\phi(\mathbf p)$4. End-to-end mesh export takes $\phi(\mathbf p)$5 s for 6 views, compared with $\phi(\mathbf p)$6 s to $\phi(\mathbf p)$7 s for Gaussian plus TSDF pipelines (Wang et al., 25 May 2026).

5. Triangle Splatting SLAM

Triangle Splatting SLAM extends the same primitive choice into online dense RGB-D SLAM (Fry et al., 29 May 2026). The map is an unstructured triangle soup with a vertex set

$\phi(\mathbf p)$8

and a face set $\phi(\mathbf p)$9. On each new keyframe, the system back-projects every valid RGB-D pixel into 3D, spawns an equilateral triangle around each new point, chooses triangle size proportional to distance to the nearest neighbour, and orients the triangle to the local sensor normal from finite differences of depth. Per-keyframe maintenance prunes triangles whose mean opacity is below $\mathbf s$0 or whose projected area exceeds $\mathbf s$1, and densifies by subdividing triangles with low rendering sharpness.

Tracking and mapping are both driven by differentiable rendering. The single-frame tracking frontend minimizes a photometric loss with D-SSIM and a depth loss, while the multi-keyframe backend jointly optimizes camera poses and all vertex parameters using photometric, depth, geometric normal alignment, and equiangularity terms. To accelerate pose-only iterations, the system derives an analytic pose Jacobian with the micro-Lie-theory expression

$\mathbf s$2

When a connected mesh is required, the current point set is triangulated via restricted Delaunay triangulation, and never-visible triangles can be removed through a pruned Delaunay step (Fry et al., 29 May 2026).

The system is not real-time in the conventional SLAM sense, but it is explicitly online. On a single RTX 4090, TUM scenes run at $\mathbf s$3 to $\mathbf s$4 FPS with end-to-end latency $\mathbf s$5 to $\mathbf s$6 s per frame; triangle counts range from $\mathbf s$7 to $\mathbf s$8, and peak GPU memory is $\mathbf s$9 to $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$0 GB (Fry et al., 29 May 2026). On TUM-RGBD, the reported average ATE is $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$1 cm, compared with $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$2 for MonoGS-2D and $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$3 for MonoGS. On Replica, the average ATE is $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$4 cm, compared with $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$5 for MonoGS-2D*. For geometry reconstruction on Replica, the reported average Chamfer distance is $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$6 cm for Ours+TSDF, $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$7 cm for Ours+Delaunay, and $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$8 cm for Ours+Delaunay (pruned), compared with $$I(\mathbf p)=\mathrm{ReLU}\Bigl(\frac{\phi(\mathbf p)}{\phi(\mathbf s)}\Bigr)^\sigma,$$9 cm for MonoGS-2D*+TSDF. The rendering-quality trade-off is explicit: on Replica, the system reports $1$0 dB PSNR, $1$1 SSIM, and $1$2 LPIPS, whereas MonoGS reports $1$3 dB, $1$4, and $1$5 (Fry et al., 29 May 2026). This establishes a recurrent theme in triangle-native splatting: explicit geometry and editability may improve while photometric rendering metrics need not dominate image-first baselines.

6. Downstream uses, recurrent trade-offs, and name ambiguity

A central motivation for triangle-native TriSplat systems is that the rendering primitive is already a surface element. In "Triangle Splatting+," the converged representation is exported directly as PLY or OBJ, with approximately 2 million vertices and 3 million triangles on Mip-NeRF360, no further Poisson reconstruction or texturing, and approximately 400 FPS rendering in Unity on a consumer laptop GPU (Held et al., 29 Sep 2025). The same work emphasizes downstream uses that are difficult to express in Gaussian-only pipelines: because each rendered pixel is governed by exactly one opaque triangle, a 2D segmentation mask can be lifted directly to a set of triangles in 3D; the paper demonstrates extracting a table in the Garden scene and a truck in the Tanks scene by masking and deleting the corresponding triangles. It also reports direct import into Unity as a non-convex mesh collider, with rigid-body interaction, walkable floors, collisions, gravity, and first-person navigation (Held et al., 29 Sep 2025).

The feed-forward TriSplat work makes the same simulation claim in a sparse-view setting. Its exported meshes are intended for Unity, Unreal, NVIDIA Isaac Sim, physics engines, collision detectors, and standard rasterizers without TSDF fusion or Poisson reconstruction, and the paper reports direct import into Unity and Isaac Sim for locomotion, grasping, and collision without manual cleanup (Wang et al., 25 May 2026). This suggests that "simulation-ready" is not a peripheral add-on but a defining criterion of triangle-native TriSplat systems.

A common misconception is that every "TriSplat" paper is triangle-based. "UniTriSplat" is not; it is a unified 3D Gaussian Splatting framework that reformulates Gaussian rendering on the unit sphere via HEALPix discretization for perspective, fisheye, and omnidirectional cameras (Zhu et al., 29 Jun 2026). Its key quantities are the equal-area pixel count

$1$6

and solid angle

$1$7

which are used to obtain uniform solid-angle sampling and a HEALPix-aware SSIM loss. On Mip-NeRF 360, UniTriSplat reports PSNR $1$8, SSIM $1$9, HSSIM $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$0, LPIPS $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$1, and training time $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$2 minutes, while OP43DGS reports PSNR $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$3, SSIM $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$4, HSSIM $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$5, LPIPS $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$6, and $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$7 minutes. On ScanNet++, UniTriSplat reports PSNR $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$8, SSIM $$C(\mathbf p)= \sum_{n=1}^{M} \bigl(\mathbf c_{T_n}\,o_{T_n}\,I(\mathbf p)\bigr) \prod_{i=1}^{n-1}\bigl[1-o_{T_i}I(\mathbf p)\bigr].$$9, HSSIM $\min\{o_i,o_j,o_k\}$0, LPIPS $\min\{o_i,o_j,o_k\}$1, and $\min\{o_i,o_j,o_k\}$2 minutes; on 360Roam it reports PSNR $\min\{o_i,o_j,o_k\}$3, SSIM $\min\{o_i,o_j,o_k\}$4, HSSIM $\min\{o_i,o_j,o_k\}$5, LPIPS $\min\{o_i,o_j,o_k\}$6, and $\min\{o_i,o_j,o_k\}$7 minutes (Zhu et al., 29 Jun 2026). These numbers clarify that the "TriSplat" naming pattern now spans both triangle-native explicit geometry and camera-unified Gaussian splatting.

Across these works, the stable conceptual core is not a single codebase or parameterization but a research direction: differentiable splatting that aims to preserve the efficiency of explicit primitives while making scene outputs more directly usable in graphics, robotics, simulation, collision checking, and mesh editing. The exact primitive, however, remains paper-dependent.