NanoGS: Training-Free and Lightweight Gaussian Splat Simplification

Conference: ECCV 2026
Paper: ECCV Official
Project: https://saliteta.github.io/NanoGS/
Area: 3D Vision / Model Compression
Keywords: 3D Gaussian Splatting, model compaction, training-free simplification, moment matching, edge collapse

TL;DR

NanoGS introduces a training-free and lightweight 3D Gaussian Splatting simplification framework that constructs a spatial sparse KNN merge graph, scores candidate merges via an information-theoretic I-divergence and appearance metric, and fuses primitives using closed-form Mass-Preserved Moment Matching (MPMM), achieving extreme primitive compaction up to 1000x without requiring multi-view images or GPU retraining.

Background & Motivation

3D Gaussian Splatting (3DGS) has transformed real-time novel view synthesis by modeling scenes with collections of anisotropic 3D Gaussians optimized via adaptive density control. By offering rasterization-compatible, photorealistic rendering at high frame rates, it has quickly become a prominent alternative to implicit representations like Neural Radiance Fields (NeRF). However, capturing intricate high-frequency geometry and complex view-dependent appearances demands millions of Gaussian primitives. Consequently, serialized 3DGS assets frequently consume hundreds of megabytes or several gigabytes. This structural scaling creates severe bottlenecks for storage, network transmission, primitive depth sorting, and rasterization overhead, substantially hindering smooth deployment on mobile and edge devices.

Existing efficiency techniques for 3DGS broadly fall into two categories: bit-level compression (such as vector quantization, entropy coding, and spherical harmonics reduction) and primitive-level compaction (such as pruning and sparsification). Compaction methods reduce the number of Gaussians directly, but dominant approaches—including LightGS, PUP 3D-GS, and GHAP—heavily rely on GPU-intensive post-optimization loops supervised by calibrated multi-view camera images. This requirement breaks down in widespread practical workflows where 3DGS models originate from feed-forward single-view generators, cross-modal diffusion models, mesh-to-splat conversions, or interactive asset editors where calibrated source images simply do not exist. Furthermore, asset creators cannot anticipate every downstream client's VRAM constraints, and running multi-hour retraining pipelines for each target budget is infeasible.

To bridge the gap between resource-constrained edge execution, missing image supervision, and on-the-fly model decimation, 3DGS requires a representation-preserving, training-free post-hoc simplification system that operates efficiently on CPU. The angle of attack in this paper is to treat the Gaussian set as an unnormalized continuous spatial mixture distribution and decouple the simplification pipeline into candidate topology selection, merge-cost evaluation, and primitive fusion operators. Core idea: organize primitives into a sparse spatial KNN graph, evaluate candidate merges via Monte Carlo I-divergence and appearance discrepancy, and iteratively collapse disjoint edges using closed-form Mass-Preserved Moment Matching (MPMM) with volume-weighted moments and transmittance-saturating opacity.

Method

Overall Architecture

NanoGS formulates Gaussian Splat simplification as a progressive edge collapse procedure over a sparse spatial neighbor graph. The end-to-end pipeline consists of four modular stages: initial opacity filtering, sparse merge graph construction, merge-cost evaluation, and primitive fusion via Mass-Preserved Moment Matching (MPMM), coordinated through batched edge collapses and periodic neighborhood refreshes. The system first prunes low-opacity floater primitives, connects each Gaussian to its spatial \(k\)-nearest neighbors to bound edge complexity from \(O(N^2)\) to \(O(kN)\), scores each edge by approximating the two-Gaussian mixture with a single Gaussian, and greedily merges non-overlapping pairs until the desired compaction ratio \(\rho\) is reached.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input 3DGS Primitive Set<br/>Centers / Covariances / Opacity / SH"] --> B["Initial Opacity Filtering<br/>Prune low-opacity noise and floating artifacts"]
    B --> C["Sparse Merge Graph & Progressive Collapses<br/>Build spatial KNN candidate graph (K=16)"]
    C --> D["I-Divergence Geometric & Appearance Cost<br/>Evaluate divergence between mixture and approximation"]
    D --> E["Mass-Preserved Moment Matching (MPMM)<br/>Mass-weighted moments and transmittance union"]
    E --> F{"Target Compaction Ratio ρ Reached?"}
    F -->|No, continue reduction| G["Periodic Neighborhood Refresh<br/>Recompute spatial KNN on newly merged primitives"]
    G --> C
    F -->|Yes, finished| H["Output Standard 3DGS Model<br/>Native compatibility with standard renderers and codecs"]

