VoxelGS: Integer-Based 3D Gaussian Compression

• VoxelGS is a 3D Gaussian splatting compression framework that quantizes Scaffold-GS into an integer-type point cloud using differentiable quantization.
• It employs a Laplacian-based rate proxy to effectively reshape attribute distributions and enable efficient run-length and Octree coding.
• VoxelGS demonstrates improved PSNR and reduced bitrate across datasets while maintaining fast training, decoding, and rendering performance.

VoxelGS most commonly denotes the compression framework introduced in "Voxel-GS: Quantized Scaffold Gaussian Splatting Compression with Run-Length Coding," which targets I-3DGS by converting Scaffold-GS into an integer-type Gaussian point cloud through differentiable quantization, constraining entropy with a Laplacian-based rate proxy, and then applying lossless Octree and run-length coding (Fu et al., 19 Dec 2025). In that usage, the central objective is to separate reconstruction from compression, avoid neural entropy models, and preserve rendering quality while reducing storage and bandwidth. The term is not fully standardized across the 3DGS literature: contemporaneous work also uses "VoxelGS" for a voxel-based streaming organization inside StreamingGS (Zhang et al., 9 Jun 2025), while other papers adopt voxel-based Gaussian pipelines without naming them VoxelGS, or use the name only as a code repository identifier (Wang et al., 30 May 2025); (Du et al., 26 May 2026).

1. Conceptual position within 3D Gaussian splatting

Gaussian splatting represents a scene as a set of 3D Gaussian primitives rendered in real time by splatting their screen-space footprints. Each Gaussian typically has a 3D position, shape parameters, opacity, and color or radiance attributes. High-fidelity 3DGS training produces floating-point parameters and large, redundant Gaussian sets, so compression is required for distribution, bandwidth reduction, and standardization. In the Voxel-GS formulation, the starting point is Scaffold-GS, a structured 3DGS representation in which anchor points produce $k$ Gaussians via tiny MLPs; some attributes, including rotation and opacity, are not stored explicitly but are inferred from compact anchor features during rendering (Fu et al., 19 Dec 2025).

Within that setting, Voxel-GS is explicitly positioned against prior neural entropy-model approaches such as A-3DGS. Those approaches jointly optimize reconstruction and an entropy model and directly emit bitstreams from multi-view inputs, but they also incur per-scene neural coder overhead and couple reconstruction tightly to the entropy model. Voxel-GS instead separates reconstruction and compression, uses no trainable entropy parameters, and aims at a compact point cloud with efficient lossless coding and no added distortion during compression. This design aligns with MPEG I-3DGS standardization goals and suggests a codec-oriented interpretation of Gaussian splatting compression rather than an end-to-end learned bitstream generator (Fu et al., 19 Dec 2025).

2. Integer-type representation and differentiable quantization

The core representational move in Voxel-GS is to quantize Scaffold-GS anchors and anchor-conditioned attributes into integers while preserving end-to-end trainability. Anchor positions $P$ are voxelized to a fixed resolution $Q_P$ using straight-through estimator rounding,

$P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$

Duplicate anchors are removed to reduce redundancy and irregularity. Other Scaffold-GS features are quantized as

$$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$

Here, $O$ denotes per-anchor offsets with dimension $3k$, $A$ denotes anchor features with dimension $m$, and $S$ denotes scaling factors with dimension $P$0 (Fu et al., 19 Dec 2025).

The exported representation therefore stores integer coordinates together with integer-coded attributes of total dimension $P$1 per anchor. In the reported parameterization, $P$2 and $P$3, with $P$4, $P$5, and $P$6. Rotation and opacity are not saved; they are reconstructed at render time by the tiny MLPs from $P$7. This preserves the structured compactness of Scaffold-GS while making the representation directly compatible with lossless point-cloud coding (Fu et al., 19 Dec 2025).

