KISS-GS: 3D Gaussian Splatting Compression Kept Simple

Conference: ECCV 2026
Paper: ECCV Official
Code: https://fraunhoferhhi.github.io/KISS-GS/
Area: 3D Vision
Keywords: 3D Gaussian Splatting, scene compression, Gaussian compaction, image-based codec, self-organizing codebook

TL;DR

KISS-GS proposes a modular, decoder-first 3DGS compression framework that strictly decouples reconstruction, compaction, encoding, and adaptation, enabling 85× to 319× file-size reductions over vanilla 3DGS at matching visual quality while requiring only ubiquitous, browser-native 2D image decoders.

Background & Motivation

Three-dimensional Gaussian Splatting (3DGS) has rapidly emerged as a foundational representation for novel view synthesis and radiance field modeling, offering photorealistic real-time rendering at high frame rates. However, uncompressed scenes are typically exported as massive .ply files containing millions of explicit Gaussians, regularly exceeding several hundred megabytes or even gigabytes per scene. This excessive storage footprint and heavy memory overhead create a severe bottleneck when deploying 3DGS to bandwidth-constrained web viewers, mobile devices, and AR/VR headsets.

Existing 3DGS compression architectures frequently couple primitive pruning, neural anchor prediction (e.g., Scaffold-GS, HAC++), multi-resolution hash grids, vector quantization, and entropy models directly into end-to-end training regimes. While effective at driving rate-distortion curves upward, this tight integration obscures where compression gains actually come from, creating an "attribution gap" between primitive reduction and per-primitive bit efficiency. Furthermore, training-format coupling locks the compression mechanism to specific reconstruction pipelines: downstream clients are forced to implement complex neural inference modules or custom decoding routines, preventing the use of standard hardware-accelerated image decoding pipelines readily available on end devices.

This paper addresses these limitations by embracing the KISS ("keep it simple, stupid") principle under a strict "decoder-first" philosophy. The authors decouple compression from the reconstruction pipeline entirely, shifting computational complexity to the encoder while restricting the decoder to ubiquitous 8-bit image formats. Core idea: construct an entirely modular four-stage compression pipeline (reconstruction → POPSpa compaction → SOG-XT image-based encoding → encoding-aware fine-tuning) that leverages the 48-fold covariance rotation-scale symmetry (PRAS) and self-organizing 2D spherical harmonics codebooks, allowing standard 2D image codecs to achieve rate-distortion performance that matches or outperforms complex, tightly coupled neural compression pipelines.

Method

Overall Architecture

KISS-GS structures 3DGS compression into four strictly independent, replaceable pipeline stages: 1. Stage 1: Reconstruction: Accepts any off-the-shelf 3DGS .ply point cloud (e.g., standard INRIA or gsplat MCMC models) without requiring custom anchor grids or specialized training losses; 2. Stage 2: POPSpa Compaction: Prunes redundant primitives in a post-training setting via a two-stage rendering error metric (\(\Delta\text{SE}\)) combined with \(\ell_0\) optimize-sparsify refinement and effective-rank regularization, achieving an initial 15.7× reduction in primitive count; 3. Stage 3: SOG-XT Image Encoding: Projects compacted Gaussian attributes onto regular 2D image grids. It applies signed-log spatial contraction with dual-byte-plane PLAS sorting for positions, utilizes self-organizing 2D k-means codebooks with UV indexing for spherical harmonics, and introduces PRAS to smooth rotation and scale grids across 48 equivalent covariance parameterizations, reducing file size by an additional 6.6×; 4. Stage 4: Encoding-Aware Fine-Tuning (Optional): Freezes the discrete grid assignments, codebook UV indices, and active mask while backpropagating rendering error through a straight-through estimator (STE) quantization loop for 4k steps, securing an additional 2.2× rate-distortion gain without modifying the output container or decoder logic.

The complete data flow and modular transitions are illustrated below:

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Input 3DGS Scene<br/>Standard .ply / 30k iterations"] --> B["POPSpa Compaction<br/>Two-stage error pruning + ℓ0 refinement & erank reg"]
    B --> C["SOG-XT Image Encoding<br/>Upper & lower byte-plane PLAS spatial sorting"]
    C --> D["SOG-XT Self-Organizing 2D Codebook<br/>k-means clustering + PLAS centroid sorting + UV packing"]
    D --> E["PRAS Covariance Symmetry Smoothing<br/>48-fold equivalence class multiscale filter matching"]
    E --> F{"Need further compression?"}
    F -->|No: Pure post-hoc codec| G["SOG-XT Standard Image Container<br/>8-bit WebP image planes + YAML metadata"]
    F -->|Yes: Additional 4k steps| H["Encoding-Aware Fine-Tuning<br/>STE straight-through quantization + rendering refinement"]
    H --> G