Key Designs

1. Sparse Merge Graph & Progressive Collapses: Converting quadratic pair search to local graph edge contraction

Evaluating all pairwise merge combinations across \(N\) primitives requires prohibitive \(O(N^2)\) complexity on large-scale scenes with millions of splats. Furthermore, merging distant primitives inevitably causes severe volumetric dilation and visible geometric distortion. To address this, NanoGS constructs an undirected \(k\)-nearest-neighbor graph \(G=(V, E)\) based on primitive 3D center positions \(\mu_i\), strictly bounding the candidate edge count to \(|E| = O(kN)\) (default \(k=16\)).

During each reduction pass, the framework selects an independent set of non-overlapping, lowest-cost candidate edges (a matching) and collapses them in parallel, halving the selected primitives in a single iteration. Because spatial merges alter local geometry and point densities, static graphs would miss newly adjacent merge opportunities. NanoGS incorporates a periodic local neighborhood refresh that re-runs spatial KNN queries around newly generated primitives, maintaining high merge quality under aggressive compaction while achieving second-level execution throughput on commodity CPUs.

2. I-Divergence Geometric & Appearance Cost: Information-theoretic scoring of Gaussian mixture approximation

Standard mesh simplification methods rely on Quadric Error Metrics (QEM), but 3D Gaussians represent continuous volumetric probability densities characterized by anisotropic covariances and optical transmittances. Simple Euclidean distance between centers cannot reflect radiation field distortions caused by merging. When two Gaussians are spatially well-separated (forming a bimodal distribution), approximating them with a single Gaussian induces significant mass mismatch or over-inflation. To quantify this distortion rigorously, NanoGS interprets each splat \(i\) as an unnormalized continuous spatial mass density: $\(p_i(x) = w_i \mathcal{N}(x; \mu_i, \Sigma_i), \quad w_i = (2\pi)^{3/2} \alpha_i \prod_{k=1}^3 s_{i,k}\)$ where \(s_{i,k}\) represents the scaling factor along axis \(k\), and \(\alpha_i\) is the opacity. Defining the normalized two-component mixture distribution \(\tilde{p}_{ij}(x) = \frac{w_i}{W} \mathcal{N}(x; \mu_i, \Sigma_i) + \frac{w_j}{W} \mathcal{N}(x; \mu_j, \Sigma_j)\) with total mass \(W=w_i+w_j\), and denoting the moment-matched Gaussian as \(q_m(x) = \mathcal{N}(x; \mu_m, \Sigma_m)\), the geometric merge distortion is measured by the I-divergence (generalized Kullback-Leibler divergence): $\(\mathcal{D}_{\mathrm{geo}}(i, j) = \mathrm{I}(\tilde{p}_{ij} \parallel q_m) = \int \tilde{p}_{ij}(x) \log \frac{\tilde{p}_{ij}(x)}{q_m(x)} dx\)$ Since the mixture term lacks a closed form, it is approximated with a small fixed number of Monte Carlo samples (\(S=1\) is sufficient). Combined with the squared Euclidean distance between spherical harmonics feature vectors \(\mathcal{D}_{\mathrm{app}}(i, j) = \|f_i - f_j\|_2^2\), the total cost \(\mathcal{C}(i, j) = \mathcal{D}_{\mathrm{geo}}(i, j) \mathcal{D}_{\mathrm{app}}(i, j)\) prioritizes pairs that share consistent geometry, orientation, and color.

3. Mass-Preserved Moment Matching (MPMM): Closed-form fusion via volume-mass weighting and probabilistic opacity union

