NanoGS: Efficient 3D Gaussian Splat Simplification

• NanoGS is a training-free, CPU-efficient framework that simplifies 3D Gaussian Splat models by merging similar Gaussian primitives while preserving scene structure and appearance.
• It employs a graph-based k-nearest neighbor approach and mass-preserved moment matching to locally merge splats with minimal perceptual and geometric error.
• The framework significantly reduces model size and computational overhead for real-time applications, maintaining compatibility with established 3DGS rendering pipelines.

NanoGS is a training-free, CPU-lightweight framework for the simplification of 3D Gaussian Splat (3DGS) scene representations. Unlike most prior approaches that require expensive GPU-based post-training optimization and image-based supervision, NanoGS directly operates on existing 3DGS models to drastically reduce the number of Gaussian primitives—or "splats"—while preserving scene structure, appearance, and compatibility with established 3DGS rendering pipelines. The approach is based on graph-based, local pairwise merging of Gaussian splats utilizing mass-preserved moment matching and an explicit, quantifiable merge cost. NanoGS achieves significant reductions in model size and compute overhead for real-time applications without retraining or fine-tuning (Xiong et al., 17 Mar 2026).

1. Motivation and Problem Context

@@@@1@@@@ (3DGS) is a real-time scene representation technique wherein complex 3D scenes are encoded by millions of anisotropic Gaussian primitives. Each splat is parameterized by a 3D center, full or diagonal covariance, opacity, and an appearance descriptor (typically spherical-harmonic color coefficients). During rendering, each splat is projected onto the camera plane, depth-sorted, alpha-blended, and shaded. While 3DGS models deliver high-fidelity, photorealistic novel view synthesis, they incur substantial costs:

• Storage and transmission requirements scale to hundreds of MB or even GB, as 10⁶–10⁷ splats are typical for detailed scenes.
• Rendering overhead arises due to the need for rasterization, sorting, and large memory bandwidth, degrading performance, especially on edge devices.
• Existing model compaction methods, such as image-guided pruning, quantization, or retraining, demand expensive GPU optimization with calibrated images and may forfeit compatibility with established 3DGS renderers.

NanoGS was developed to address these issues with a training-free, fast, and representation-preserving simplification process that maintains both geometric and photometric scene fidelity for real-time 3DGS pipelines (Xiong et al., 17 Mar 2026).

2. 3D Gaussian Splat Representation

Within 3DGS, each splat $i$ is defined by:

• Center $\mu_i \in \mathbb{R}^3$
• Covariance $\Sigma_i \in \mathbb{R}^{3 \times 3}$ (anisotropic; diagonal or full)
• Opacity $\alpha_i \in [0,1]$
• Appearance feature $f_i$ (e.g., spherical-harmonic color coefficients)

The unnormalized Gaussian density for splat $i$ is

$p_i(x) = w_i \cdot \mathcal{N}(x; \mu_i, \Sigma_i)$

where $$w_i = (2\pi)^{3/2} \cdot \alpha_i \cdot \prod_k s_{i,k}$$ encodes the splat's mass (determined by its volume and opacity). Rendering entails projecting each splat into the image plane, performing depth sorting, alpha compositing, and applying shading via its $f_i$ descriptor. This parameterization is preserved throughout all NanoGS operations to retain full compatibility with extant 3DGS rendering tools (Xiong et al., 17 Mar 2026).

3. Pairwise Merging via Sparse Spatial Graphs

NanoGS reduces the splat count by repeated, local merging of splats with minimal expected error. This is formalized as identifying and merging pairs of spatially proximate splats $(i, j)$ into a single splat $m$, preserving the mass and the salient spatial, opacity, and appearance information of the original pair.

3.1 Spatial Neighborhood via kNN Graph

NanoGS constructs a $k$-nearest-neighbor (kNN) graph $G=(V, E)$ over the current splat centers $\{\mu_i\}$, connecting each splat to its $k$ spatially nearest neighbors. This produces $|E| = O(kN)$ candidate merge operations per iteration, far less than the $O(N^2)$ total pairwise possibilities, and is periodically rebuilt to adapt neighborhoods as the geometry changes during simplification (Xiong et al., 17 Mar 2026).

3.2 Merge Operation: Mass-Preserved Moment Matching

When merging $i$ and $j$:

• Mass: $W = w_i + w_j$
• Center: $\mu_m = (w_i\mu_i + w_j\mu_j)/W$
• Covariance:

$$\Sigma_m = \frac{w_i (\Sigma_i + (\mu_i-\mu_m)(\mu_i-\mu_m)^T) + w_j (\Sigma_j + (\mu_j-\mu_m)(\mu_j-\mu_m)^T)}{W}$$