Key Designs

1. POPSpa Compaction: Two-Stage Error Pruning with Effective Rank Regularization Addressing the severe redundancy in dense 3DGS scenes containing millions of unpruned primitives, POPSpa provides an independent post-training compaction module that avoids modifying the initial training regime. It computes a per-primitive rendering squared error change \(\Delta\text{SE}_k = \|C_{\text{render}} - C'_{\text{render}}\|^2\) across all training viewpoints in a fast single pass, pruning primitives with the lowest contribution. To prevent severe perceptual degradation under high pruning ratios, POPSpa integrates an alternating optimize-sparsify scheme for 5k steps under an \(\ell_0\) opacity constraint, allowing the remaining Gaussians to redistribute opacity and coverage. Crucially, it applies an effective-rank regularizer to penalize degenerate primitives: $$ \mathcal{L}{\text{erank}} = \sum_k \lambda(\Sigma_k) - 1 + \epsilon, 0) s_3 $$ where }} \max(\text{erank\(\text{erank}(\Sigma_k) = \exp(-\sum_{i=1}^3 p_i \log p_i)\) measures the effective dimensional occupancy of normalized eigenvalues. This penalty suppresses needle-shaped Gaussians (\(\text{erank} \approx 1\)) that cause severe multi-view artifacts, encouraging flat, disk-shaped Gaussians (\(\text{erank} \approx 2\)) that conform cleanly to surface boundaries. After a second \(\Delta\text{SE}_k\) pruning pass and 5k recovery steps (10k post-processing steps total), POPSpa discards roughly 90% of primitives to achieve a 15.7× compaction ratio.

2. SOG-XT Self-Organizing 2D Codebook: High-Dimensional SH Vector Quantization with Spatial UV Indices Because high-order spherical harmonics (SH) coefficients account for over 41% of total storage and exhibit noisy spatial variations resistant to image coding, SOG-XT decouples color into a 0th-order DC term \(f_{\text{dc}}\) (stored as an 8-bit RGB image) and higher-order AC coefficients \(f_{\text{rest}}\) (15 parameters per channel). For \(f_{\text{rest}}\), it builds a k-means codebook of size \(K = S^2\) (\(S \in [8, 256]\) multiples of 8, capped at 65,536 entries). Whereas prior systems sort centroids lexicographically—causing adjacent indices to jump erratically across color space—SOG-XT arranges the cluster centroids into a 2D grid using PLAS sorting. Consequently, neighboring 2D coordinates \((u, v)\) correspond to visually and numerically similar color profiles. Each Gaussian only stores two 8-bit UV index channels, while the 2D codebook is folded into a compact \(3 \times 5\) tiled RGB image, producing dramatic compressibility gains in standard 2D image encoders without losing visual fidelity.

3. PRAS Covariance Symmetry Smoothing: Exploiting 48-Fold Equivalence Classes to Remove Grid High-Frequency Jitter Mapping unstructured 3D Gaussians into a 2D image grid routinely creates high-frequency parameter chatter between adjacent pixels, sharply reducing image compression efficiency. The authors observe that the mapping from a 3D covariance matrix \(\Sigma\) to rotation quaternions and scaling vectors \((q, s)\) is strictly one-to-many, admitting an equivalence class of 48 distinct parameterizations: (i) \(3! = 6\) scale permutations balanced by \(90^\circ\) axis rotations, (ii) \(2^3 = 8\) eigenvector reflections yielding 4 proper rotation matrices with \(\det(R)=1\), and (iii) quaternion double-cover duality where \(q\) and \(-q\) define identical 3D rotations (\(6 \times 4 \times 2 = 48\)). Parallel Representative Assignment Smoothing (PRAS) leverages this insight by running multiscale low-pass filtering on quantized parameter proxy grids across exponentially decreasing blur radii. For every Gaussian primitive, PRAS evaluates all 48 equivalent candidate tuples and assigns the representative that minimizes the \(\ell_1\) distance to the spatially smoothed target grid. By eliminating artificial parameter divergence without changing underlying 3D geometry or grid positions, PRAS allows quaternion quantization to be coarsened from 255 levels down to 99 levels without perceptual degradation.

4. Encoding-Aware Fine-Tuning: Straight-Through Quantization Adjustment with Fixed Output Layout To recover slight precision drops caused by uniform quantization, KISS-GS offers an optional 4k-step adaptation stage. The discrete codec layout—including the active mask, 2D PLAS primitive assignment, and codebook UV coordinates—is held strictly constant to preserve full forward compatibility with the simple image decoder. Continuous Gaussian attributes are mapped to quantized image tensors during the forward pass and rendered, while gradients are routed through rounding operations using a straight-through estimator (STE). PRAS is periodically re-applied during fine-tuning to keep parameters aligned with smooth covariance equivalence states. This closed-loop adaptation yields an additional 2.2× compression boost while maintaining 100% byte-level compatibility with the un-tuned SOG-XT container.

Loss & Training

During the 10k POPSpa post-processing phase, the training objective combines photometric reconstruction loss with the effective rank penalty: $$ \mathcal{L} = (1 - \lambda_{\text{D-SSIM}})\mathcal{L}1 + \lambda}}\mathcal{L{\text{D-SSIM}} + \mathcal{L} $$ In the optional 4k-step encoding-aware fine-tuning phase, a lightweight Total Variation (TV) smoothness penalty is imposed directly on the quantized image tensors alongside the rendering loss to further guide attributes toward low-entropy, codec-friendly configurations.}

