FlexGaussian: 3DGS Compression Framework

• FlexGaussian is a training-free framework that compresses 3D Gaussian Splatting scenes by using mixed-precision quantization, attribute-discriminative pruning, and fast online adaptation.
• It achieves up to 96.4% compression with less than 1 dB PSNR drop by selectively pruning redundant Gaussians and quantizing attributes based on sensitivity.
• Fast Online Adaptation allows flexible trade-offs between file size and quality, making the method suitable for mobile, AR/VR, and bandwidth-constrained applications.

FlexGaussian is a training-free post-training compression framework for 3D Gaussian Splatting (3DGS) that combines mixed-precision quantization, attribute-discriminative pruning, and fast online adaptation to compress already trained Gaussian scenes without retraining, fine-tuning, refinement, or mask learning (Tian et al., 9 Jul 2025). It addresses the practical deployment bottleneck of 3DGS, where scenes are represented by millions of explicit Gaussian primitives with geometry and appearance attributes, and where model files can reach hundreds of MiB to multiple GiB. In the reported evaluation, FlexGaussian achieves up to 96.4% compression while maintaining high rendering quality with less than 1 dB drop in PSNR, and it is presented as deployable on mobile devices (Tian et al., 9 Jul 2025).

1. Problem setting and representational scope

FlexGaussian operates on a trained 3DGS scene represented as an $N \times M$ attribute matrix, where each row is a Gaussian primitive and each column is an attribute channel. The attributes listed are center coordinates, scaling factors along 3 axes, rotation in quaternion form $(w,x,y,z)$, opacity, view-independent base color in RGB denoted $SH_{base}$, and degree-3 spherical harmonics coefficients for view-dependent effects denoted $SH_{adv}$ (Tian et al., 9 Jul 2025).

The method is motivated by the storage burden of explicit 3DGS. The paper gives two concrete examples: the Garden scene from Mip-NeRF360, trained at 1.6K resolution, requires over 5.8 million Gaussians and gigabyte-level storage; the Rubble scene from Mill-19, trained with Grendel-GS, has over 40 million Gaussians and an 8.9 GB file. The paper further links this burden to mobile GPUs, AR/VR devices, edge deployment, and bandwidth-constrained streaming, and notes that large scenes such as MatrixCity and Mill-19 often need 16–64 GPUs to train because of image storage, optimizer states, and training intermediates.

Within this setting, “training-free” has a specific operational meaning. Compression begins from an already optimized 3D Gaussian model and is applied without retraining, fine-tuning, refinement, or mask learning, and without requiring access to training images for optimization. This definition is central to the method’s positioning: the target is not maximal rate-distortion performance at any computational cost, but flexible reconfiguration under changing memory and quality constraints with low additional compute overhead.

2. Compression architecture

The FlexGaussian pipeline has three named components—Attribute-Discriminative Pruning (ADP), Mixed-Precision Quantization (MPQ), and Fast Online Adaptation (FOA)—applied to a trained 3DGS model (Tian et al., 9 Jul 2025).

Component	Primary role	Mechanism
ADP	Reduce Gaussian and attribute redundancy	Fully retain top $\alpha\%$, discard bottom $\beta\%$, partially prune middle tier
MPQ	Reduce precision cost	Channel-wise INT4/INT8 quantization with subchannel-wise grouped quantization
FOA	Select operating point	Search over ADP and MPQ settings under compression or quality targets

Operationally, FlexGaussian first computes per-Gaussian importance scores using a global significance measure. ADP then sorts Gaussians by importance and applies a tiered retention policy. MPQ quantizes the remaining attributes with channel-wise mixed precision, and FOA searches the resulting design space to identify a configuration satisfying a target compression ratio or quality budget.

The paper repeatedly emphasizes that these components address different axes of redundancy. ADP removes redundancy along the Gaussian dimension and partially along the attribute dimension; MPQ reduces the bit-width cost of the remaining data; FOA makes the framework reconfigurable rather than tied to a single compression point. This design is explicitly contrasted with methods that require retraining or that must rerun a heavier forward pass for every new target configuration.

3. Mixed-Precision Quantization

MPQ is motivated by an empirical asymmetry in channel sensitivity. The paper reports that INT8 quantization usually preserves quality fairly well, whereas uniform INT4 quantization causes a sharp drop in rendering quality. The stated explanation is that different 3DGS attributes have very different dynamic ranges, with ranges differing by up to 200×, for example between XYZ and SH channels (Tian et al., 9 Jul 2025).

