Splatwizard: 3DGS Compression Benchmark

• Splatwizard is a unified benchmarking toolkit for 3D Gaussian Splatting compression that standardizes evaluation with a common training and evaluation pipeline.
• It modularizes components like rasterizers, codecs, and metrics to ease rapid prototyping and reduce engineering overhead.
• The toolkit enables multidimensional evaluation—including PSNR, FPS, memory usage, and geometric fidelity—ensuring fair comparisons across methods.

Splatwizard is a unified benchmark toolkit for 3D Gaussian Splatting (3DGS) compression, introduced to make evaluation of compression methods standardized, reproducible, and comprehensive while also reducing the engineering burden of implementing new methods (Liu et al., 31 Dec 2025). It is positioned simultaneously as a benchmarking framework for fair comparison of existing 3DGS compression methods and as a development toolkit for constructing new methods with less boilerplate and fewer engineering incompatibilities. The toolkit addresses a setting in which raw 3DGS scenes are large and redundant, compression methods differ substantially in preprocessing and systems design, and existing benchmarks often emphasize photorealistic image quality while underreporting geometric accuracy and system-level properties.

1. Motivation and problem setting

The immediate motivation for Splatwizard is the practical cost of uncompressed 3DGS representations. A scene may contain millions of Gaussian ellipsoids, and in practice can require up to $10^7$ Gaussians, resulting in hundreds of megabytes of storage (Liu et al., 31 Dec 2025). This creates a deployment bottleneck for real systems and has led to a rapid proliferation of compression methods.

The paper characterizes the resulting landscape as highly heterogeneous. Existing methods differ in preprocessing and pruning logic, rasterizers, quantization schemes, entropy models and codecs, training schedules, and decoding assumptions. This heterogeneity makes it difficult to compare methods “apples to apples,” especially when published comparisons rely on reported numbers rather than re-runs or cover only a subset of methods. The benchmark is therefore framed as an infrastructure response to methodological fragmentation rather than as a single compression algorithm.

A central argument is that evaluation criteria for 3DGS compression must be multidimensional. Existing benchmarks and surveys are described as insufficient because they focus mostly on photorealistic metrics like PSNR, ignore geometric accuracy even though 3DGS is fundamentally a 3D representation, and do not consistently report FPS, memory, bitrate, and latency. The paper ties this directly to application requirements: streaming needs low encoding/decoding latency, robotics needs high throughput and low memory, and surface reconstruction tasks need geometric fidelity, not just good images. This suggests that Splatwizard is intended to formalize compression benchmarking as a systems-and-representation problem rather than a narrow image-quality task.

2. Design goals and overall organization

Splatwizard defines a unified training and evaluation pipeline for 3DGS compression around three design goals: standardization, decoupling, and broader metric coverage (Liu et al., 31 Dec 2025). Standardization is implemented through a common pipeline for data loading, model training, compression or encoding, and rendering evaluation. Decoupling is implemented by separating key components into interchangeable modules such as rasterizers, entropy modules, codecs, and reconstruction components. Broader metric coverage is implemented by going beyond PSNR-style rendering quality to include bitrate or model size, number of Gaussians, FPS, peak memory usage, and geometric reconstruction accuracy.

The internal organization is centered on a scheduler-based training workflow and a modular library structure. The paper describes 3DGS training as five stages:

1. pre-scheduler execution
2. rendering
3. loss calculation
4. post-scheduler execution
5. optimizer update

This workflow is designed for methods with phase-specific behavior. The scheduler can trigger pruning, densification, SH-degree increase, quantization switching, entropy-constrained training, and distillation at designated iterations. The paper illustrates the abstraction with the registration pattern:

$360^\circ$3

The significance of this design is not only syntactic. The paper presents many 3DGS methods as temporally structured procedures rather than fixed loops, and the scheduler is intended to expose that structure directly. A plausible implication is that the framework treats iteration scheduling as a first-class experimental variable, which is particularly relevant for compression methods whose behavior changes substantially across training phases.

3. Modular libraries and implementation support

The toolkit is divided into several libraries, each targeting a recurrent engineering pain point in 3DGS compression research (Liu et al., 31 Dec 2025).