When collapsing an edge \((i, j)\) into a merged primitive \(m\), prior moment-matching techniques typically weight primitives by opacity alone. This causes small, high-opacity outlier floaters to dominate large semi-transparent surface splats, resulting in visible holes and surface tearing. MPMM addresses this by weighting each splat by its spatial integrated mass \(w_i = (2\pi)^{3/2} \alpha_i \prod_{k} s_{i,k}\), which couples 3D volumetric scale with opacity. The merged center \(\mu_m\) and appearance vector \(f_m\) are computed as mass-weighted averages: $\(\mu_m = \frac{w_i \mu_i + w_j \mu_j}{W}, \quad f_m = \frac{w_i f_i + w_j f_j}{W}\)$ To ensure strict second-order statistical consistency, the merged covariance matrix \(\Sigma_m\) is decomposed into a kernel averaging term and a dispersion term: $\(\Sigma_m = \frac{1}{W} \sum_{k \in \{i, j\}} w_k \Sigma_k + \frac{1}{W} \sum_{k \in \{i, j\}} w_k (\mu_k - \mu_m)(\mu_k - \mu_m)^\top\)$ The first term preserves local anisotropic orientation, while the second term accounts for the separation between means, naturally expanding the Gaussian envelope to cover the union of both components. For opacity, MPMM applies the Porter-Duff source-over transmittance multiplication rule: \(\alpha_m = 1 - (1 - \alpha_i)(1 - \alpha_j) = \alpha_i + \alpha_j - \alpha_i \alpha_j\). This saturating union preserves optical blocking capacity and prevents surfaces from becoming transparent under extreme decimation.

A Worked Example

Consider two adjacent splats on an object surface: primitive \(i\) is a primary surface patch with scale product 0.08 and opacity \(\alpha_i = 0.8\); primitive \(j\) is a smaller detail splat with scale product 0.02 and opacity \(\alpha_j = 0.6\). 1. Mass weighting: \(w_i \propto 0.08 \times 0.8 = 0.064\), while \(w_j \propto 0.02 \times 0.6 = 0.012\). Primitive \(i\) accounts for 84.2% of the combined mass. 2. Centroid and appearance: The new center \(\mu_m\) and spherical harmonics \(f_m\) are strongly anchored by the primary primitive \(i\), preventing small outliers from shifting color and position. 3. Covariance expansion: If the two centroids are slightly offset, the dispersion term automatically dilates the covariance ellipsoid along the connecting direction, smoothly bridging the gap without manual hyperparameter tuning. 4. Opacity composition: The merged opacity evaluates to \(\alpha_m = 1 - (1 - 0.8)(1 - 0.6) = 0.92\), guaranteeing that light occlusion remains dense and coherent.

Key Experimental Results

Main Results

NanoGS is benchmarked across four standard 3DGS datasets covering 21 scenes: NeRF-Synthetic (8 synthetic objects), Mip-NeRF 360 (9 unbounded outdoor/indoor scenes), Tanks & Temples (2 large-scale real scenes), and Deep Blending (2 complex indoor environments). Compaction budgets are set to \(\rho \in \{0.1, 0.01, 0.001\}\) (retaining 10%, 1%, and 0.1% primitives). Baselines (LightGS, PUP3DGS, GHAP) are evaluated on their standalone compaction/pruning stage without post-compaction retraining:

Dataset	Compaction Ratio \(\rho\)	LightGS [NeurIPS 24]	PUP3DGS [CVPR 25]	GHAP [NeurIPS 25]	Ours (NanoGS)	Margin over Best Baseline
NeRF-Synthetic	0.1	21.25 / 0.875 / 2205	20.24 / 0.860 / 2341	20.09 / 0.838 / 2487	25.81 / 0.910 / 2450	+4.56 dB
(Full: 33.66 / 0.970)	0.01	15.76 / 0.807 / 2571	13.26 / 0.786 / 2676	12.81 / 0.776 / 2679	22.28 / 0.858 / 2598	+6.52 dB
	0.001	12.64 / 0.796 / 2624	11.31 / 0.792 / 2839	11.07 / 0.791 / 2916	19.04 / 0.822 / 2641	+6.40 dB