Key Experimental Results

Main Results

Under the standardized 3DGS benchmark protocol, file-size reduction factors over uncompressed INRIA 3DGS (40k iterations) at matching reference quality (INRIA-Q) are summarized below (higher reduction indicates superior compression efficiency):

Method	Tanks and Temples (PSNR / SSIM / LPIPS)	Mip-NeRF 360 (PSNR / SSIM / LPIPS)	Deep Blending (PSNR / SSIM / LPIPS)	Synthetic NeRF (PSNR / SSIM / LPIPS)
CodecGS (ICCV 2025)	53×* / - / -	72× / 72× / -	76× / 76× / -	n/a / n/a / n/a
ContextGS (NeurIPS 2024)	42× / 42× / -	55× / 55× / -	187× / 187× / -	n/a / n/a / n/a
HAC++ (TPAMI 2025)	77×* / 68× / -	70× / 36× / -	156× / 156× / -	- / - / -
KISS-GS (SOG-XT w/o FT)	227× / 104× / 60×	104× / 73× / 40×	- / - / -	10× / - / -
KISS-GS (SOG-XT + FT)	319× / 131× / 72×	228× / 109× / 64×	85× / 98× / -	21× / 14× / 14×

Note: Entries with * indicate lower bounds where the smallest available operating point already exceeds INRIA-Q; - indicates that INRIA-Q was not reached within evaluated ranges. On real-world datasets, KISS-GS achieves a 228× reduction on Mip-NeRF 360 and a 319× reduction on Tanks and Temples, substantially outperforming HAC++.

Ablation Study

A component-wise leave-one-out ablation of the SOG-XT encoding format on the Bicycle scene (256k primitives, baseline size 3.878 MB) is shown below:

Configuration	Size [MB]	Size Change \(\Delta\text{Size}\)	\(\Delta\text{PSNR}\) [dB]	\(\Delta\text{SSIM}\)	\(\Delta\text{LPIPS}\)	Note
SOG-XT Full Pipeline	3.878	0	24.23 (base)	0.6818 (base)	0.3540 (base)	Full model
w/o SH AC codebooks	7.313	+3,434,816 B	+0.2320	+0.00790	-0.00579	Removing VQ causes file size to expand by 88.6%
w/o WebP image compression	6.908	+3,030,148 B	+0.0000	+0.00000	+0.00000	Demonstrates role of native image compression
w/o quaternion u8 quantization	6.427	+2,548,718 B	+0.0317	+0.00147	-0.00067	Storing float rotations balloons size by 65.7%
w/o primitive PLAS sorting	4.493	+614,851 B	+0.0059	+0.00022	-0.00036	Loss of 2D spatial coherence degrades entropy coding
w/o centroid PLAS sorting	3.920	+42,416 B	+0.0000	+0.00000	+0.00000	Zero-cost gain: Smooth centroid layout saves 42 KB
w/o label UV packing	3.890	+12,142 B	+0.0000	+0.00000	+0.00000	Zero-cost gain: Packing UV indices saves 12 KB
w/o PRAS covariance smoothing	3.866	-11,810 B	-0.1104	-0.00538	+0.00273	Omitting PRAS degrades PSNR (-0.11 dB) despite saving 11 KB
w/o means signed-log remapping	3.359	-519,272 B	-7.5508	-0.37864	+0.22151	Without space contraction, 16-bit quantization collapses