The bit-width assignment policy is channel-wise rather than global. Each individual channel is temporarily quantized to INT4 while the others are kept at INT8; the resulting normalized quality gap from the original model is measured; channels with smaller gaps are classified as less sensitive and assigned INT4, while more sensitive channels remain at INT8. The paper states that this procedure does not explicitly model channel correlations, but in practice is “robust and efficient,” and that sensitivity patterns are largely scene-insensitive, with optional lightweight search when needed.

Quantization also has a second granularity level. Within each channel, sequential attributes are bucketed into subgroups, with the paper giving approximately 1000 sub-groups per channel, and each subgroup receives its own quantization range. This grouped quantization is introduced because a single global range per channel is too coarse when a channel contains millions of values.

The empirical effect of MPQ is documented both in main results and in ablations. Without pruning, MPQ alone reduces Garden from 1379.99 MiB at 27.18 dB to 216.65 MiB at 26.81 dB; Truck from 601.03 MiB at 24.94 dB to 93.97 MiB at 24.69 dB; and DrJohnson from 805.36 MiB at 28.94 dB to 124.43 MiB at 28.81 dB. Grouped quantization also improves fidelity at fixed compression: Garden rises from 26.45 PSNR without grouped quantization to 26.81 PSNR with grouped quantization, and Bonsai rises from 30.25 PSNR to 31.19 PSNR. The paper summarizes this as grouped quantization mitigating about half of the quality loss at the same compression ratio.

A notable limitation is that the paper does not provide explicit quantization equations. It does not supply formulas for quantizer definition, dequantizer definition, scale or zero-point, clipping, or a formal bit-allocation objective. The quantization mechanism is therefore specified procedurally and empirically rather than through a fully explicit symbolic formulation.

4. Attribute-Discriminative Pruning and Fast Online Adaptation

ADP is based on a per-Gaussian global significance score inherited from LightGaussian. The paper gives the score as

$GS_n = \sum_{n=1}^{MHW}\mathbbm{1}(G(X_n), r_i)\cdot \sigma_n \cdot \gamma(\bigoplus_n),$

while also noting in the surrounding explanation that the notation is imperfectly typeset (Tian et al., 9 Jul 2025). In the text, $GS_n$ is the global significance score of the $n$-th Gaussian, $MHW$ is the total number of pixels over all training views, $(w,x,y,z)$0 indicates whether Gaussian $(w,x,y,z)$1 intersects ray $(w,x,y,z)$2, $(w,x,y,z)$3 is opacity, and $(w,x,y,z)$4 measures Gaussian volume from scaling factors.

After ranking by significance, ADP partitions the Gaussians into three regions: the top $(w,x,y,z)$5 are fully retained, the bottom $(w,x,y,z)$6 are fully discarded, and the middle $(w,x,y,z)$7 are partially retained. In this middle region, only critical attributes are preserved and less important ones—especially $(w,x,y,z)$8—are pruned. The paper therefore describes ADP as a semi-structured pruning strategy acting along both the primitive dimension and the attribute dimension. Geometry attributes are treated as compact and highly important, whereas $(w,x,y,z)$9 is treated as storage-heavy and less sensitive.

The ablation results are central to the justification of ADP. On Garden, baseline performance is 27.18 dB at 1379.99 MiB; Row-P alone gives 25.10 dB at 552.00 MiB; SH-P alone gives 23.71 dB at 327.46 MiB; and ADP gives 26.51 dB at 439.73 MiB. On Truck, baseline is 24.94 dB at 601.03 MiB; Row-P gives 21.82 dB at 120.21 MiB; SH-P gives 22.90 dB at 142.62 MiB; and ADP gives 24.27 dB at 102.89 MiB. On DrJohnson, baseline is 28.94 dB at 805.36 MiB; Row-P gives 26.53 dB at 161.07 MiB; SH-P gives 27.40 dB at 191.10 MiB; and ADP gives 28.21 dB at 137.87 MiB. These comparisons support the paper’s claim that attribute-aware semi-structured pruning is materially better than attribute-agnostic pruning at similar or better compression.

FOA is the mechanism that makes FlexGaussian flexible under changing constraints. The paper argues that the quality-versus-pruning trend is sufficiently regular, with an approximately convex Pareto frontier and a monotonic tradeoff trend, so that only a small candidate set needs to be searched. Each search step duplicates the original model, applies pruning, quantizes, dequantizes, renders, and evaluates quality, after which the parameters are updated and the process repeats. The search can prioritize either compression or quality. On Truck, FlexGaussian spans 8× to 256× compression with PSNR losses from 0.05 dB to 9 dB, and each reconfiguration step takes about 1–2 seconds.

