3D Gaussian Splatting renders a scene by drawing millions of small, semi-transparent 3D ellipsoids, called splats, onto the screen. It is fast enough for interactive use, but a single scene can occupy about a gigabyte, and that footprint strains GPU memory and bandwidth. Existing compressors shrink the colors, shapes and orientations of the splats by roughly 45 to 50 times. They leave the splat positions at full precision, because rounding the positions tears surfaces apart. Once everything else is compressed, positions become the main storage cost.
We propose to quantize positions aggressively and to treat the rounding error as a known amount of random positional jitter rather than as damage to repair. Two ingredients make this work. First, we round each splat's position in its own principal-axis frame, with a step size proportional to that splat's size along each axis. Second, we add a pseudo-random offset before rounding and remove the same offset when decoding ("dithering"). Together these make the error independent of the scene and of a known size. The renderer can then account for that error inside each splat's own shape. Decoding is a few arithmetic operations per splat, so frame rate is unchanged and no neural network enters the rendering loop.
Core Claim
The claim is that positional quantization error in Gaussian splatting can be made statistically simple and then absorbed into the splat representation, at no rendering cost. This would allow far fewer bits per position than the 16-bit or full-precision coordinates kept by current compressors, at equal image quality.
The idea comes from two results in the quantization-noise literature. Gaussian Approximation of Quantization Error for Estimation from Compressed Data shows that in high dimensions, compression error behaves like additive white Gaussian noise. The equivalent variance is $\sigma^2 = 1/(2^{2R}-1)$ for normalized data at $R$ bits per dimension, so estimators designed for Gaussian noise can be applied directly to compressed data. PTQD shows that hardware quantization noise inside a diffusion model can be folded into the model's own noise schedule, with a separate correction for systematic bias, instead of being fought.
Our analogue of PTQD's schedule is the splat covariance, the matrix describing each ellipsoid's size and orientation. The key fact is that a Gaussian splat whose center is displaced by independent zero-mean noise with covariance $D_i$ has expected footprint $\Sigma_i + D_i$, where $\Sigma_i$ is splat $i$'s covariance. For Gaussian noise this is exact. For uniform noise it is a close approximation when the step is small relative to the splat.
One gap must be addressed honestly. The Kipnis–Reeves equivalence is a high-dimensional result, and a single 3D position is not high-dimensional. Rounding $3.4$ to $3$ is deterministic, structured error. We therefore do not rely on dimension to make the error well behaved. Subtractive dithering, the universal quantization that Bridging the Gap between Diffusion Models and Universal Quantization for Image Compression uses to close the "discretization gap" in diffusion codecs, makes the error exactly uniform and independent of the input in any dimension. Only the shape mismatch between uniform and Gaussian noise remains, and we measure it directly.
Research Program
The scheme stores each splat's position as a coarse grid cell plus a residual. The residual is expressed in the splat's local principal-axis frame and quantized with per-axis step $\Delta_{i,k} = c\, s_{i,k}$. Here $s_{i,k}$ is the splat's scale along axis $k$, and $c$ is a single global knob set by the bit budget. Dither offsets come from a hash of the splat index, so they cost no storage.
Under this rule, the jitter covariance in world coordinates is $D_i = R_i \,\mathrm{diag}(\Delta_{i,k}^2/12)\, R_i^\top$, with $R_i$ the splat's rotation. Because the steps scale with the splat, this simplifies to
$$D_i = \frac{c^2}{12}\,\Sigma_i .$$
In words, every splat is jittered by the same fraction of its own size. A large background splat tolerates a coarse position, while a thin splat on a bicycle spoke gets a fine one. The bits per coordinate are roughly $\log_2(L/(c\,s_{i,k}))$, where $L$ is the grid cell width. This mirrors PTQD's step-aware mixed precision, with splat size playing the role of the diffusion timestep.
Training proceeds in three stages. The first is ordinary 3DGS training. The second is joint training in which each forward pass renders the splats with positions perturbed by fresh dithered-quantization noise at the target $c$. This is the Gaussian-noise counterpart of the noise substitution in Compressing 3D Gaussian Splatting by Noise-Substituted Vector Quantization, but calibrated to the actual rate and applied to positions. The third is a choice of deployment mode. In the "absorbed" mode, the renderer uses covariance $\Sigma_i + D_i$, and training has already learned smaller shapes so that the inflated splats fit the images. In the "realized" mode, the renderer uses the decoded positions as they are, and the remaining non-position parameters are briefly fine-tuned.
Comparing these two modes is the scientific core. The absorbed mode should turn the shattering and floaters caused by misplaced sharp splats into mild, predictable softening. We expect it to win at coarse rates and to converge with the realized mode at fine rates.
Two further analyses ground the theory. First, we test whether the measured per-splat image error matches the error predicted by the expected-footprint model, as a function of $c$. Second, as a secondary probe of the high-dimensional argument, we jointly quantize blocks of neighboring residuals after a shared random rotation, to see whether the error becomes more Gaussian and whether that matters.
The scheme is designed to fit inside existing color and shape compressors. It replaces the uncompressed positions in NSVQ-GS and the 16-bit positions in CompGS's BitQ variant (CompGS). Everything else in those pipelines stays unchanged.
Baselines
The naive reference point is the same pruned and vector-quantized scene with positions left at full precision. This is the NSVQ-GS setting. Its authors report a bicycle scene reduced from about 1.1 GB to about 21 MB and rendering at 103 FPS, against 43 FPS for original 3DGS on an RTX 4070 (NSVQ-GS). Its image quality is the target we must match. Its size is the target we must beat.
The strongest existing practical method is CompGS with BitQ, which applies k-means vector quantization with straight-through gradient training to the other attributes and stores positions at reduced precision. The authors report 1.4 GB scenes reduced to under 20 MB and frame rates often above 300 FPS (CompGS). Lacuna has no per-scene PSNR for NSVQ-GS or CompGS on Mip-NeRF360. The only scene-level quality figure in the file for a compressed 3DGS method is ELMGS-medium at 24.08 dB PSNR on Tanks & Temples, cited through the 3DGS compression survey. We will therefore rerun both methods ourselves rather than quote them.
The straight-through training baseline matters most and is built to isolate our key ingredient. It uses identical per-axis bit allocation, but rounds deterministically and trains through rounding with a straight-through gradient. This tells us whether dithering and the noise model add anything beyond simply spending bits proportionally to splat size. A second ablation keeps the dithered noise during training but drops covariance absorption at deployment. A third uses a uniform world-space step size instead of a size-proportional one.
All methods start from the same trained 3DGS checkpoint and the same pruning. They receive the same number of fine-tuning iterations and an equal hyperparameter search budget per method, and they are timed on one GPU at a fixed resolution. Beating CompGS-BitQ means matching its PSNR within 0.1 dB, its SSIM, and its LPIPS at a smaller total file size, or improving its metrics at equal size, with frame rate unchanged within measurement noise.
Why not just…?
Why not just keep positions at 16 bits, as CompGS does? This is the safe default, and it works. Once color and shape are compressed to codebook indices, however, three 16-bit coordinates per splat make up a large share of the remaining bytes. Our rate-distortion curve for position bits will show directly whether coarser rates are reachable. If quality collapses below 16 bits for every method, including ours, the proposal fails, and that is a clean negative result.
Why not just train through rounding with a straight-through gradient and then fine-tune? This is the real threat. If deterministic rounding with the same size-proportional allocation matches our method, the contribution reduces to the allocation rule. NSVQ-GS reports that straight-through training suffers gradient mismatch and loses sharp boundaries relative to noise substitution, which suggests the noise model matters. That evidence concerns codebook attributes, not positions, so the matched-allocation ablation above is the deciding experiment. We will report it whichever way it comes out.
Why not just predict positions from anchors, as structured methods like Scaffold-GS and HAC do? The survey lists anchor-based schemes among the most compact options. The research file also notes that decoding complex entropy models or neural decompressors during rendering adds latency, and it gives no frame-rate numbers for those schemes. Our decoder is a hash and a multiply-add per coordinate. The two approaches are complementary, since anchor offsets can themselves be quantized with our rule. We will report frame rate and decode time alongside size so that this tradeoff is visible.
Why not just clean up the rendered frame with a one-step diffusion model? Generative dequantizers are the natural way to apply quantization-noise equivalence, and OSCAR gets this down to one denoising step on 2D images. In rendering, however, the fastest such system in the file, the one-step DiffPBR, runs at 10 FPS. The foundation-model codec in Lossy Image Compression with Foundation Diffusion Models takes 3.49 s per image. Both are far from the 100+ FPS that compressed splatting already achieves. We therefore absorb the noise analytically, at zero runtime cost.
Proposed Experiments
We evaluate on the nine Mip-NeRF360 scenes (every eighth image held out), Tanks & Temples, and Deep Blending, the benchmarks shared by NSVQ-GS, CompGS and the compression survey. We report PSNR, SSIM, LPIPS, total size, bits per position, frame rate on a fixed GPU, and depth disagreement with the uncompressed model as a geometry check.
The first decisive check is the position rate-distortion sweep over $c$. It compares absorbed, realized, straight-through-matched, uniform-step and 16-bit variants. We predict that the absorbed mode dominates at coarse rates and that its advantage shrinks to zero as $c \to 0$. A flat gap at every rate would suggest that something other than the noise model explains the gain.
The second check tests the noise model itself. We compare measured image error per splat with the error predicted by the expected-footprint formula, and we compare uniform dither against block-rotated quantization, to quantify the uniform-versus-Gaussian mismatch.
The third check is latency. Frame rate with in-shader decoding must equal frame rate with preloaded float positions, and both must stay within noise of the NSVQ-GS and CompGS numbers we reproduce. If compression saves bytes but costs frames, the method has not done its job.
References
- Gaussian Approximation of Quantization Error for Estimation From Compressed Data
- PTQD: Accurate Post-Training Quantization for Diffusion Models
- Bridging the Gap between Diffusion Models and Universal Quantization for Image Compression
- Compressing 3D Gaussian Splatting by Noise-Substituted Vector Quantization
- CompGS: Smaller and Faster Gaussian Splatting with Vector Quantization
- Compression in 3D Gaussian Splatting: A Survey of Methods, Trends, and Future Directions
- OSCAR: One-Step Diffusion Codec Across Multiple Bit-rates
- DiffPBR: Point-Based Rendering via Spatial-Aware Residual Diffusion
- Lossy Image Compression with Foundation Diffusion Models