Key Findings

• Clean Stage Attribution: On Mip-NeRF 360, starting from a 738 MB .ply file, POPSpa compaction yields a 15.7× reduction (47.1 MB), SOG-XT encoding yields 6.6× (7.13 MB), and fine-tuning adds 2.2× (3.23 MB), combining for an exact 228.4× overall reduction.
• PRAS Unlocks Aggressive Rotation Quantization: Ablations confirm that without PRAS smoothing, quaternion quantization must use 255 bins to prevent severe rendering degradation; with PRAS, quantization coarsening to 99 bins achieves identical fidelity.
• SH Codebooks Provide the Largest Footprint Reduction: High-order spherical harmonics account for over 41% of uncompressed data. Restricting codebook size to \(S \le 256\) with 2D PLAS ordering prevents more than 3.4 MB of redundant storage without visible quality loss.

Highlights & Insights

• Discrete Smoothing over 48 Covariance Symmetries (PRAS): Rather than adding artificial continuous regularizers during reconstruction, PRAS exploits the exact physical symmetries of Gaussian covariance matrices to choose optimal representatives from a discrete 48-element equivalence class, eliminating high-frequency image encoding noise at zero quality cost.
• Decoder-First System Architecture: By refusing to deploy complex neural decoders (such as MLPs or anchor feature lookups), KISS-GS demonstrates that a sophisticated encoder paired with native 8-bit image formats (WebP/PNG) can match and surpass state-of-the-art neural compression methods in rate-distortion efficiency.
• Dual-Byte-Plane Spatial Sorting: When mapping 16-bit continuous spatial positions into 2D raster grids, KISS-GS weights the coarse upper byte plane more heavily than the fine lower byte plane during PLAS sorting, maintaining global structural continuity while optimizing local residual compressibility.

Limitations & Future Work

• Performance Boundary on Inconsistent Capture Data: On the Deep Blending benchmark characterized by exposure fluctuations and non-Lambertian reflections, KISS-GS (85×-98×) trails anchor-based neural baselines like HAC++ (156×), which absorb capture inconsistencies into continuous neural features.
• Encoder Optimization Overhead: While client-side decompression executes in under one second on standard CPUs, encoding requires multi-stage error backpropagation, multiscale spatial smoothing (PRAS), and global PLAS permutation optimization.
• Future Directions: Extending PRAS equivalence smoothing to SO(3)-equivariant color spaces for spherical harmonics, and integrating fast non-iterative geometric compaction to accelerate encoding time.

Related Work & Insights

• vs HAC / HAC++ (ECCV 2024 / TPAMI 2025): HAC++ employs multi-resolution hash grids and lightweight anchor MLPs, tightly binding compression to training and requiring custom neural runtime engines. In contrast, KISS-GS decouples compression entirely, achieves superior rate-distortion performance on real-world datasets (Tanks & Temples, Mip-NeRF 360), and decodes instantaneously via browser-native image codecs.
• vs SOG / .sog (Morgenstern et al. 2024 / PlayCanvas 2025): Early SOG tied smoothing regularizers directly to training, while the official .sog format relies on 1D Morton curves and lexicographical centroid sorting, causing irregular rate-distortion curves. SOG-XT introduces dual-byte PLAS sorting, self-organizing 2D codebooks, and PRAS covariance smoothing to dramatically elevate compression ratios while maintaining standard browser compatibility.

Rating

• Novelty: ⭐⭐⭐⭐ [The 48-fold covariance rotation-scale equivalence smoothing (PRAS) is an exceptionally elegant exploitation of geometric symmetry for discrete image encoding]
• Experimental Thoroughness: ⭐⭐⭐⭐⭐ [Exemplary attribution analysis separating compaction, encoding, and adaptation gains across four standard benchmarks with compute-matched recomputations of HAC++]
• Writing Quality: ⭐⭐⭐⭐⭐ [Clear, compelling narrative rooted in Dijkstra's simplicity philosophy, supported by concise mathematical formulations and well-designed visualizations]
• Value: ⭐⭐⭐⭐⭐ [Delivers immediate industrial value for web-first, mobile, and AR/VR radiance field streaming by eliminating custom neural decoding dependencies]