Quantization is not active throughout the full training run. Voxel-GS uses 30,000 steps per scene, with anchor pruning and adaptive control from steps 1,500 to 15,000. Quantization and the rate proxy are disabled until 15,000 steps for stable reconstruction and enabled only after the anchor count is fixed. This schedule reflects a practical distinction between first obtaining a stable reconstruction and then reshaping its statistics into a compressible integer distribution (Fu et al., 19 Dec 2025).

3. Laplacian rate proxy and rate–distortion objective

Voxel-GS replaces learned entropy models with a lightweight Laplacian-based proxy for the bitrate of run-length coding applied to integerized attributes. For each integer value $P$8, the proxy defines

$P$9

where $Q_P$0 and $Q_P$1 are computed from the current attribute samples to be encoded. For a Laplace distribution with location $Q_P$2 and scale $Q_P$3,

$Q_P$4

The associated rate term is

$Q_P$5

No rate constraint is applied to $Q_P$6 because anchor positions are coded by Octree and their bitrate is stable during training for a fixed voxel resolution (Fu et al., 19 Dec 2025).

The full optimization objective is

$Q_P$7

with $Q_P$8, $Q_P$9, and $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$0. The intended effect is to penalize spread and heavy tails in the quantized attribute distributions, encouraging concentration around $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$1 and thereby increasing repeated integer symbols when anchors are traversed in Morton order. Since run-length coding benefits from repeated consecutive symbols, the rate proxy is designed to approximate a coding objective without modeling full symbol contexts (Fu et al., 19 Dec 2025).

Empirically, the paper reports that the expected coding rate of run-length coding can be approximated as $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$2, with $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$3 and correlation coefficient $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$4 between the proxy estimate and actual RLC bitrates. On the "chair" scene from Synthetic-NeRF, adding $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$5 makes attribute histograms closer to Laplacian, reduces entropy by 33%, and shrinks the bitstream from 1.59 MB to 0.91 MB while keeping PSNR essentially unchanged at 34.15 dB to 34.14 dB (Fu et al., 19 Dec 2025). This suggests that much of the compressibility gain comes not from a stronger back-end coder, but from reshaping the learned attribute statistics before export.

4. Lossless coding organization and decoding

After training, Voxel-GS exports an integer-type Gaussian point cloud and compresses it with a two-stage lossless pipeline. Geometry, represented by integer anchor coordinates $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$6 on a voxel grid of resolution $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$7, is coded by the Octree branch of G-PCC, specifically tmc13v23. Octree traversal determines the geometry order, and Morton mapping is used to impose spatial locality. Under the decoded geometry in Morton order, the attribute streams $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$8, $P_Q = \mathrm{STE\_ROUND}(P \cdot Q_P)/Q_P.$9, and $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$0 are then losslessly run-length coded directly in bypass mode (Fu et al., 19 Dec 2025).

Run-length coding emits pairs of symbol value and run length for consecutive identical integers. No additional entropy coding beyond RLC is used in the reported configuration. The design relies on two interacting mechanisms: spatial locality induced by Morton ordering, and symbol repetition induced by proxy-constrained quantization. Because the attribute streams are aligned to the geometry order, the coding stage is simple and scene-specific entropy parameters do not need to be transmitted (Fu et al., 19 Dec 2025).

Decoding mirrors the same structure. The Octree reconstructs integer anchor positions, RLC decodes the attribute streams aligned with Morton order, and the tiny MLPs reconstruct rotation and opacity from $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$1. Combined with $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$2 and $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$3, the $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$4 Gaussians per anchor are recovered and rendered. Since the final compressed asset is already integerized before lossless coding, there is no post-compression distortion beyond the distortion already controlled during training (Fu et al., 19 Dec 2025).

5. Quantitative behavior, complexity, and operating regime

