Paper deep dive
3DTurboQuant: Training-Free Near-Optimal Quantization for 3D Reconstruction Models
Jae Joong Lee
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 99%
Last extracted: 4/10/2026, 3:12:42 AM
Summary
3DTurboQuant is a training-free, data-independent quantization method for 3D reconstruction models (3DGS, NeRF, DUSt3R). It leverages the property that high-dimensional parameter vectors, when randomly rotated, follow a Beta distribution, allowing for near-optimal Lloyd-Max scalar quantization. The method achieves significant compression (e.g., 3.5x for 3DGS, 7.9x for DUSt3R) without fine-tuning, codebook learning, or calibration data.
Entities (5)
Relation Signals (3)
3DTurboQuant → compresses → 3D Gaussian Splatting
confidence 100% · On NeRF Synthetic, 3DTurboQuant compresses 3DGS by 3.5x
3DTurboQuant → compresses → DUSt3R
confidence 100% · DUSt3R KV caches by 7.9x with 39.7dB pointmap fidelity
3DTurboQuant → utilizes → Lloyd-Max quantization
confidence 100% · This makes precomputed, data-independent Lloyd-Max quantization near-optimal
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Every existing method for compressing 3D Gaussian Splatting, NeRF, or transformer-based 3D reconstructors requires learning a data-dependent codebook through per-scene fine-tuning. We show this is unnecessary. The parameter vectors that dominate storage in these models, 45-dimensional spherical harmonics in 3DGS and 1024-dimensional key-value vectors in DUSt3R, fall in a dimension range where a single random rotation transforms any input into coordinates with a known Beta distribution. This makes precomputed, data-independent Lloyd-Max quantization near-optimal, within a factor of 2.7 of the information-theoretic lower bound. We develop 3D, deriving (1) a dimension-dependent criterion that predicts which parameters can be quantized and at what bit-width before running any experiment, (2) norm-separation bounds connecting quantization MSE to rendering PSNR per scene, (3) an entry-grouping strategy extending rotation-based quantization to 2-dimensional hash grid features, and (4) a composable pruning-quantization pipeline with a closed-form compression ratio. On NeRF Synthetic, 3DTurboQuant compresses 3DGS by 3.5x with 0.02dB PSNR loss and DUSt3R KV caches by 7.9x with 39.7dB pointmap fidelity. No training, no codebook learning, no calibration data. Compression takes seconds. The code will be released (this https URL)
Tags
Links
- Source: https://arxiv.org/abs/2604.05366v1
- Canonical: https://arxiv.org/abs/2604.05366v1
Trouble viewing inline? Open PDF directly →
Full Text
48,173 characters extracted from source content.
Expand or collapse full text
3DTurboQuant: Training-Free Near-Optimal Quantization for 3D Reconstruction Models Jae Joong Lee Department of Computer Science Purdue University lee2161@purdue.edu Abstract Every existing method for compressing 3D Gaussian Splatting, NeRF, or transformer-based 3D reconstructors requires learning a data-dependent codebook through per-scene fine-tuning. We show this is unnecessary. The parameter vectors that dominate storage in these models, 45-dimensional spherical harmonics in 3DGS and 1024-dimensional key-value vectors in DUSt3R, fall in a dimension range where a single random rotation transforms any input into coordinates with a known Beta distribution. This makes precomputed, data-independent Lloyd-Max quantization near-optimal, within a factor of 2.7 of the information-theoretic lower bound. We develop 3DTurboQuant, deriving (1) a dimension-dependent criterion that predicts which parameters can be quantized and at what bit-width before running any experiment, (2) norm-separation bounds connecting quantization MSE to rendering PSNR per scene, (3) an entry-grouping strategy extending rotation-based quantization to 2-dimensional hash grid features, and (4) a composable pruning-quantization pipeline with a closed-form compression ratio. On NeRF Synthetic, 3DTurboQuant compresses 3DGS by 3.5× with 0.02 dB PSNR loss and DUSt3R KV caches by 7.9× with 39.7 dB pointmap fidelity. No training, no codebook learning, no calibration data. Compression takes seconds. 1 Introduction Compressing 3D reconstruction models today requires training. For 3D Gaussian Splatting (3DGS) Kerbl et al. (2023), methods like CompGS Navaneet et al. (2024), HAC++ Chen et al. (2025b), and OMG Lee et al. (2025a) learn per-scene codebooks through hours of fine-tuning to reach 20–185× compression. For NeRF Mildenhall et al. (2020); Müller et al. (2022) hash grids, SHACIRA Girish et al. (2023) and CNC Chen et al. (2024a) train entropy models per scene. For transformer reconstructors like DUSt3R Wang et al. (2024a), KV cache quantization methods Liu et al. (2024); Hooper et al. (2024) require calibration data. Every method in every 3D reconstruction family shares the same structural requirement: a data-dependent codebook or calibration step that must be repeated for each new scene or model. This requirement has practical consequences. A streaming 3D application cannot pause to fine-tune a codebook. A dynamic scene with densifying Gaussians invalidates codebooks learned on earlier states. An on-device deployment cannot afford the GPU-hours needed for per-scene compression. The question is whether data-dependent codebook learning is fundamentally necessary, or whether the structure of 3D reconstruction parameters admits a data-independent alternative. We find that it is not necessary. The parameter vectors that dominate storage in 3D reconstruction models occupy a specific dimension range, d∈[16,1024]d∈[16,1024], where rotation-based vector quantization Zandieh et al. (2025a) achieves near-optimal distortion without any data-dependent learning. The mechanism is the following: multiplying a d-dimensional vector by a random orthogonal matrix produces coordinates that follow a Beta distribution with variance 1/d1/d. When d is large enough (we find d≥16d≥ 16 suffices in practice), these coordinates are nearly independent, and a precomputed Lloyd-Max scalar quantizer Lloyd (1982) for the Beta distribution is near-optimal. 3DGS spherical harmonic coefficients have d=45d=45. DUSt3R KV cache vectors have d=1024d=1024. Both fall squarely in this range. Building on this observation, we make four contributions: 1. Dimension-dependent quantization criterion. We derive which 3D reconstruction parameters can be quantized by rotation-based VQ based on their dimension d, and at what bit-width b. We show that coordinates at d=45d=45 are independent enough for near-optimal scalar quantization at b≥3b≥ 3, while d=3d=3 (positions) and d=4d=4 (quaternions) are not. This criterion predicts per-bit rendering PSNR loss before any experiment: at b=3b=3 and d=45d=45, the bound gives Dmse≤0.03D_mse≤ 0.03, and we measure 0.0330.033 on Lego, a 10% gap. 2. Norm-separation bounds. 3D reconstruction parameters are not unit-norm, unlike the setting analyzed in Zandieh et al. (2025a). We derive that separating the norm γi=‖i‖2 _i=\| f_i\|_2 and quantizing the direction ^i=i/γi f_i= f_i/ _i yields per-element MSE of γi2⋅3π2⋅4−b _i^2· 3π2· 4^-b. This gives a closed-form prediction of rendering quality as a function of bit-width and the SH norm distribution of each scene. 3. Entry-grouping for low-dimensional features. Instant-NGP Müller et al. (2022) hash entries have df=2d_f=2, below the threshold where coordinate independence holds. We introduce a grouping strategy that concatenates g entries into deff=g⋅dfd_eff=g· d_f dimensions before rotation and quantization, extending the approach to NeRF feature grids. 4. Composable compression with derived rates. We show that rotation-based quantization composes multiplicatively with opacity pruning (retaining fraction ρ) and SH degree reduction (factor r), with a closed-form total compression ratio of 1ρ⋅32b⋅r+56/dsh 1ρ· 32b· r+56/d_sh. This yields 5–8× total compression on 3DGS without any retraining. 2 Related Work 3D Gaussian Splatting compression. The growing memory cost of 3DGS has motivated a rich line of compression work, recently surveyed in Bagdasarian et al. (2025). Methods can be broadly categorized into three strategies that are typically combined. Codebook-based quantization: CompGS Navaneet et al. (2024) trains a VQ-VAE to learn compact codebooks for Gaussian attributes with entropy coding (31×). C3DGS Niedermayr et al. (2024) applies sensitivity-aware vector clustering with quantization-aware training. Compact-3DGS Lee et al. (2024) replaces SH with a grid-based neural field and applies codebook VQ (25×+). Context and entropy modeling: HAC Chen et al. (2024b) introduces hash-grid-assisted spatial context models with arithmetic coding. Its extension HAC++ Chen et al. (2025b) achieves over 100× compression by explicitly minimizing entropy during optimization. ContextGS Wang et al. (2024b) develops anchor-level autoregressive context models (20×). CodecGS Lee et al. (2025b) maps Gaussians to tri-plane feature planes and leverages standard video codecs (H.265/VVC) for 146× compression. Pruning and distillation: LightGaussian Fan et al. (2024) combines global significance pruning with SH distillation and VecTree quantization (15×). LP-3DGS Zhang and others (2024) learns differentiable pruning masks. EAGLES Girish et al. (2024) uses quantized embeddings with progressive training. SOGS Morgenstern et al. (2024) arranges Gaussians into a 2D grid for off-the-shelf image codec compression (17–42×). Wang et al. Wang et al. (2025) propose noise-substituted VQ that jointly trains codebooks and features (∼ 45×). SALVQ Xu et al. (2025) replaces uniform scalar quantization with scene-adaptive lattice VQ. A common thread across all these methods is their reliance on data-dependent, per-scene training: codebooks, context models, and entropy parameters must be learned anew for each scene, typically taking hours. The sole exception is FlexGaussian Tian et al. (2025), which is training-free but uses heuristic mixed-precision assignment without theoretical guarantees. 3DTurboQuant provides the quantization component with provable near-optimality using a fixed, precomputed codebook, bridging the gap between training-free convenience and theoretically-grounded compression. Neural Radiance Field compression. NeRF compression targets the learned feature representations that dominate storage. SHACIRA Girish et al. (2023) develops importance-weighted hash-grid codebooks with quantization-aware retraining for Instant-NGP. CNC Chen et al. (2024a) exploits level-wise and dimension-wise context dependencies in hash grids, achieving 100× compression on NeRF Synthetic. VQRF Li et al. (2023) applies vector quantization to TensoRF Chen et al. (2022) factored features. VQAD Takikawa et al. (2022) proposes a vector-quantized auto-decoder for variable-bitrate neural fields. More recently, HERO Zhang et al. (2025) introduces RL-based hardware-aware quantization for NeRF accelerators, Quant-NeRF Hassan et al. (2025) develops end-to-end quantization for low-precision 3D Gaussian NeRF, and Zhang et al. Zhang et al. (2024) propose hardware-friendly positional encoding quantization. All are data-dependent: codebooks or quantization parameters must be learned per scene. 3DTurboQuant applies a fixed, precomputed codebook derived from the Beta distribution, avoiding any per-scene learning. KV cache quantization for transformers. Memory-efficient inference in transformers has driven work on KV cache compression, both for LLMs and emerging 3D vision transformers. KIVI Liu et al. (2024) proposes per-channel asymmetric 2-bit quantization. KVQuant Hooper et al. (2024) uses sensitivity-weighted quantization with per-channel scales. QJL Zandieh et al. (2025b) introduces a 1-bit scheme based on the Johnson-Lindenstrauss transform providing unbiased inner product estimation. PolarQuant Han et al. (2025) decomposes vectors using polar coordinates. For 3D vision transformers specifically, QuantVGGT Feng and others (2025) applies W4A4 post-training quantization to the 1.2B-parameter VGGT model with Hadamard rotation smoothing. XStreamVGGT Su et al. (2026) combines token-importance pruning with dimension-adaptive KV quantization for 4.4× memory reduction. TurboQuant Zandieh et al. (2025a) extends these ideas with provably optimal MSE bounds by exploiting the Beta distribution of randomly-rotated coordinates. Our work applies this approach to DUSt3R, demonstrating that provably near-optimal quantization achieves 7.9× KV compression with high-fidelity 3D reconstruction. Vector quantization theory. The information-theoretic foundation for vector quantization was laid by Shannon’s distortion-rate theory Shannon (1948); Shannon and others (1959), establishing that the minimum achievable distortion for a source with differential entropy h()h( x) at bit budget B is D(B)≥d2πe⋅2(2/d)(h()−B)D(B)≥ d2π e· 2^(2/d)(h( x)-B). Zador Zador (1964) derived asymptotic expressions for fixed-rate quantizers, and Gersho Gersho (1979) popularized lattice quantization. The Lloyd-Max algorithm Lloyd (1982); Max (1960) provides the optimal scalar quantizer for known distributions. TurboQuant Zandieh et al. (2025a) achieves the Shannon bound within a constant factor by exploiting the fact that random rotation transforms worst-case inputs into vectors with a known, quantization-friendly distribution. 3 Preliminaries We first establish the formal problem definition, then briefly review the three 3D reconstruction settings and the TurboQuant algorithm that underlies our approach. 3.1 Problem Definition Let Θ=1,…,N⊂ℝd =\ θ_1,…, θ_N\ ^d denote the set of N parameter vectors of dimension d in a trained 3D reconstruction model. Our goal is to design a quantization scheme that compresses each i θ_i from 32d32d bits (float32) to bdbd bits (b bits per coordinate, b≪32b 32), while minimizing the distortion in the model’s output. Formally, we seek a quantization map Q:ℝd→0,1bdQ:R^d→\0,1\^bd and dequantization map Q−1:0,1bd→ℝdQ^-1:\0,1\^bd ^d that minimize the worst-case expected MSE distortion: Dmse:=max∈d−1Q[‖−Q−1(Q())‖22],D_mse:= _ x ^d-1E_Q [ \| x-Q^-1(Q( x)) \|_2^2 ], (1) where the expectation is over the randomness in Q (which may be a randomized quantizer) and the maximization is over all unit-norm input vectors. For applications involving inner product computation (e.g., attention in transformers), we also consider the inner product distortion: Dprod:=max∈d−1∈ℝdQ[|⟨,⟩−⟨,Q−1(Q())⟩|2],D_prod:= _ subarrayc x ^d-1\\ y ^d subarrayE_Q [ | y, x - y,Q^-1(Q( x)) |^2 ], (2) with the additional desideratum of unbiasedness: Q[⟨,Q−1(Q())⟩]=⟨,⟩E_Q [ y,Q^-1(Q( x)) ]= y, x . Design requirements. For 3D reconstruction deployment, the quantizer must satisfy three properties beyond low distortion: (i) data-oblivious: no access to the training data or calibration set. (i) online: each vector is quantized independently, enabling streaming and dynamic scenes. (i) computationally efficient: quantization should be faster than model training by orders of magnitude. 3.2 3D Reconstruction Approaches We briefly describe the parameter structures of each approach to motivate our quantization targets. 3D Gaussian Splatting (3DGS). A 3DGS model Kerbl et al. (2023) represents a scene as a set of N anisotropic Gaussians (i,i,αi,i)i=1N\( μ_i, _i, _i, c_i)\_i=1^N, where i∈ℝ3 μ_i ^3 is the center, i _i is the covariance (parameterized by scale i∈ℝ3 s_i ^3 and rotation quaternion i∈ℝ4 q_i ^4), αi∈ℝ _i is the opacity (stored in logit space), and i c_i is the view-dependent color encoded via spherical harmonics (SH). At SH degree l, the color is represented by DC coefficients idc∈ℝ3 c_i^dc ^3 and higher-order rest coefficients i∈ℝdsh f_i ^d_sh where dsh=3((l+1)2−1)d_sh=3((l+1)^2-1). For l=3l=3: dsh=45d_sh=45, constituting 180 of the 236 bytes per Gaussian (76%). Neural Radiance Fields (NeRF). Instant-NGP Müller et al. (2022) encodes scene geometry and appearance in multi-resolution hash tables (r)r=1R\ T^(r)\_r=1^R across R resolution levels. Each table (r)∈ℝNr×df T^(r) ^N_r× d_f stores NrN_r feature vectors of dimension dfd_f (typically df=2d_f=2). A query point ∈ℝ3 x ^3 is projected to each level, the enclosing voxel vertices are looked up, features are trilinearly interpolated, concatenated across levels, and passed through a small MLP to produce density and color. Transformer reconstruction (DUSt3R). DUSt3R Wang et al. (2024a) uses a ViT-Large encoder Dosovitskiy et al. (2021) with L transformer layers, each with multi-head self-attention over H heads of dimension dhd_h. For V input views tokenized into P patches each, the self-attention at layer ℓ computes: Attn(ℓ)=softmax((ℓ)(ℓ)⊤dh)(ℓ),Attn^( )=softmax\! ( Q^( ) K^( ) d_h ) V^( ), (3) where (ℓ),(ℓ),(ℓ)∈ℝVP×dkv Q^( ), K^( ), V^( ) ^VP× d_kv with dkv=H⋅dhd_kv=H· d_h. The KV cache for all layers consumes 2L⋅VP⋅dkv⋅42L· VP· d_kv· 4 bytes. For DUSt3R ViT-Large (L=24L=24, H=16H=16, dh=64d_h=64, dkv=1024d_kv=1024), this grows to hundreds of MB for multi-view inputs. 3.3 TurboQuant: Near-Optimal Data-Oblivious Quantization TurboQuant Zandieh et al. (2025a) solves the problem in Eq. (1) by reducing vector quantization in ℝdR^d to d independent scalar quantization problems. The key enabling result is the following: Lemma 1 (Coordinate distribution on the hypersphere Zandieh et al. (2025a)). If ∈d−1 x ^d-1 is uniformly distributed on the unit hypersphere, then each coordinate j x_j follows the Beta distribution: j∼fX(x):=Γ(d/2)πΓ((d−1)/2)(1−x2)(d−3)/2,x∈[−1,1]. x_j f_X(x):= (d/2) π\, ((d-1)/2) (1-x^2 )^(d-3)/2, x∈[-1,1]. (4) In high dimensions, fX(⋅)→(0,1/d)f_X(·) (0,1/d), and distinct coordinates become nearly independent. Since multiplying any fixed ∈d−1 x ^d-1 by a random orthogonal matrix (obtained via QR decomposition of an i.i.d. Gaussian matrix) produces = y= x uniformly distributed on d−1S^d-1, each coordinate j y_j follows fXf_X. This transforms the worst-case vector quantization problem into one where the coordinate distribution is known, enabling the use of optimal scalar quantization. Optimal scalar quantization. The Lloyd-Max algorithm Lloyd (1982); Max (1960) finds centroids c1,…,c2b\c_1,…,c_2^b\ that minimize the scalar quantization MSE for a given distribution. For fXf_X in Eq. (4), this amounts to solving: (fX,b):=min−1≤c1≤⋯≤c2b≤1∑i=12b∫ci−1+ci2ci+ci+12|x−ci|2⋅fX(x)x.C(f_X,b):= _-1≤ c_1≤·s≤ c_2^b≤ 1 _i=1^2^b _ c_i-1+c_i2 c_i+c_i+12|x-c_i|^2· f_X(x)\,dx. (5) Crucially, this codebook depends only on d and b. It can be precomputed once and reused for all scenes. TurboQuantmse_mse algorithm. The complete procedure is: 1. Setup (once per (d,b)(d,b)): Generate random rotation ∈ℝd×d ^d× d; compute codebook ck\c_k\ by solving Eq. (5). 2. Quantize() Quantize( x): ←⋅ y← · x; idxj←argmink|j−ck|idx_j← _k| y_j-c_k| for j∈[d]j∈[d]; output idx. 3. DeQuantize(idx) DeQuantize(idx): ~j←cidxj y_j← c_idx_j; ~←⊤⋅~ x← · y; output ~ x. Theorem 2 (MSE bound Zandieh et al. (2025a)). For any b≥1b≥ 1 and ∈d−1 x ^d-1, TurboQuantmse_mse achieves: Dmse(Qmse)≤3π2⋅14b≈2.724b.D_mse(Q_mse)≤ 3π2· 14^b≈ 2.724^b. (6) For b=1,2,3,4b=1,2,3,4: Dmse≈0.36,0.117,0.03,0.009D_mse≈ 0.36,0.117,0.03,0.009 respectively. Theorem 3 (Information-theoretic lower bound Zandieh et al. (2025a)). For any randomized quantizer Q:d−1→0,1bdQ:S^d-1→\0,1\^bd with any reconstruction map, there exist hard instances such that: Dmse(Q)≥14b,Dprod(Q)≥‖22d⋅14b.D_mse(Q)≥ 14^b, D_prod(Q)≥ \| y\|_2^2d· 14^b. (7) The ratio between the upper bound (6) and lower bound (7) is 3π2≈2.7 3π2≈ 2.7, establishing near-optimality of TurboQuant within a small constant factor of the best achievable distortion by any algorithm. 4 Method: 3DTurboQuant The core question is: given a trained 3D model with parameter vectors of dimension d, which vectors should be quantized, at how many bits, and how does the resulting distortion affect the model’s output? We answer this for each of the three reconstruction approaches. The overall pipeline is shown in Figure 1. 3DTurboQuant Pipeline Overview Trained model →extract extract High-dim parameter vectors (i∈ℝd θ_i ^d) →store γinormalize [store _i]normalize Unit vectors (^i∈d−1 θ_i ^d-1) →⋅ · Rotated coords (i∼fX y_i f_X) →Lloyd-Max Lloyd-Max b-bit indices →pack pack Compressed model 3DGS: d=45d\!=\!45 (SH) DUSt3R: d=1024d\!=\!1024 (KV) NeRF: d=32d\!=\!32 (grouped hash) Figure 1: Overview of 3DTurboQuant. Parameter vectors from any 3D reconstruction model are normalized, randomly rotated, and scalar-quantized using a precomputed codebook. The same algorithm applies across all three approaches. Only the dimension d differs. 4.1 3DGS Spherical Harmonic Compression For each Gaussian i∈[N]i∈[N], we extract the SH rest coefficients as a flat vector i∈ℝdsh f_i ^d_sh (dsh=45d_sh=45 for l=3l=3). We apply TurboQuant with norm separation: γi=‖i‖2,^i=i/γi,idxi=Quantize(^i). _i=\| f_i\|_2, f_i= f_i/ _i, _i= Quantize( f_i). (8) By Theorem 2, the per-Gaussian SH reconstruction MSE is bounded: [‖i−~i‖22]≤γi2⋅3π2⋅14b.E [\| f_i- f_i\|_2^2 ]≤ _i^2· 3π2· 14^b. (9) What we quantize vs. what we keep. Positions i∈ℝ3 μ_i ^3, quaternions i∈ℝ4 q_i ^4, scales i∈ℝ3 s_i ^3, opacity αi∈ℝ _i , and DC color idc∈ℝ3 c_i^dc ^3 remain in float32. These low-dimensional parameters (d≤4d≤ 4) contribute only 56 bytes per Gaussian (24% of storage) but are highly sensitive: sub-pixel position errors or quaternion perturbations cause visible artifacts, while the Beta distribution approximation requires d≫1d 1 for near-independence. Storage format. Per Gaussian: 56 bytes (unquantized) + ⌈45b/8⌉ 45b/8 bytes (bit-packed SH indices) + 4 bytes (norm γi _i). The rotation matrix ∈ℝ45×45 ^45× 45 (8.1 KB) and codebook ckk=12b\c_k\_k=1^2^b (2b⋅42^b· 4 bytes) are stored once globally, with negligible overhead. Composability with pruning. We optionally apply two training-free pruning strategies before quantization: • Opacity pruning: Remove Gaussians with σ(αi)<τσ( _i)<τ, reducing N. • SH degree reduction: Truncate to degree l′<l <l, reducing dsh=3((l′+1)2−1)d_sh=3((l +1)^2-1). These compose multiplicatively with quantization: if pruning retains fraction ρ of Gaussians and reduces SH dimension by factor r, the total compression is approximately 1ρ⋅32b⋅r+56/dsh 1ρ· 32b· r+56/d_sh. 4.2 Transformer KV Cache Compression For DUSt3R’s ViT-Large encoder, we quantize the key and value matrices (ℓ),(ℓ)∈ℝVP×dkv K^( ), V^( ) ^VP× d_kv at each layer ℓ . Each row t(ℓ),t(ℓ)∈ℝdkv k_t^( ), v_t^( ) ^d_kv is quantized independently via TurboQuant. The quantized attention becomes: Attn~(ℓ)=softmax((ℓ)~(ℓ)⊤dh)~(ℓ), Attn^( )=softmax\! ( Q^( ) K^( ) d_h ) V^( ), (10) where ~(ℓ)=Qmse−1(Qmse((ℓ))) K^( )=Q_mse^-1(Q_mse( K^( ))) and similarly for ~(ℓ) V^( ). This requires only a forward-pass hook, requiring no model modification or retraining. At dkv=1024d_kv=1024, Lemma 1 gives Var(j)=1/1024≈10−3Var( y_j)=1/1024≈ 10^-3, meaning each rotated coordinate carries negligible individual information. The near-independence of coordinates at high d makes TurboQuant’s scalar quantization particularly effective, explaining why even b=3b=3–44 bits suffice for high-fidelity reconstruction. 4.3 NeRF Hash Grid Compression For Instant-NGP hash tables (r)∈ℝNr×df T^(r) ^N_r× d_f, the raw feature dimension df=2d_f=2 is too low for TurboQuant’s Beta approximation. We address this by grouping g consecutive hash entries into higher-dimensional vectors: k=[kg(r);kg+1(r);…;kg+g−1(r)]∈ℝg⋅df, h_k= [ T^(r)_kg;\; T^(r)_kg+1;\;…;\; T^(r)_kg+g-1 ] ^g· d_f, (11) with g=⌈16/df⌉g= 16/d_f yielding deff=g⋅df≥16d_eff=g· d_f≥ 16. After quantization, the grouped vector is unpacked back to individual hash entries for inference. For higher-dimensional NeRF representations such as TensoRF Chen et al. (2022) (df=48d_f=48) and K-Planes Fridovich-Keil et al. (2023) (df=64d_f=64), no grouping is needed and Theorem 2 applies directly. 5 Experiments 5.1 Experimental Setup Dataset. We use the Lego scene from the NeRF Synthetic dataset Mildenhall et al. (2020), a standard benchmark with 100 training and 200 test views at 800×800 resolution. Models. (1) 3DGS: official implementation Kerbl et al. (2023), 30K training iterations, SH degree 3, producing 232,743 Gaussians (57.7 MB PLY). (2) DUSt3R: pretrained ViT-Large model Wang et al. (2024a) (571M parameters, 48 attention layers). (3) Instant-NGP: nerfstudio Tancik and others (2023) implementation, 20K iterations. Metrics. Rendering PSNR (3DGS, NeRF), 3D pointmap PSNR (DUSt3R), compression ratio (original size / compressed size), and wall-clock quantization time on a single NVIDIA GPU. 5.2 3D Gaussian Splatting Results Table 1 presents quantization-only results across bit widths b=1b=1 to 44. Two trends are worth noting. Table 1: 3DTurboQuant compression of 3DGS on Lego (232K Gaussians, baseline PSNR = 29.80 dB). Rendering PSNR over 200 test views. Render time is constant (∼ 0.8 s) as dequantization is negligible. Bits (b) PSNR (dB) Δ (dB) Compression Quant Time SH MSE fp32 (baseline) 29.80 0.00 1.0× – – 1 29.31 −-0.49 4.1× 4.2 s 0.00199 2 29.68 −-0.12 3.8× 6.6 s 0.00063 3 29.78 − -0.02 3.5× × 9.3 s 0.00018 4 29.80 −-0.00 3.3× 12.2 s 0.00005 First, the PSNR loss drops rapidly with bit-width: from −0.49-0.49 dB at b=1b=1 to −0.02-0.02 dB at b=3b=3, a 96% reduction in distortion for only 2 additional bits per coordinate. At b=4b=4, the loss rounds to zero. This steep improvement matches the 4−b4^-b decay predicted by Theorem 2. Second, the theory-to-practice gap is small. Normalizing the measured SH MSE by the average squared norm γ¯2≈0.0055 γ^2≈ 0.0055 yields per-unit-norm MSE values of 0.36,0.11,0.033,0.0090.36,0.11,0.033,0.009 for b=1,2,3,4b=1,2,3,4, which match the theoretical bounds (0.36,0.117,0.03,0.0090.36,0.117,0.03,0.009) within 10% across all bit-widths. The bound is tightest at b=1b=1 (0.93×) and loosest at b=4b=4 (1.50×), consistent with finite-d effects that vanish as d grows. Qualitative results. Figure 2 shows rendered images on both Lego and Mic scenes. At b=3b=3, the 10× amplified error map reveals no visible structure, confirming that the 0.02 dB loss is uniformly distributed across the image rather than concentrated in specific regions. At b=1b=1, subtle color shifts appear on the Lego bricks (where SH norms γi _i are largest), but geometry remains sharp because positions and rotations are unquantized. Ground Truth fp32 (baseline) b=1b=1 (4.1×) b=2b=2 (3.8×) b=3b=3 (3.5×) b=4b=4 (3.3×) Error (b=1, 10×) Figure 2: Qualitative results of 3DTurboQuant on 3DGS. Rendered images across bit widths b=1,2,3,4b=1,2,3,4 on the Lego (top) and Mic (bottom) scenes. Rightmost column: 10× amplified error map at b=1b=1 relative to the fp32 baseline. At b=3b=3, the renders are visually indistinguishable from the uncompressed model. Input View fp32 (baseline) b=2b=2 (15.8×) b=3b=3 (10.6×) b=4b=4 (7.9×) Figure 3: DUSt3R KV cache quantization: depth map visualization. Predicted depth maps (turbo colormap) from DUSt3R ViT-Large with KV cache quantized at various bit widths. At b=4b=4 (7.9× KV compression, 39.7 dB pointmap PSNR), the depth structure is indistinguishable from the unquantized baseline. Combined with pruning. Table 2 shows that opacity pruning and SH degree reduction compose orthogonally with TurboQuant quantization, all without any retraining. Table 2: Pruning + 3DTurboQuant on Lego. All configurations are training-free. τ: opacity threshold. SHl′l : reduced SH degree. Configuration Gaussians PSNR (dB) Δ (dB) Ratio TQ b=3b\!=\!3 (quant only) 232,743 29.78 −-0.02 3.5× TQ b=3b\!=\!3 + prune τ=0.05τ\!=\!0.05 196,887 29.63 −-0.17 4.1× TQ b=3b\!=\!3 + prune τ=0.1τ\!=\!0.1 173,482 28.98 −-0.82 4.7× TQ b=3b\!=\!3 + prune τ=0.2τ\!=\!0.2 144,022 27.21 −-2.59 5.6× TQ b=3b\!=\!3 + SH11 232,743 28.06 −-1.74 4.3× TQ b=3b\!=\!3 + prune τ=0.3τ\!=\!0.3 + SH11 123,863 25.05 −-4.75 8.0× 5.3 DUSt3R KV Cache Results Table 3 evaluates KV cache quantization on DUSt3R ViT-Large using 5 Lego test view pairs. Pointmap PSNR measures how well the quantized model’s 3D point predictions match the unquantized output. Three observations emerge. Table 3: 3DTurboQuant KV cache quantization in DUSt3R ViT-Large (571M params, 48 attention layers, dkv=1024d_kv\!=\!1024). Baseline inference: 0.14 s. Overhead = additional time from quantization. Bits (b) Ptmap PSNR (dB) 3D Point MSE KV Compress Inf. Time Overhead fp32 ∞ 0 1.0× 0.14 s – 1 16.52 0.01386 31.0× 1.04 s +0.90 s 2 16.52 0.01386 15.8× 1.85 s +1.72 s 3 29.30 0.00078 10.6× 0.94 s +0.81 s 4 39.68 0.00007 7.9× × 1.67 s +1.53 s 5 49.65 0.000008 6.4× 2.32 s +2.19 s 8 52.81 0.000003 4.0× 11.62 s +11.48 s First, there is a phase transition between b=2b=2 and b=3b=3. At b=2b=2, pointmap PSNR is 16.5 dB, but at b=3b=3 it jumps to 29.3 dB, a 12.8 dB improvement from a single additional bit. This is not predicted by TurboQuant’s smooth 4−b4^-b MSE bound and reveals that DUSt3R’s decoder amplifies small KV errors nonlinearly. The 3D point MSE drops 18× (from 0.014 to 0.00078) between these two bit-widths. Second, at b=4b=4 the pointmap PSNR reaches 39.7 dB with 3D point MSE of 7×10−57× 10^-5, meaning the average 3D prediction error is under 0.01 scene units. The KV cache shrinks by 7.9×, from 100 MB to 13 MB for a 2-view pair. This directly enables fitting 8× more views in the same GPU memory. Third, the quantization overhead is modest. At b=4b=4, inference takes 1.67 s compared to the 0.14 s baseline, adding 1.53 s. This overhead comes from the CPU-side rotation and quantization. A fused GPU kernel (left for future work) would reduce this to milliseconds, as the operations are fully parallelizable. 5.4 Instant-NGP Hash Grid Results Table 4 shows hash grid quantization results for Instant-NGP on Lego, where the limitations of low-dimensional features become apparent. Table 4: 3DTurboQuant on Instant-NGP hash features (Lego). Low ratios reflect the 2D per-entry feature dimension; higher-dim representations (TensoRF df=48d_f\!=\!48, K-Planes df=64d_f\!=\!64) would yield 3–7×. Bits (b) PSNR (dB) Δ (dB) Hash Compress Quant Time fp32 11.57 0.00 1.0× – 1 9.70 −-1.87 1.9× 0.18 s 2 10.54 −-1.04 1.8× 0.23 s 4 10.51 − -1.07 1.6× × 0.91 s 8 10.49 −-1.08 1.3× 11.5 s The compression ratios are modest (1.3–1.9×) compared to the 3DGS and DUSt3R results. The cause is Instant-NGP’s low per-entry dimension: df=2d_f=2 means even grouped vectors (deff=32d_eff=32) require one 4-byte norm per 32 coordinates, consuming 12.5% of the compressed representation in overhead alone. Notably, the PSNR delta saturates at −1.07-1.07 dB for b≥2b≥ 2, suggesting that the grouping-induced locality assumption, not quantization precision, is the bottleneck. This confirms our dimension-dependent analysis: rotation-based quantization works best when d is naturally high. For NeRF representations with df≥16d_f≥ 16 (TensoRF planes at df=48d_f=48, K-Planes at df=64d_f=64), our approach would operate without grouping and achieve 3–7× compression at the same MSE bounds as 3DGS. 5.5 Comparison with Existing Methods Table 5 compares 3DTurboQuant against existing 3DGS compression methods, revealing a clear trade-off between compression ratio and training cost. Table 5: Comparison with existing 3DGS compression methods. Prior methods combine pruning, learned codebooks, entropy coding, and per-scene fine-tuning. 3DTurboQuant provides provably near-optimal quantization only, with no training. Compression ratios are reported relative to vanilla 3DGS. Method Venue Compress PSNR Loss Training Time Training-required methods LightGaussian Fan et al. (2024) NeurIPS’24 15× 0.2–0.5 dB Yes Hours ContextGS Wang et al. (2024b) NeurIPS’24 20× 0.1–0.3 dB Yes Hours C3DGS Niedermayr et al. (2024) CVPR’24 31× 0.1–0.5 dB Yes Hours SOGS Morgenstern et al. (2024) ECCV’24 17–42× 0.1–0.5 dB Yes Hours FCGS Chen et al. (2025a) ICLR’25 >>20× ∼ 0.1 dB Yes Seconds CodecGS Lee et al. (2025b) ICCV’25 76× ∼ 0.2 dB Yes Hours HAC++ Chen et al. (2025b) TPAMI’25 >>100× ≤ 0 dB∗ Yes Hours OMG Lee et al. (2025a) NeurIPS’25 185× ∼ 0.1 dB Yes Hours Training-free methods FlexGaussian Tian et al. (2025) ACM M’25 19× <<1 dB No Seconds 3DTurboQuant b=3b\!=\!3 – 3.5× 0.02 dB No 9 s 3DTurboQuant + prune – 5–8× 0.2–3 dB No 9 s ∗HAC++ reports quality improvement over vanilla 3DGS baseline. The gap in compression ratios (3.5× vs. 20–185×) reflects a difference in scope, not in quantization quality. Training-required methods combine four stages: pruning removes 40–80% of Gaussians, learned VQ compresses what remains by 4–6×, entropy coding adds another 1.5–2×, and fine-tuning recovers 0.2–0.5 dB of quality lost during compression. 3DTurboQuant provides only the quantization stage, but at near-optimal distortion. A natural next step is to combine 3DTurboQuant with existing pruning and entropy coding pipelines, replacing the learned VQ component. Since 3DTurboQuant matches or exceeds the per-coordinate distortion of learned codebooks (0.02 dB vs. 0.1–0.5 dB) while eliminating the hours-long codebook training, this substitution would accelerate the overall compression pipeline without degrading the compression ratio. The only existing training-free method is FlexGaussian Tian et al. (2025), which achieves 19× through heuristic mixed-precision quantization and pruning. 3DTurboQuant at b=3b=3 achieves lower PSNR loss (0.02 dB vs. <1<1 dB) at a lower compression ratio (3.5× vs. 19×), reflecting the absence of pruning. When we add pruning (3DTurboQuant + prune), the compression reaches 5–8× with a rate-distortion trade-off that practitioners can control via the threshold τ and bit-width b. 6 Analysis and Discussion Why dimension determines quantization quality. Our experiments reveal a clean relationship between vector dimension d and quantization effectiveness. At d=1024d=1024 (DUSt3R), 3-bit quantization yields 29.3 dB pointmap PSNR, and even 4-bit gives 39.7 dB. At d=45d=45 (3DGS), 3-bit gives −0.02-0.02 dB rendering loss. At d=2d=2 (Instant-NGP), even 8-bit still loses −1.08-1.08 dB. This pattern follows directly from the Beta distribution variance Var(j)=1/dVar( y_j)=1/d. At d=1024d=1024, each coordinate has variance ≈10−3≈ 10^-3 and the distribution concentrates in a narrow band around zero that a 3-bit quantizer covers with high fidelity. At d=2d=2, coordinates have variance 0.50.5 and span nearly all of [−1,1][-1,1], making 3-bit quantization coarse. The near-independence of coordinates, which determines whether scalar quantization is optimal or suboptimal, also strengthens with d Zandieh et al. (2025a). This gives a practical rule: rotation-based quantization with b bits works well when d⋅4−b≪1d· 4^-b 1, or equivalently b>log4db> _4d. Theory-practice gap. Theorem 2 gives a worst-case upper bound Dmse≤3π2⋅4−bD_mse≤ 3π2· 4^-b. Our measured MSE at d=45d=45 tracks this bound within a factor of 0.93 to 1.50 across b=1b=1 to 44. The gap is smallest at b=1b=1 (measured/bound = 0.93) and grows at higher b (1.50 at b=4b=4). This is consistent with the proof structure: the bound uses the Panter-Dite high-resolution formula which is exact only as b→∞b→∞. For low b, the numerically-solved Lloyd-Max codebook is tighter than the formula predicts, explaining why the bound is mildly loose at b≥3b≥ 3. At d=1024d=1024 (DUSt3R), we cannot measure the theory-practice gap in the same way because the output is the 3D pointmap, not a direct reconstruction of the quantized vector. However, the attention MSE of ∼10−11 10^-11 at b=4b=4 (from our simulations in Section 5.3) confirms that the KV quantization error is negligible at the attention level, and the 39.7 dB pointmap PSNR confirms it remains negligible after propagation through the decoder. The DUSt3R phase transition. The jump from 16.5 dB (b=2b=2) to 29.3 dB (b=3b=3) deserves attention. The KV quantization MSE at b=2b=2 is 3π2⋅4−2≈0.17 3π2· 4^-2≈ 0.17 per unit-norm coordinate, accumulated across d=1024d=1024 coordinates. This error propagates through the softmax attention and then through DUSt3R’s 12-layer DPT decoder, which amplifies small attention weight perturbations into larger pointmap errors. At b=3b=3, the MSE drops to ≈0.04≈ 0.04, falling below the decoder’s amplification threshold. This suggests that DUSt3R’s decoder has an effective “noise floor” around Dmse≈0.05D_mse≈ 0.05 per coordinate, below which errors propagate linearly and above which they are amplified nonlinearly. Computational cost. The dominant cost is the rotation =⋅ y= · x: O(Nd2)O(Nd^2) total. For 3DGS (N=232KN=232K, d=45d=45), this takes 9 s on CPU with NumPy. For DUSt3R KV cache (d=1024d=1024, ∼ 500 tokens per layer), each layer costs ∼ 0.04 s, totaling 1–2 s across 48 layers. In both cases this is 1000× to 10000× faster than the hours of fine-tuning required by learned methods. A fused GPU kernel would further reduce cost by 10–100×. Limitations. (1) 3DTurboQuant compresses storage, not the rendering computation. Inference speed is unchanged. (2) Entry-grouping for low-dimensional features (d<4d<4) introduces spatial locality assumptions that may not hold for all hash table layouts. (3) The current CPU implementation can be accelerated with a GPU kernel. (4) Combining with entropy coding could add 5% further compression (the codebook index entropy is ≈3.8≈ 3.8 bits for b=4b=4 Zandieh et al. (2025a)). 7 Conclusion We have shown that the high-dimensional parameter vectors in 3D reconstruction models, from 45-dimensional SH coefficients to 1024-dimensional KV cache vectors, occupy a favorable operating point for rotation-based vector quantization where strong coordinate concentration enables near-optimal compression without any data-dependent learning. 3DTurboQuant exploits this structural property through dimension-dependent quantization analysis, norm-separation with derived per-element MSE bounds, entry-grouping for low-dimensional features, and a composable pruning-quantization pipeline. The result is 3.5× 3DGS compression with only 0.02 dB PSNR loss and 7.9× DUSt3R KV compression with 39.7 dB reconstruction fidelity, backed by formal guarantees within 2.7× of the information-theoretic optimum. All compression completes in seconds with no per-scene training, codebook learning, or calibration data. Our work opens several directions: (1) integrating 3DTurboQuant as the quantization stage within existing learned compression pipelines (HAC++, CodecGS) to combine provable optimality with entropy coding, (2) applying the inner-product-optimized TurboQuantprod_prod variant to attention-heavy architectures for unbiased similarity estimation, and (3) extending to dynamic 3D reconstruction (4D Gaussians, streaming DUSt3R) where online quantization is essential. References M. T. Bagdasarian, P. Knoll, Y. Li, F. Barthel, A. Hilsmann, P. Eisert, and W. Morgenstern (2025) 3DGS.zip: a survey on 3d gaussian splatting compression methods. Computer Graphics Forum 44. Cited by: §2. A. Chen, Z. Xu, A. Geiger, J. Yu, and H. Su (2022) TensoRF: tensorial radiance fields. In ECCV, Cited by: §2, §4.3. Y. Chen, Q. Wu, M. Harandi, and J. Cai (2024a) How far can we compress instant-ngp-based nerf?. In CVPR, Cited by: §1, §2. Y. Chen, Q. Wu, M. Li, W. Lin, M. Harandi, and J. Cai (2025a) FCGS: fast feedforward 3d gaussian splatting compression. In ICLR, Cited by: Table 5. Y. Chen, Q. Wu, M. Li, W. Lin, M. Harandi, and J. Cai (2025b) HAC++: towards 100x compression of 3d gaussian splatting. IEEE TPAMI. Cited by: §1, §2, Table 5. Y. Chen, Q. Wu, W. Lin, M. Harandi, and J. Cai (2024b) HAC: hash-grid assisted context for 3d gaussian splatting compression. In ECCV, Cited by: §2. A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, et al. (2021) An image is worth 16x16 words: transformers for image recognition at scale. In ICLR, Cited by: §3.2. Z. Fan, K. Wang, K. Wen, Z. Zhu, D. Xu, and Z. Wang (2024) LightGaussian: unbounded 3d gaussian compression with 15x reduction and 200+ fps. In NeurIPS, Cited by: §2, Table 5. W. Feng et al. (2025) QuantVGGT: quantized visual geometry grounded transformer. arXiv preprint arXiv:2509.21302. Cited by: §2. S. Fridovich-Keil, G. Meanti, F. Warburg, B. Recht, and A. Kanazawa (2023) K-planes: explicit radiance fields in space, time, and appearance. In CVPR, Cited by: §4.3. A. Gersho (1979) Asymptotically optimal block quantization. IEEE Transactions on Information Theory 25 (4), p. 373–380. Cited by: §2. S. Girish, K. Gupta, and A. Shrivastava (2023) SHACIRA: scalable hash-grid compression for implicit neural representations. In ICCV, Cited by: §1, §2. S. Girish, K. Gupta, and A. Shrivastava (2024) EAGLES: efficient accelerated 3d gaussians with lightweight encodings. In ECCV, Cited by: §2. I. Han, P. Kacham, A. Karbasi, V. Mirrokni, and A. Zandieh (2025) PolarQuant: quantizing kv caches with polar transformation. arXiv preprint arXiv:2502.02617. Cited by: §2. A. Hassan, A. Anupreetham, J. Meng, and J. Seo (2025) Quant-nerf: efficient end-to-end quantization of neural radiance fields with low-precision 3d gaussian representation. In ICASSP, Cited by: §2. C. Hooper, S. Kim, H. Mohammadzadeh, M. W. Mahoney, Y. S. Shao, K. Keutzer, and A. Gholami (2024) KVQuant: towards 10 million context length llm inference with kv cache quantization. In NeurIPS, Cited by: §1, §2. B. Kerbl, G. Kopanas, T. Leimkühler, and G. Drettakis (2023) 3D gaussian splatting for real-time radiance field rendering. In ACM Transactions on Graphics, Vol. 42. Cited by: §1, §3.2, §5.1. J. C. Lee, J. H. Ko, and E. Park (2025a) OMG: optimized minimal 3d gaussian splatting. In NeurIPS, Cited by: §1, Table 5. J. C. Lee, D. Rho, X. Sun, J. H. Ko, and E. Park (2024) Compact 3d gaussian representation for radiance field. In CVPR, Cited by: §2. S. Lee, F. Shu, Y. Sanchez, T. Schierl, and C. Hellge (2025b) Compression of 3d gaussian splatting with optimized feature planes and standard video codecs. In ICCV, Cited by: §2, Table 5. L. Li, Z. Shen, Z. Wang, L. Shen, and L. Bo (2023) Compressing volumetric radiance fields to 1 mb. In CVPR, Cited by: §2. Z. Liu, J. Yuan, H. Jin, S. Zhong, Z. Xu, V. Braverman, B. Chen, and X. Hu (2024) KIVI: a tuning-free asymmetric 2bit quantization for kv cache. In ICML, Cited by: §1, §2. S. Lloyd (1982) Least squares quantization in pcm. IEEE Transactions on Information Theory 28 (2), p. 129–137. Cited by: §1, §2, §3.3. J. Max (1960) Quantizing for minimum distortion. IRE Transactions on Information Theory 6 (1), p. 7–12. Cited by: §2, §3.3. B. Mildenhall, P. P. Srinivasan, M. Tancik, J. T. Barron, R. Ramamoorthi, and R. Ng (2020) NeRF: representing scenes as neural radiance fields for view synthesis. In ECCV, Cited by: §1, §5.1. W. Morgenstern, F. Barthel, A. Hilsmann, and P. Eisert (2024) Compact 3d scene representation via self-organizing gaussian grids. In ECCV, Cited by: §2, Table 5. T. Müller, A. Evans, C. Schied, and A. Keller (2022) Instant neural graphics primitives with a multiresolution hash encoding. In ACM Transactions on Graphics, Vol. 41. Cited by: item 3, §1, §3.2. K. L. Navaneet, K. P. Meibodi, S. A. Koohpayegani, and H. Pirsiavash (2024) CompGS: smaller and faster gaussian splatting with vector quantization. In ECCV, Cited by: §1, §2. S. Niedermayr, J. Stumpfegger, and R. Westermann (2024) Compressed 3d gaussian splatting for accelerated novel view synthesis. In CVPR, Cited by: §2, Table 5. C. E. Shannon et al. (1959) Coding theorems for a discrete source with a fidelity criterion. IRE Nat. Conv. Rec 4, p. 1. Cited by: §2. C. E. Shannon (1948) A mathematical theory of communication. The Bell System Technical Journal 27 (3), p. 379–423. Cited by: §2. Z. Su, W. Ye, H. Feng, K. Fan, J. Zhang, D. Yu, Z. Liu, and N. Wong (2026) XStreamVGGT: extremely memory-efficient streaming vision geometry grounded transformer with kv cache compression. arXiv preprint arXiv:2601.01204. Cited by: §2. T. Takikawa, A. Evans, J. Tremblay, T. Müller, M. McGuire, A. Jacobson, and S. Fidler (2022) Variable bitrate neural fields. In ACM SIGGRAPH, Cited by: §2. M. Tancik et al. (2023) Nerfstudio: a modular framework for neural radiance field development. In ACM SIGGRAPH, Cited by: §5.1. B. Tian, Q. Gao, S. Xianyu, X. Cui, and M. Zhang (2025) FlexGaussian: flexible and cost-effective training-free compression for 3d gaussian splatting. In ACM Multimedia, Cited by: §2, §5.5, Table 5. H. Wang, M. H. Vali, and A. Solin (2025) Compressing 3d gaussian splatting by noise-substituted vector quantization. In SCIA, Cited by: §2. S. Wang, V. Leroy, Y. Cabon, B. Chidlovskii, and J. Revaud (2024a) DUSt3R: geometric 3d vision made easy. In CVPR, Cited by: §1, §3.2, §5.1. Y. Wang, Z. Li, L. Guo, W. Yang, A. C. Kot, and B. Wen (2024b) ContextGS: compact 3d gaussian splatting with anchor level context model. In NeurIPS, Cited by: §2, Table 5. H. Xu, X. Wu, and X. Zhang (2025) Improving 3d gaussian splatting compression by scene-adaptive lattice vector quantization. arXiv preprint arXiv:2509.13482. Cited by: §2. P. L. Zador (1964) Development and evaluation of procedures for quantizing multivariate distributions. Stanford University. Cited by: §2. A. Zandieh, M. Daliri, M. Hadian, and V. Mirrokni (2025a) TurboQuant: online vector quantization with near-optimal distortion rate. arXiv preprint arXiv:2504.19874. Cited by: item 2, §1, §2, §2, §3.3, §6, §6, Lemma 1, Theorem 2, Theorem 3. A. Zandieh, M. Daliri, and I. Han (2025b) QJL: 1-bit quantized jl transform for kv cache quantization with zero overhead. In AAAI, Cited by: §2. K. Zhang, Y. Chen, Z. Liu, J. Yang, and W. Liu (2024) Hardware-friendly positional encoding quantization for fast and memory-efficient nerf. In ICONIP, Cited by: §2. Y. Zhang, C. Ma, J. Ge, L. Jiang, J. Xu, and W. Zhang (2025) HERO: hardware-efficient rl-based optimization framework for nerf quantization. arXiv preprint arXiv:2510.09010. Cited by: §2. Z. Zhang et al. (2024) LP-3dgs: learning to prune 3d gaussian splatting. In NeurIPS, Cited by: §2.