Mip-NeRF 360	0.1	19.38 / 0.588 / 727	15.59 / 0.513 / 996	17.35 / 0.444 / 1224	21.97 / 0.582 / 1015	+2.59 dB
(Full: 27.46 / 0.815)	0.01	14.39 / 0.389 / 1526	10.19 / 0.161 / 2408	10.62 / 0.174 / 2557	19.39 / 0.470 / 2006	+5.00 dB
	0.001	11.97 / 0.278 / 2071	8.81 / 0.056 / 2650	8.52 / 0.035 / 2623	17.20 / 0.430 / 2194	+5.23 dB
Tanks & Temples	0.1	17.50 / 0.642 / 1108	12.71 / 0.564 / 1283	15.34 / 0.487 / 1666	17.94 / 0.626 / 1430	+0.44 dB
(Full: 23.63 / 0.847)	0.01	12.29 / 0.441 / 1996	8.22 / 0.266 / 2434	8.43 / 0.220 / 2659	15.29 / 0.501 / 2326	+3.00 dB
	0.001	9.36 / 0.341 / 2419	6.78 / 0.162 / 2593	5.33 / 0.026 / 2670	13.54 / 0.457 / 2487	+4.18 dB
Deep Blending	0.1	24.28 / 0.816 / 891	19.65 / 0.755 / 1325	21.75 / 0.739 / 1376	26.29 / 0.839 / 1202	+2.01 dB
(Full: 29.56 / 0.903)	0.01	18.28 / 0.712 / 1879	8.83 / 0.282 / 2478	11.36 / 0.435 / 2583	23.12 / 0.780 / 2132	+4.84 dB
	0.001	13.41 / 0.616 / 2296	7.06 / 0.073 / 2672	7.06 / 0.061 / 2627	19.42 / 0.739 / 2322	+6.01 dB

Note: Table cells format is PSNR / SSIM / FPS.

Ablation Study

The ablation investigates the core modular choices: candidate graph topology (KNN vs. Octree), initial opacity filtering, and the geometric cost metric (I-divergence vs. fast MSE surrogate):

Dataset	Configuration	\(\rho = 0.1\)	\(\rho = 0.01\)	\(\rho = 0.001\)	Note
NeRF-Synthetic	Full model	25.81 / 0.910	22.28 / 0.858	19.04 / 0.822	Complete pipeline
	w/o KNN graph (Octree)	25.53 / 0.905	20.74 / 0.839	15.85 / 0.800	Rigid spatial partitioning drops 3.19 dB at \(\rho=0.001\)
	w/o filtering	24.99 / 0.904	22.01 / 0.858	18.87 / 0.822	Float-point noise slightly pollutes surface blends
	w/o I-divergence (MSE)	25.65 / 0.908	22.15 / 0.854	18.80 / 0.819	MSE fails to capture high-order volumetric overlap
Mip-NeRF 360	Full model	21.97 / 0.582	19.39 / 0.470	17.20 / 0.430	Best fidelity on unbounded outdoor scenes
	w/o KNN graph (Octree)	21.53 / 0.537	17.82 / 0.444	14.11 / 0.382	Severe boundary grouping errors in complex backgrounds
	w/o filtering	18.24 / 0.504	15.47 / 0.421	14.67 / 0.401	Unfiltered semi-transparent floaters severely hurt outdoor PSNR
	w/o I-divergence (MSE)	21.61 / 0.566	19.19 / 0.467	16.98 / 0.426	Degraded continuous anisotropic fitting

Key Findings