The reported experiments cover Synthetic-NeRF, Mip-NeRF360, Tanks and Temples, and DeepBlending, with PSNR, SSIM, LPIPS, and bitstream size as evaluation metrics. Relative to I-3DGS baselines, Voxel-GS is reported to attain the best average performance among standard codecs. Against HybridGS, it improves PSNR by 0.85 dB on average while reducing bitrate by 45%. Averaged across three large-scale datasets, Voxel-GS achieves 26.88 dB at 17.92 MB, comparable to CompGS at 26.26 dB and 17.47 MB. Across four datasets, Voxel-GS reaches 28.34 dB at 6.94 MB, close to HAC at 28.70 dB and 7.22 MB despite HAC using learned entropy models. On smaller scenes such as Synthetic-NeRF, it outperforms ContextGS in rate–distortion because its parameterless proxy is efficient under limited bitrate budget (Fu et al., 19 Dec 2025).

The computational profile is also part of the method’s identity. On Tanks and Temples, training time is 14.01 min for Voxel-GS versus 24.67–46.60 min for HAC++ and CompGS. Encoding and decoding are 1.28 s and 1.47 s, versus 8.13 s and 13.33 s for HAC++, corresponding to about 85% time savings. Runtime rendering remains essentially unchanged relative to Scaffold-GS, with 111.8 FPS for Voxel-GS and 112.1 FPS for Scaffold-GS. GPU memory is reported as 6 GB for Voxel-GS versus 10–13 GB for HAC++ and CompGS (Fu et al., 19 Dec 2025).

The method also exposes a clear operational hierarchy of quantization controls. $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$5 is described as the most effective and stable knob for rate control; the paper uses $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$6 for Synthetic-NeRF and $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$7 for Mip-NeRF360, Tanks and Temples, and DeepBlending. $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$8 is critical for fidelity, and values below 8 significantly hurt PSNR, so $$F_Q = \mathrm{STE\_ROUND}(F \cdot Q_F), \qquad F \in \{P,O,A,S\}.$$9 is recommended. $O$0 and $O$1 remain secondary fine-tuning knobs, with defaults at 1. This division of control suggests that geometry resolution dominates the stable rate budget, while attribute quantization is used primarily for fine adjustment (Fu et al., 19 Dec 2025).

6. Limitations, trade-offs, and ambiguity of the name

Voxel-GS inherits several limitations from its design choices. The Laplacian proxy is accurate on the tested datasets, but scenes with highly irregular or multimodal attribute distributions may deviate from the Laplacian prior, reducing proxy accuracy and yielding suboptimal RLC bitrate. Because no explicit entropy constraint is applied to positions during training, geometry bitrate depends mostly on $O$2 and scene structure; deeply irregular geometry may still incur higher Octree cost. The method also reports that adding the proxy can activate more derived Gaussians to maintain quality, dispersing offset distributions and partially offsetting savings on $O$3. More generally, without a powerful learned entropy coder, RLC may be suboptimal for some distributions, even if the proxy closes much of the gap in practice (Fu et al., 19 Dec 2025).

A recurrent misconception is that "VoxelGS" denotes a single well-defined method across the literature. In fact, the name is polysemous. In StreamingGS, "VoxelGS" refers to a voxel-based streaming paradigm that reorganizes Gaussians into a regular 3D grid and renders voxel-by-voxel in a memory-centric pipeline; its emphasis is DRAM traffic reduction, not compression of integer-type Scaffold-GS assets (Zhang et al., 9 Jun 2025). In "Adaptive Voxelization for Transform coding of 3D Gaussian splatting data," the authors present a voxel-based 3DGS compression framework built around adaptive octrees, GPCC, and RAHT, but the paper explicitly states that it does not introduce a method named "VoxelGS" (Wang et al., 30 May 2025). In "Gaussian-Voxel Duet," the public code repository is named VoxelGS, yet the underlying method is a dual-scaffold hybrid representation for monocular surface reconstruction rather than an I-3DGS codec (Du et al., 26 May 2026). An older and unrelated usage describes a voxel-based global illumination system built on voxel cone tracing rather than Gaussian splatting (Kahl, 2021).

For that reason, the most precise contemporary encyclopedic usage is to reserve Voxel-GS for the 2025 compression framework based on differentiable quantization, a Laplacian rate proxy, and lossless Octree plus run-length coding (Fu et al., 19 Dec 2025), while recognizing that adjacent literature uses the same or similar label for distinct voxel-centric Gaussian pipelines.