5. Empirical evaluation and deployment

The reported evaluation covers 13 standard scenes from Mip-NeRF360, Tanks and Temples, and Deep Blending, with comparisons against 3D-GS, FCGS or FCGS-Opt, LightGaussian, Compressed3D, PUP 3DGS, and CompGS (Tian et al., 9 Jul 2025). The primary metrics are PSNR, SSIM, LPIPS, file size, and compression time cost.

The headline aggregate result is that FlexGaussian achieves average size reductions of 94.9% on Mip-NeRF360, 96.1% on Tanks and Temples, and 96.4% on Deep Blending, with corresponding PSNR losses of 0.8 dB, 0.7 dB, and 0.8 dB under the paper’s main target of less than 1 dB PSNR drop. The average desktop results reported for FlexGaussian are 26.38 PSNR, 40.80 MiB, and 25.69 s on Mip-NeRF360; 22.44 PSNR, 16.30 MiB, and 18.24 s on Tanks and Temples; and 28.61 PSNR, 25.48 MiB, and 25.65 s on Deep Blending.

The method’s central systems claim is speed under training-free compression. The paper reports that FlexGaussian is 1.7–2.1× faster than FCGS and 10–100× faster than training-involved methods, with total compression typically under 30 seconds on the main desktop setup. For the Truck scene, total compression time is about 20.3 s, broken down into 38.8% data loading, 13.9% importance score calculation, 47.1% online adaptation, and 0.2% model storage. Each FOA step averages 1.56 s, with pruning taking 0.22 s, quantization 0.84 s, dequantization 0.32 s, and rendering 0.18 s; rendering during adaptation is reported for 32 views at about 178 FPS.

The combination of ADP and MPQ gives additional compression beyond either component alone. On Garden, the full method reaches 26.29 dB at 89.58 MiB; on Truck, 24.10 dB at 21.87 MiB; and on DrJohnson, 28.11 dB at 28.98 MiB. The paper characterizes this as an extra 2.4×–4.3× compression over either single component while remaining within the target quality regime.

Deployment on constrained hardware is a major part of the paper’s argument. The mobile platform is an Nvidia Jetson Xavier with 16 GB shared memory, of which about 12 GB is described as effectively usable after OS and process overhead. Reported mobile compression times range from 59.42 s on Train to 73.88 s on Truck and 135.49 s on Bicycle. The paper also contrasts FlexGaussian with FCGS on memory usage, stating that raw FCGS fails on 7 of 13 scenes because it exceeds 24 GiB VRAM, whereas FlexGaussian is designed for lower memory demand and mobile deployability.

6. Position in the 3DGS compression literature

FlexGaussian is explicitly presented not as the best pure rate-distortion method in every setting, but as a speed-flexibility-resource-efficiency compromise (Tian et al., 9 Jul 2025). On Mip-NeRF360, for example, Compressed3D is reported at 27.02 PSNR and 28.81 MiB, CompGS at 26.99 PSNR and 21.08 MiB, and FlexGaussian at 26.38 PSNR and 40.80 MiB. The paper therefore does not claim universal superiority over retraining- or refinement-based compression; instead, it emphasizes that those methods require access to training data and pipeline state, iterative optimization, and materially higher compute and memory budgets.

Several limitations are also either explicit or readily visible from the reported methodology. The paper does not provide explicit quantization formulas or low-level serialization details; importance scoring remains a nontrivial part of runtime; FOA still requires repeated rendering evaluations; and the claim that channel sensitivity patterns are scene-insensitive is empirical rather than derived. The rendering workflow described in evaluation quantizes, dequantizes, and then renders, which suggests that the paper does not specify a fundamentally redesigned renderer kernel for direct compressed-domain rendering.

Subsequent literature positions FlexGaussian as an important hybrid baseline in the 3DGS compression design space. GETA-3DGS characterizes FlexGaussian as a method that “applies training-free attribute-wise mixed-precision,” and groups it with other methods that treat pruning, quantization, and entropy coding as separate stages governed by hand-tuned heuristics such as opacity thresholds, fixed bit-widths, or spherical-harmonic truncation rules (Zhang et al., 3 May 2026). In that framing, FlexGaussian is not dismissed; rather, it is treated as evidence that attribute-wise mixed precision is valuable, while joint optimization of pruning and quantization under explicit hard constraints remains an open systems problem. This later reception is consistent with the original paper’s contribution: FlexGaussian established a practical, training-free, rapidly reconfigurable compressor for trained 3DGS models, and later work treated it as a strong reference point rather than an endpoint.