• Widening Advantage in Extreme Regimes: At moderate reduction (\(\rho=0.1\)), pruning baselines maintain reasonable outlines. However, under aggressive compression (\(\rho \le 0.01\)), pruning creates severe holes and discontinuous fragments. NanoGS maintains contiguous surfaces, outperforming the best baseline by an average of +2.40 dB at \(\rho=0.1\), +4.84 dB at \(\rho=0.01\), and +5.46 dB at \(\rho=0.001\).
• Critical Role of Opacity Filtering in Real Scenes: On Mip-NeRF 360, disabling opacity filtering causes an immediate 3.73 dB drop at \(\rho=0.1\) (21.97 → 18.24) and 2.53 dB at \(\rho=0.001\). This confirms that unbounded reconstructions contain large populations of low-opacity floaters that distort clean surface merges if not pre-emptively pruned.
• CPU Efficiency and Codec Orthogonality: Compacting large outdoor scenes (1122 MB) to 10% takes only 88.1 seconds on CPU and 17.1 seconds on a single GPU. Furthermore, cascading NanoGS with bit-level entropy codecs like Self-Organizing Gaussians (SOG) yields an additional \(6.35\times\) storage reduction, enabling multi-order-of-magnitude overall size reduction.

Highlights & Insights

• Decoupled Modular Simplification Framework: Disentangling the pipeline into candidate topology, cost function, and merge operator clarifies that training-free compaction performance stems from principled structural pairing rather than complicated optimization loops.
• Physically Grounded Mass-Preserved Moment Matching: Defining primitive mass as the integral of 3D volume scale and opacity successfully prevents surface shrinking and tearing, establishing an effective formulation for anisotropic Gaussian fusion.
• Universal Drop-in Deployment: NanoGS operates entirely on pre-trained ply files without retraining or camera parameters, preserving the native 3DGS parameter format for immediate compatibility with standard rasterizers.

Limitations & Future Work

• Static Scene Constraint: The current formulation focuses on static 3DGS assets; extending topology tracking and moment matching to dynamic 4D Gaussians carrying velocity or deformation fields is an open challenge.
• Elongated Primitive Merging: Merging pairs of highly needle-like, non-coaxial Gaussians with a single Gaussian can induce local blurring due to the dispersion term; multi-splat (many-to-one) or adaptive subdivision operators could mitigate this.
• View-Dependent High-Frequency Drift: The appearance cost uses the Euclidean distance of spherical harmonics vectors, which may smooth out sharp specular highlights; incorporating viewing-angle-aware perceptual penalties represents a promising direction.

Related Work & Insights

• vs LightGS [Fan et al., NeurIPS 2024]: LightGS relies on view-reprojection sensitivity to prune primitives and requires subsequent fine-tuning to recover fidelity; NanoGS is completely training-free, operating in the native primitive space to eliminate geometry holes under extreme ratios.
• vs GHAP [Wang et al., NeurIPS 2025]: GHAP applies optimal transport for global Gaussian mixture reduction but relies on appearance optimization to restore visual textures; NanoGS preserves color and geometry simultaneously using closed-form MPMM without retraining.
• vs H3DGS [Kerbl et al., TOG 2024]: H3DGS hard-codes moment matching inside a pre-determined Bounding Volume Hierarchy (BVH) for dynamic LOD rendering; NanoGS decouples graph topology from cost metrics, generating compact, permanent representations driven purely by merge loss.

Rating

• Novelty: ⭐⭐⭐⭐ [Decoupled training-free framework combining spatial KNN, I-divergence, and Mass-Preserved Moment Matching]
• Experimental Thoroughness: ⭐⭐⭐⭐⭐ [Extensive evaluations across 4 benchmarks, 21 scenes, 3 extreme compaction ratios, and CPU/GPU timing]
• Writing Quality: ⭐⭐⭐⭐⭐ [Well-structured, concise mathematical formulations with clear pipeline visualization]
• Value: ⭐⭐⭐⭐⭐ [High practical utility for mobile/web deployment, eliminating multi-view imagery and retraining requirements]

Related Papers

• [ECCV 2026] TanGO: Training-Free 3D Editing via Tangent-Space Guidance and Optimization
• [CVPR 2026] Fast3Dcache: Training-free 3D Geometry Synthesis Acceleration
• [ECCV 2026] PixGS: Pixel-Space Diffusion for Direct 3D Gaussian Splat Generation
• [CVPR 2026] AnchorFlow: Training-Free 3D Editing via Latent Anchor-Aligned Flows
• [ECCV 2026] SplatPainter: Interactive Authoring of 3D Gaussians from 2D Edits via Test-Time Training