Library	Scope	Examples stated in the paper
Rasterizer Lib	Rasterizers and rendering variants	standard 3DGS rasterizer, accelerated variants, depth-enabled variants, importance-score rasterizers, approximate Hessian-based importance variants, 2DGS, TrimGS
Metrics Lib	Loss computation and evaluation	PSNR, SSIM, LPIPS, Chamfer distance
Codec Lib	Compression-related modules	STE quantization, noise relaxation, vector quantization, training-aware quantization, hash grids, triplanes, arithmetic coding, rANS, Huffman coding
Reconstruction Lib	3DGS-to-mesh evaluation bridge	rendering depth maps, TSDF fusion, Open3D reconstruction

The paper emphasizes that this modularity is not purely organizational. Researchers can mix and match components from different methods, including using different rasterizers at different phases. This is especially relevant for reconstruction-oriented methods such as 2DGS and TrimGS, which appear in the rasterizer library specifically to support evaluation regimes that are not limited to standard 3DGS rendering.

For implementation of new models, Splatwizard provides a flexible module system based on PyTorch that supports JIT loading, which compiles at runtime, and AOT compilation, which builds during installation. The stated motivation is that 3DGS research often requires changing rasterizers and integrating custom CUDA/C++ entropy modules, which typically causes build dependencies, linker issues, version conflicts, and cross-platform problems. The framework is intended to mitigate these issues while preserving a Python-facing workflow.

The scheduler-based integration strategy complements this module system. New methods can be integrated by registering their operations at specific iterations rather than rewriting the full training loop. The paper specifically identifies pruning then distillation, quantization-aware training, entropy-constrained training, and hybrid rasterizer pipelines as settings that benefit from this design. In this sense, Splatwizard functions as both an execution framework and a compatibility layer.

4. Evaluation pipeline and benchmark protocol

The evaluation pipeline benchmarks 3DGS compression along several axes at once (Liu et al., 31 Dec 2025). Rendering quality is measured with PSNR, SSIM, and LPIPS against ground-truth views. Rate-distortion behavior is evaluated through curves over bitrate, Gaussian count, and image quality metrics. Rendering speed is measured as rendering frame rate (FPS). Memory and computational efficiency are represented by peak GPU memory usage during rendering. Geometric accuracy is assessed through Chamfer distance for reconstructed point clouds and Chamfer distance for reconstructed meshes.

The geometric component is presented as a major contribution because previous compression benchmarks largely neglected it. The reconstruction library renders depth maps, fuses them using TSDF, and uses Open3D for reconstruction. This explicitly treats 3DGS as a 3D representation whose fidelity can be interrogated through surface reconstruction, not only through view synthesis.

The benchmark protocol is defined over six datasets: Mip-NeRF 360, Tanks and Temples, Deep Blending, BungeeNeRF, NeRF Synthetic, and DTU. Their roles are specified in the paper: Mip-NeRF 360 for unbounded $360^\circ$ scenes, Tanks and Temples for real scenes with complex geometry, Deep Blending for indoor and outdoor view synthesis, BungeeNeRF for extreme multi-scale scenes, NeRF Synthetic for 8 Blender-rendered scenes, and DTU for geometric ground-truth evaluation.

Several reproducibility constraints are stated explicitly. All methods in the model zoo were evaluated using the same protocols; training and testing splits were kept consistent; encoding and decoding models were strictly isolated for bitrate evaluation to avoid data leakage; all methods encode complete information into a single binary file; and decoding uses a freshly initialized model plus the binary file. The supplementary material states that all training and testing were done on a single RTX 3090. Together, these constraints define Splatwizard less as a collection of scripts than as a benchmark protocol with explicit isolation assumptions.

5. Formal definitions and supported learning strategies

The paper includes several equations to illustrate the kinds of compression strategies that the framework can represent (Liu et al., 31 Dec 2025). These are presented in the description of ChimeraGS and in the pruning and distillation machinery.

For Speedy-Splat, the reparameterized Hessian-based importance score is given as

$$\tilde{U}_i = \log \left| \nabla_{g_i} I_\mathcal{G} \nabla_{g_i} I_\mathcal{G}^T \right|,$$

with

