DiffSoup: Compact Radiance Field Rendering

• DiffSoup is a radiance field representation that replaces dense models with a compact collection of opaque triangles augmented by multi-resolution neural textures.
• It introduces stochastic opacity masking to enable direct differentiation through binary visibility in standard GPU rasterization, ensuring robust gradient-based optimization.
• It achieves significant reductions in storage and computation while delivering real-time performance and compatibility with existing graphics pipelines.

DiffSoup is a radiance field representation and differentiable rendering method designed for extreme simplification of 3D scene models, enabling efficient and high-fidelity view synthesis with a minimal set of geometric primitives. The method replaces dense point-based or volumetric representations with a compact "triangle soup": a highly unstructured collection of opaque triangles, each augmented with compact multi-resolution neural textures and a binary opacity function. A key advance is the adoption of stochastic opacity masking, which allows direct differentiation through discrete visibility events in standard GPU rasterization, thereby obviating the need for smooth or volumetric rasterization and enabling robust gradient-based optimization even with hard, binary visibility. DiffSoup achieves significant reduction in storage and computation while providing compatibility with existing graphics hardware and pipelines, real-time performance on consumer devices, and quality competitive with state-of-the-art approaches using orders of magnitude more primitives (Tojo et al., 28 Mar 2026).

1. Triangle-Soup Radiance Field Representation

The core data structure of DiffSoup is a set of $M$ unstructured triangles,

$$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$

where each triangle $T_t$ is associated with two texture functions parameterized over barycentric coordinates $\mathbf{b} \in \mathbb{R}^2$:

• Color feature: $C_t(\mathbf{b}) \in \mathbb{R}^{N_\mathrm{feat}}$
• Opacity: $\alpha_t(\mathbf{b}) \in [0,1]$

Neural texture encoding employs a latent feature vector of dimension $N_\mathrm{feat} = 7$ and a scalar alpha per subdivision vertex of a multi-resolution triangular grid on each triangle. At subdivision resolution $R$, this results in $(2^{R-1} + 1) \times (2^R + 1)$ texture vertices per triangle. Training involves texture feature blending across levels $R_{\min} \le R \le R_{\max}$, with the finest level stored as a compact 8-bit PNG atlas after training.

2. Differentiable Binary Opacity via Stochastic Masking

Standard GPU rasterization with binary opacity typically yields non-differentiable discrete visibility. DiffSoup addresses this via stochastic opacity masking: for each fragment $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$0, a random threshold $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$1 determines whether the triangle is visible ($$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$2). The visible fragment per pixel is then selected as

$$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$3

where $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$4 is the fragment depth. This induces a differentiable probability $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$5 for each fragment,

$$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$6

which is equivalent to the volumetric weight used in NeRF losses.

Gradients are computed using the likelihood-ratio trick, yielding an unbiased estimator even for discrete visibility events: $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$7 where the score term for each fragment has a closed form. This formulation eliminates the requirement for mollifiers (edge smoothing) and supports stable optimization to binary opacity.

3. Rasterization and Rendering Pipeline

DiffSoup's inference pipeline is tightly integrated with standard GPU depth-tested rasterization. Each triangle fragment fetches its per-triangle alpha value and performs the stochastic threshold test in-shader, discarding the fragment if it fails. Depth-tested surviving fragments provide features for deferred neural shading: the selected per-pixel feature is input to a dedicated MLP, which combines it with a view-direction encoding (spherical harmonics up to degree 2, totaling 9 SH coefficients) to produce RGB output.

The rendering pipeline can be implemented as a GLSL or HLSL shader, ensuring cross-platform compatibility. Empirical validation demonstrates real-time performance across diverse hardware platforms, including NVIDIA RTX 4090 (up to 2,000 fps at quarter resolution), MacBook Pro M3 Pro (147 fps full resolution), and iPhone 15 (51 fps at $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$8).

4. Training Methodology and Optimization

Optimization is driven by a composite loss: $$\mathcal{T} = \{T_t\}_{t=1}^M, \quad T_t = (v_{t1}, v_{t2}, v_{t3}),\; v_{ti} \in \mathbb{R}^3,$$9 where $T_t$0 and $T_t$1 are predicted and ground truth color features, respectively.

Initialization samples sparse structure-from-motion keypoints, using two-thirds farthest-point sampling and one-third uniform, each covered by a small randomly oriented triangle. Vertex positions are optimized with VectorAdam (learning rate $T_t$2). Texture and MLP weights use Adam (feature lr $T_t$3, network lr $T_t$4), both decayed by $T_t$5 exponentially.

The training progression includes a coarse-to-fine multi-resolution texture schedule: for the first 5,000 iterations, a single-level texture ($T_t$6); in the next 5,000, multi-resolution ($T_t$7). Every 100 iterations, edge splitting subdivides triangles exceeding a fractional screen-space length, and pruning eliminates triangles with zero pixel coverage to enforce the target primitive budget.

5. Quantitative Evaluations and Comparative Benchmarks

On the MipNeRF360 dataset with 15,000 primitives, DiffSoup reports:

Representation	PSNR ↑	SSIM ↑	LPIPS ↓	FPS (RTX 4090)
3DGS (23K Gaussians)	23.72	0.664	0.420	115
Triangle Splatting (15K tri)	22.81	0.634	0.430	—
TexGS (15K Gaussians+tex)	24.80	0.697	0.270	16.8
DiffSoup (15K tri, CUDA)	24.76	0.748	0.204	1960

On Synthetic Scenes and the MobileNeRF benchmark, DiffSoup uses $T_t$8K triangles, while MobileNeRF uses $T_t$9K faces and requires 8 minutes of training (QEM mesh-init) versus 6 hours. DiffSoup matches or exceeds PSNR on NeRF-Synthetic and Shelly datasets.

Ablation studies confirm:

• Learned opacity is essential to capturing sub-triangle detail; fixing $\mathbf{b} \in \mathbb{R}^2$0 results in degraded SSIM/LPIPS.
• Multi-resolution textures yield faster convergence and less noisy geometry compared to single-level.
• Reducing the primitive budget from 15K to 5K incurs only $\mathbf{b} \in \mathbb{R}^2$1 dB PSNR loss, indicating graceful quality/budget trade-off.

6. Implementation Details and Memory Considerations

Geometry storage is 9 floats per triangle. At $\mathbf{b} \in \mathbb{R}^2$2, each triangle's texture grid consumes 561 points × 8 floats = 4,488 floats per triangle; for 15K triangles, this totals approximately 65.9 MB GPU memory and 44.3 MB for 8-bit PNG textures. The forward pass requires a single full-screen draw call with stochastic alpha and depth testing, plus deferred neural shading. A custom CUDA operator implements the backward pass for stochastic masking gradients. Per-fragment stochastic thresholding and depth-test are efficiently implemented in fragment shaders with pseudo-random noise textures.

7. Significance and Applications

DiffSoup demonstrates high-quality radiance field simplification with compactness and performance unattainable by prior Gaussian or volumetric splatting methods. Its full compatibility with standard graphics pipelines, orders-of-magnitude reduction in triangle count (typically $\mathbf{b} \in \mathbb{R}^2$3K), and robust differentiable rasterization of hard-edged geometry establish its utility for scenarios demanding low-latency, platform-agnostic rendering, bandwidth efficiency, and real-time interactivity on commodity devices (Tojo et al., 28 Mar 2026).