• Opacity (source-over "union" rule): $\alpha_m = 1 - (1-\alpha_i)(1-\alpha_j)$
• Appearance: $f_m = (w_i f_i + w_j f_j)/W$

This mass-preserved moment matching (MPMM) ensures that merged splats reflect the weighted aggregate of their constituents, biasing toward preserving coverage by large, opaque splats and maintaining scene integrity (Xiong et al., 17 Mar 2026).

4. Merge Cost and Error Measurement

For each candidate merge $(i, j)$, an explicit cost $C(i,j)$ quantifies the error of replacing the mixture $(i,j)$ by their merged splat $m$.

4.1 Geometric Distortion: I-Divergence

The geometric cost is defined as the I-divergence between the normalized two-component mixture $$\tilde{p}_{ij}(x) = \pi \mathcal{N}(x; \mu_i, \Sigma_i) + (1-\pi)\mathcal{N}(x; \mu_j, \Sigma_j)$$ (where $\pi = w_i/(w_i + w_j)$) and the merged Gaussian $q_m(x) = \mathcal{N}(x; \mu_m, \Sigma_m)$:

$$D_{\text{geo}}(i, j) = \int \tilde{p}_{ij}(x) \log \frac{\tilde{p}_{ij}(x)}{q_m(x)} dx$$

Since this is intractable analytically for mixtures, it is estimated via Monte Carlo sampling (Xiong et al., 17 Mar 2026).

4.2 Appearance Discrepancy

The appearance cost penalizes merges between visually dissimilar splats:

$D_{\text{app}}(i, j) = \| f_i - f_j \|_2^2$

4.3 Total Merge Cost

The combined cost is $$C(i, j) = D_{\text{geo}}(i, j) + D_{\text{app}}(i, j)$$. This formulation prioritizes spatial-neighbor merges with low geometric and photometric error, ensuring simplifications are perceptually and structurally faithful (Xiong et al., 17 Mar 2026).

5. Progressive Simplification Workflow

The NanoGS simplification process consists of the following steps:

1. Opacity Pruning: Remove all splats with opacity $\alpha$ below a threshold $\tau$.
2. Iterative Merging (while the current splat count exceeds the target):
   • Build or update the kNN graph over splat centers.
   • Compute $C(i, j)$ for each edge $(i, j)$ in $E$.
   • Sort all candidate merges by increasing cost.
   • Apply greedy disjoint matching: iterate through sorted edges, selecting each pair only if both splats are unmerged in this pass, up to the desired number of merges.
   • Merge all selected pairs in parallel using MPMM.
3. Termination: Stop once the target count or compaction ratio is reached.

This procedure enforces that merges are local and non-overlapping per batch. Locality and disjoint batch processing enable efficient parallel execution and maintain global scene structure during heavy simplification (Xiong et al., 17 Mar 2026).

6. Implementation and Integration

NanoGS does not require access to calibrated images or additional neural optimization. All operations—kNN graph construction, cost computation, and merge execution—are CPU-efficient, running on a few cores and handling million-splat models in minutes. The output strictly preserves the $\left( \mu, \Sigma, \alpha, f \right)$ parameterization of standard 3DGS, allowing immediate integration into existing renderers (including ORBX, InstantNGP GUI). No gradient descent or fine-tuning is necessary, and the process is entirely disentangled from the original 3D reconstruction pipeline (Xiong et al., 17 Mar 2026).

7. Experimental Results and Benchmarking

NanoGS was evaluated on NeRF-Synthetic (8 scenes), Mip-NeRF 360 (9 scenes), Tanks & Temples (2), and Deep Blending (2), under compaction ratios $\rho \in \{0.1, 0.01, 0.001\}$. Performance was measured using PSNR, SSIM, and FPS:

• At $\rho=0.1$, NanoGS achieved the highest PSNR (example: $25.81$ dB vs. $21.25$ dB for LightGS on NeRF-Synthetic), with SSIM $\sim 0.91$.
• Under aggressive compaction ($\rho = 0.01, 0.001$), NanoGS outperformed baselines by $+4$–$6$ dB in PSNR on average, maintaining coherent geometry in contrast to "floater" artifacts commonly arising with other simplification approaches.
• Rendering framerate (FPS) remained competitive due to reduced splat count and commensurate rasterization savings.
• Ablations demonstrated that kNN graph locality, opacity thresholding, and I-divergence-based merge cost each contributed $1$–$3$ dB PSNR improvements under maximal simplification pressure.

NanoGS thus provides a practical, post-hoc, training-free approach for compacting high-fidelity 3DGS models by up to $100\times$ without significant fidelity loss and with complete downstream compatibility (Xiong et al., 17 Mar 2026).