$g_i = e^q,\quad q = -\frac{1}{2}(p - \mu_{i_{2D})\boldsymbol{\Sigma}_{i_{2D}^{-1}(p - \mu_{i_{2D})^T .$

Because $\log$ is monotonic, the importance is rewritten as

$\tilde{U}_i = (\nabla_{g_i} I_\mathcal{G})^2.$

This formulation is used for efficient pruning.

For learnable SH pruning with masks, the degree-3 spherical harmonic parameters use binary masks $M \in \{0,1\}^N$: $\hat{\mathbf{c}_n^{(3)} = M_n \mathbf{c}_n^{(3)} .$ Differentiability is introduced by a straight-through estimator: $M_n = \operatorname{sg}\big(\mathbbm{1}[\sigma(m_n) > c] - \sigma(m_n)\big) + \sigma(m_n),$ and the sparsity regularizer is

$$\mathcal{L}_m = \frac{1}{N}\sum_{n=1}^{N}\sigma(m_n).$$

For teacher-student compression by distillation, the paper defines

$360^\circ$0

under the same camera pose $360^\circ$1, with final loss

$360^\circ$2

These equations are not presented as the definition of Splatwizard itself, but as evidence that the toolkit can accommodate learning-based compression strategies involving pruning, masking, quantization, and distillation. A plausible implication is that the benchmark’s scope extends beyond static codecs to methods whose compression behavior is entangled with training dynamics.

6. Model zoo, empirical conclusions, and ChimeraGS

The paper states that the authors reproduced several representative compression methods within the framework while minimizing deviations from the original papers by matching key hyperparameters, reusing shared modules where possible, implementing only method-specific innovations separately, and fixing some issues in original code that affected consistency (Liu et al., 31 Dec 2025). The model zoo includes vanilla 3DGS, Trimming the Fat, PUP-3DGS, Speedy-Splat, LightGaussian, MesonGS, C3DGS, Compact3DGS, HAC, and CAT-3DGS.

The resulting benchmark produces multi-dimensional comparisons including rate-distortion plots, PSNR, SSIM, LPIPS, number of Gaussians, bitrate, FPS, peak memory usage, and Chamfer distance for geometry. The paper summarizes several practical conclusions from these evaluations: hybrid implicit plus 3DGS methods can achieve strong rate-distortion performance; quantization-based rate-distortion methods are competitive; pruning-based methods often offer better speed; geometric quality does not always align with photorealistic quality; and some compression methods can preserve or even improve geometric reconstruction.

These conclusions are important because they challenge a common simplification in neural rendering evaluation: that higher image fidelity necessarily implies a better representation. In the Splatwizard benchmark, photorealistic fidelity and geometric reconstruction are treated as partially decoupled axes. This suggests that method ranking may change substantially depending on whether the downstream task is rendering, deployment, or geometry extraction.

To demonstrate the framework’s flexibility, the authors built a new model called ChimeraGS using Splatwizard. It combines compact initialization from SpeedySplat, learnable SH pruning, distillation, separate codebooks for degree-2 and degree-3 SH parameters, Morton-order sorting before encoding, and compatibility with rendering accelerators like FlashGS and TC-GS. The role of ChimeraGS is illustrative rather than canonical: it is presented as evidence that the toolkit supports rapid method prototyping in addition to standardized benchmarking.

7. Significance, scope, and common misconceptions

Splatwizard is best understood as evaluation infrastructure rather than as a new 3DGS compression algorithm (Liu et al., 31 Dec 2025). Its stated practical benefits are fair comparison across methods, reproducible experiments, reduced engineering overhead, support for both photorealistic and geometric metrics, better understanding of speed-memory-quality trade-offs, and easy integration of new compression and rendering modules. The paper therefore frames the toolkit as a shared, extensible evaluation infrastructure for the 3DGS compression community.

A common misconception would be to treat compression benchmarking as equivalent to reporting PSNR or LPIPS at a given bitrate. The paper explicitly rejects that narrowing of scope by incorporating FPS, peak memory usage, Gaussian count, bitrate, and geometric reconstruction accuracy. Another misconception would be that reproducing prior methods inside a common framework necessarily erases implementation differences. The paper instead emphasizes controlled reproduction: matching key hyperparameters, reusing shared modules where possible, and isolating encoding and decoding to avoid leakage, while still acknowledging the need to fix some issues in original code that affected consistency.

In this sense, Splatwizard’s larger significance lies in moving 3DGS compression from a collection of isolated implementations toward a standardized benchmark ecosystem. This suggests a change in research practice as much as a software contribution: compression methods are evaluated not only by their reported numbers, but by their behavior under a common execution model, common protocol, and common set of system-level and geometric criteria.