acceptodds
Under review as a conference paper at ICLR 2027

Neural Reparameterization for 3D Gaussian Splatting Compression

Abstract

While effective in diverse applications, including 3D/4D novel-view synthesis, Gaussian Splatting typically requires substantial storage to represent high-quality scenes. Many existing compression methods partially formulate this problem as point-based coding, treating Gaussians as a set of primitives with positions (or anchor locations) and rich appearance and shape attributes. These positions must therefore be encoded at high precision, as the storage cost scales with the number of primitives. However, many different sets of Gaussians can render the same scene equally well, so it is their spatial distribution that carries visual information and needs to be transmitted rather than any particular set. In this work, we propose GSRC, a Gaussian Splatting compression framework that achieves efficient representation and compression through neural reparameterization, which represents the Gaussians implicitly as the output of two networks instead of storing them. The first network maps a set of deterministic pseudo-random samples to a coarse point cloud representing the scene geometry, while the second one predicts the fine attributes of the Gaussians at these points using multi-resolution hash tables. To enable compact storage, we apply rate-aware training and entropy-code the resulting network parameters. Our results demonstrate that point cloud compression is not strictly necessary to achieve high-quality Gaussian Splatting representations, and that GSRC yields strong compression performance while preserving rendering quality, through implicit representation learning and model compression alone. Before entropy coding, the reparameterized model is 4 smaller than 3D-GS on Mip-NeRF 360 at 0.5 dB higher PSNR, which we attribute to the prior of the network. After coding, GSRC is about 100 smaller than 3D-GS at 0.25 dB higher PSNR, outperforms recent codecs with context models in most cases, especially in SSIM and LPIPS, and requires 49% fewer bytes than HAC++ at equal PSNR while decoding 24 faster. The implementation will be released.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Gaussian Spatting, Compression

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_4dkDOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes GSRC, a neural reparameterization framework for 3D Gaussian Splatting compression. Previous methods need to explicitly store Gaussian positions or attributes, while GSRC represents the Gaussians implicitly as the output of networks. Specifically, it employs a coarse MLP to generate Gaussian positions from deterministic pseudo-random samples and a fine MLP with multi-resolution hash grids to predict Gaussian attributes. To achieve compression, the network parameters are optimized through rate-aware training and entropy-coded without relying on context models. The method is evaluated on NeRF-Synthetic, Mip-NeRF 360, Tanks&Temples, Deep Blending, and BungeeNeRF. Experimental results demonstrate competitive performance against existing Gaussian compression methods.

Critical strengths
  1. Novel framework for 3D Gaussian Splatting compression. The paper introduce a novel framework that eliminates the need to explicitly store Gaussian positions or attributes. Instead, it utilizes two neural networks to implicitly store Gaussian positions and attributes. GSRC is the first scene-specific 3D-GS compression framework that does not require storing explicit Gaussian or anchor set.
  2. Extensive experimental evaluation. The paper provides extensive experimental results across multiple benchmarks, with detailed comparisons against existing methods. The figures and tables are well presented and clearly illustrate the performance of the proposed method. Overall, GSRC demonstrates promising compression performance while maintaining competitive rendering quality
Critical weaknesses
  1. Limited discussion of related feed-forward Gaussian representations. Since the Gaussians are generated by neural networks, the proposed framework shares similarities with existing feed-forward Gaussian Splatting methods. Existing methods have already explored generating or representing Gaussian parameters using neural networks, including neural Gaussian compression. Although GSRC further eliminates the need to store explicit Gaussian positions or anchors, the paper does not sufficiently clarify how its neural reparameterization differs from these existing approaches. A more detailed discussion and comparison would help better establish the novelty of the proposed method.
  2. High optimization cost. Although GSRC achieves competitive compression performance and faster decoding, it requires substantially longer training time than existing methods. As shown in Table 2, GSRC takes 124 minutes per scene, compared to 54 minutes for HAC++. Since the neural networks are optimized separately for each scene and do not generalize to other scenes, it is unclear whether the additional training cost is justified by the storage savings.
Questions for authors
  1. Training stability. The proposed method generates Gaussian positions using pseudo-random samples from a fixed seed. Will the seed selection strategy affect the final reconstruction quality? In Appendix Figure 13, some runs are reported to have collapsed during rate-aware fine-tuning. Could the authors explain what causes these failures and how frequently they occur across different configurations? Does this indicate a potential stability issue with the proposed compression framework?
  2. Effectiveness and Applicability of GSRC-V. Although GSRC-V introduces a view-dependent decoder to provide more flexible Gaussian attribute prediction, it does not consistently improve rendering quality across datasets. Could the authors further clarify the effectiveness of the view-dependent decoder?
4 comments

We thank the reviewer for the careful review, and for noting that GSRC is the first scene-specific 3D-GS compression framework that does not store an explicit Gaussian or anchor set. We answer each point below and points shared with other reviewers are also summarized in the general response.

W1 — Feed-forward and neural Gaussian methods.

We agree that the difference from existing neural Gaussian methods deserves further clarification. We have added a paragraph, "Feed-forward Models for Gaussian Splatting", to §2 and clarified the key difference at the beginning of §3: what is stored to represent each scene. In particular:

  • Feed-forward reconstruction models (e.g. pixelSplat, MVSplat, GS-LRM) predict Gaussians fast with a network shared across scenes, without fitting the scene, but output an explicit set that still has to be stored or coded. Generative models (e.g. L3DG, DiffGS) decode Gaussians from a compact latent with a shared decoder, but are trained for a category of objects or rooms and are not optimized to compress a given scene. The feed-forward codec FCGS compresses an already-fitted explicit set, including their positions.

  • Neural Gaussian methods (e.g. Scaffold-GS, HAC++, ContextGS, NeuralGS) fit networks per scene, but still store anchors or positions explicitly. In contrast, GSRC reparameterizes the entire Gaussian scene, including positions, through scene-specific neural networks. Only the network parameters and a seed are needed to reconstruct the Gaussians, eliminating explicit position or anchor storage. The decoded Gaussians can then be rendered by a standard rasterizer, with fast decoding (0.86 s at T = 20, N = 2^22).

W2 — Training cost.

We acknowledge that GSRC requires longer training than HAC++ (54 min): 126–269 min depending on N (Table 7), and 130 min as the median over all models (Table 2). This reflects a trade-off between one-time encoding cost and storage and decoding efficiency. While the networks are optimized separately for each scene, GSRC achieves substantial storage savings (45% BD-rate reduction over our reproduced HAC++ results on Mip-NeRF 360), and decoding is 24–29× faster than HAC++. This trade-off is particularly relevant to scenarios where a scene is encoded once but stored, transmitted, and decoded repeatedly.

We also investigated reducing the optimization cost. Halving the training time reduces PSNR by only 0.12 dB, while GSRC still matches HAC++ at equal coded size on Mip-NeRF 360 (N = 2^20, against the published HAC++ results). Our current training pipeline has not yet been optimized for speed, leaving room for further improvements, such as meta-learning network initialization across scenes.

Q1 — Seeds and collapses.

Our results show limited sensitivity to random seeds. To verify this, we retrained every table size on all datasets using three random seeds (Appendix A.6, Fig. 14, Table 5). The standard deviation of the dataset-mean PSNR is at most 0.04 dB on Mip-NeRF 360 and 0.12 dB on Tanks&Temples. Moreover, seed 0 differs from the three-seed mean by no more than 0.04 dB on Mip-NeRF 360, supporting the robustness of our original results.

Regarding the collapses, we traced them to an overly high learning rate multiplier for the position offsets inherited from 3D-GS, rather than an inherent instability of the framework. This affected 17 of the 120 Tanks&Temples models in the submission (all on Train, plus one each on Mip-NeRF 360 and Deep Blending). To address this, we reduced the learning rate by 8× and retrained all models. The revised experiments show improved training stability, with no collapses observed in Fig. 5.

Q2 — Effectiveness of GSRC-V.

We acknowledge that the benefits of GSRC-V vary across datasets. With the revised models, GSRC-V improves on GSRC on four of the five datasets (21–49 % fewer bytes at equal PSNR on NeRF-Synthetic, Mip-NeRF 360, Tanks&Temples and BungeeNeRF; Appendix A.5), but not on Deep Blending, where it is at parity at low rates and up to 0.19 dB below at high rates (Table 4).

The largest gain is observed on BungeeNeRF (49 % fewer bytes than GSRC, and 12 % fewer than HAC++), a large-scale scene captured from very different distances, whose views can be inconsistent. We attribute this improvement to GSRC-V's view-dependent decoder which adapts to the view direction and distance, as in Scaffold-GS/HAC++/etc, which can better absorb part of this inconsistency than a static set of Gaussians. This observation is consistent with KISS-GS, which similarly reports that anchor-based learned representations "better absorb capture inconsistencies" and we observe this effect on BungeeNeRF.

These gains come at an additional cost: GSRC-V requires 9–14% more storage at the same table size, with its view-dependent decoder accounting for approximately one-third of rendering time, alongside longer training (Table 7). We therefore consider GSRC-V particularly suitable for scenes with large scale variations or view-dependent appearance, while GSRC remains our default choice.

The authors have clarified my doubts in the rebuttal and I will raise my rating to 3-weak acceptance.

Thanks for your positive feedback and for raising your rating! We are glad that our rebuttal has addressed your concerns, and we sincerely appreciate your time and consideration.

Reviewer_vyf2OpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

GSRC represents a scene through a seeded coarse point generator and hash-grid-conditioned attribute heads, rather than transmitting explicit Gaussian or anchor positions. After fitting and freezing the quantized coarse generator, the fine representation is optimized through rasterization and then fine-tuned with a rate-distortion objective. Its weights are compressed with context-free entropy models. Experiments on synthetic, indoor/outdoor, and multiscale scenes demonstrate competitive rate-distortion performance, particularly on Mip-NeRF 360, and fast decoding to explicit Gaussians.

Critical strengths
  1. The representation is the most compelling contribution: geometry is reconstructed from a shared seed and a compact generator, while spatially varying residuals and attributes are represented by hash grids. This offers a useful alternative to explicitly coding a primitive or anchor set and permits substantial changes in primitive count with comparatively small changes in coded size (Sec. 4).

  2. The gains are practically interesting and supported by actual coded sizes, multiple datasets, and component ablations. On Mip-NeRF 360, Table 1 reports 27.79 dB at 6.6 MB versus HAC++ at 27.80 dB and 15.4 MB. Table 2 reports decoding to reconstructed Gaussians in 0.85 s versus 20.80 s for HAC++. The paper also reports regimes where competing codecs perform better, which helps delimit the contribution.

Critical weaknesses
  1. The deployment trade-off is incomplete. Several headline operating points generate 2^22 Gaussians, but the evaluation does not report rendering FPS or peak/resident GPU memory at comparable image quality and coded size. Using the standard rasterizer does not establish comparable rendering cost when primitive counts differ; GSRC-V additionally evaluates a view-dependent decoder. These measurements could materially change the practical assessment of the codec.

  2. The precision of the cross-codec comparison is less secure than the headline numbers suggest. Appendix A.4 states that the compressed baselines are taken from published results, with some resolution differences explicitly marked. Table 2 is described as a GH200 timing comparison, but the provenance and measurement procedure for baseline times are not sufficiently explicit. Matched-protocol rate-distortion results and an unambiguous timing breakdown would make the magnitude of the gains more convincing.

Questions for authors
  1. At representative Mip-NeRF 360 operating points, what are rendering FPS, decoded Gaussian count, and peak/resident GPU memory for GSRC, GSRC-V, and HAC++ at matched quality or size? Please include GSRC-V's view-decoder cost.

  2. Were all Table 2 timings measured on the stated GH200 with the same implementation conditions? Please separate initial fitting, render training, rate-aware fine-tuning, entropy decoding, and Gaussian reconstruction, and clarify which stages enter the 124-minute training number.

  3. Can the main Mip-NeRF 360 advantage be confirmed under the same image-resolution/evaluation protocol for the strongest compressed comparator? Please also specify the overlapping rate-distortion interval used for the reported 49% BD-rate saving.

4 comments

We thank the reviewer for the precise questions, and for noting that GSRC lets the number of Gaussians change substantially at a comparatively small change in coded size. We answer each point below and the revised paper now contains the requested measurements.

W1 / Q1 — Rendering FPS, Gaussian count and GPU memory.

Thank you for raising this concern. In short, GSRC's rendering cost is primarily determined by the number of Gaussians N rather than the bitrate. At N = 2^20, GSRC renders faster than HAC++ at matched PSNR (264 vs. 233 FPS, with smaller coded sizes of 6.0 vs. 8.9 MB). However, at N ≥ 2^21, GSRC becomes slower at comparable PSNR and coded sizes (~20 MB). We also acknowledge that GSRC requires more GPU memory than HAC++ at matched PSNR.

To provide a comprehensive comparison, we have added rendering FPS and GPU memory benchmarks in Appendix A.7 (Fig. 15, Table 6). We evaluate bicycle, garden and stump, the three Mip-NeRF 360 scenes also evaluated by CAT-3DGS, on a GH200 at the evaluation resolution. FPS is the median across the test views, including the per-view MLPs of GSRC-V and the context-model codecs. Memory is the GPU memory while rendering (for the baselines, the peak allocated, including their anchors and MLPs). Each row covers T = 17–22 or the method's rate parameters:

methodsize (MB)PSNR (dB)FPSmemory (GiB)
GSRC, N = 2^203.3–58.625.79–26.30255–2680.93–1.11
GSRC, N = 2^213.3–61.425.78–26.42162–1791.63–1.96
GSRC, N = 2^223.3–61.025.59–26.49100–1092.99–3.34
GSRC-V, N = 2^213.9–64.225.75–26.48126–1421.64–2.14
GSRC-V, N = 2^223.9–64.825.69–26.5473–853.17–3.89
HAC++4.6–26.925.71–26.37193–2690.46–0.94
ContextGS8.8–32.625.79–26.38181–2091.19–1.40
PCGS17.7–36.026.37–26.46205–2080.87–0.90
CAT-3DGS2.4–18.524.93–26.46210–2911.00–1.26

We further extended the comparison to all nine Mip-NeRF 360 scenes (partial results; the final version will report the complete evaluation). At T = 20, N = 2^20, GSRC achieves a smaller coded size (17.5 vs. 19.3 MB), higher PSNR (27.88 vs. 27.78 dB), and faster rendering (241 vs. 197 FPS) than HAC++, although it requires more GPU memory (1.01 vs. 0.74 GiB).

The rendering differences mainly arise from the number of Gaussians processed. GSRC passes all N Gaussians to the rasterizer (4.2 M at N = 2^22, about half of them on screen), while HAC++ passes the neural Gaussians it generates per view (0.47 M at its largest size). For GSRC-V, the view decoder takes about a third of its rendering time. We also evaluated post-decoding pruning: dropping the decoded Gaussians with opacity below 0.01 raises FPS by 24 % at almost no PSNR cost (−0.005 dB).

W2 — Provenance of the baselines.

We have updated Appendix A.4 to explicitly indicate, for each baseline and dataset, whether the results were reproduced by us or taken from published sources. Results evaluated under different protocols (image resolution, background settings, or PSNR conventions) are marked with † for transparency. To directly address Q3 and ensure a consistent comparison, we have also re-run HAC++, ContextGS, and PCGS on Mip-NeRF 360 under our evaluation protocol.

Q2 — Timing conditions and per-stage breakdown.

All results in Table 2 were measured on a single NVIDIA GH200, using the publicly available implementations for the baselines. We have re-measured the timings in Table 2 using the revised models, covering all 270 models on Mip-NeRF 360. The median training time is 130 minutes, including initial fitting but excluding the ~2 minutes required to generate the EDGS target cloud. To provide further insight into the computational cost, we have also added a per-stage timing breakdown in Table 7 ( also shown below) for the T = 20 models, reporting the median across all nine scenes. The total time includes logged evaluations, so it does not exactly equal the sum of the individual stages.

modelinitial fitting (min)training (min)fine-tuning (min)total (min)encoding (s)decoding (s): entropy + coarse + fine
GSRC, N = 2^209.669.244.4126.00.580.42 + 0.14 + 0.01
GSRC, N = 2^219.599.962.1174.30.510.45 + 0.21 + 0.02
GSRC, N = 2^229.6160.296.1268.90.620.47 + 0.35 + 0.04
GSRC-V, N = 2^219.7116.771.8200.00.720.56 + 0.28 + 0.03
GSRC-V, N = 2^229.6190.3109.8311.70.800.57 + 0.46 + 0.05

The 0.71 s decoding time reported in Table 2 (29× faster than HAC++) is the median across all models, excluding the fine forward pass (≤0.05 s). Even when including this step, GSRC at N = 2^22 decodes in 0.86 s, remaining 24× faster than HAC++ (20.80 s).

Q3 — Same protocol for the strongest baselines; the overlap interval.

To ensure a fair comparison, we re-ran HAC++, ContextGS and PCGS on all nine Mip-NeRF 360 scenes under the same evaluation protocol as GSRC (1,600 px width, every eighth image held out). Our HAC++ results closely reproduce the published results, with differences within 0.04 dB in PSNR and 1% in coded size. At matched PSNR, GSRC achieves 45% BD-rate savings over our reproduced HAC++ results, 63 % over ContextGS and 43 % over PCGS (Appendix A.5).

Regarding the overlapping PSNR interval, the originally reported 49% BD-rate saving was computed against the published HAC++ results over 27.60–27.82 dB, covering the entire published HAC++ PSNR range. With our revised GSRC models, the saving over this same interval is 46%. Against our reproduced HAC++ results, the overlap is 27.21–27.80 dB (HAC++ spans 26.79–27.80 dB), yielding a 45% BD-rate saving. The cell cited in the review corresponds to the submitted models, while the revised Table 1 reports the published HAC++ point closest in coded size to our largest model (27.82 dB at 19.4 MB).

Thank you for the detailed response and additional experiments, which have adequately addressed my concerns. I will maintain my positive rating and wish the authors the best of luck.

Thanks for your encouraging feedback and continued support! We sincerely appreciate your time and thoughtful consideration of our work, wish all your best!

Reviewer_fWTDOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a learning-based framework for compressing 3D Gaussian Splatting (3DGS) by reducing the storage overhead of per-Gaussian attributes. Instead of explicitly storing Gaussian positions, the method employs an MLP to model the scene's spatial distribution, from which Gaussian positions are generated through sampling. These sampled positions are subsequently refined using a lightweight MLP, while the remaining Gaussian attributes are predicted from learnable features retrieved from a 3D hash grid.

Critical strengths
  • The paper addresses the storage overhead of high-precision Gaussian positions and per-point attributes by using a neural network to decode the attributes.

  • The paper provides an interesting insight that even without explicitly storing per-point attributes, the proposed method outperforms other per-point-based methods, suggesting that per-point attribute coding may not be necessary.

Critical weaknesses
  • It is unclear whether a simple coarse MLP can represent a very complex (and unbounded) scene. The idea is interesting but more insights are required. In particular, how this MLP handles bounded and unbounded scenes is unclear. Whether this would impact the precision needed for the network weights of MLP.

  • The training of the coarse MLP requires a good initial point cloud distribution. This may complicate the training process and require additional pre-processing. In addition, this coarse MLP does not seem to be trained end-to-end together with the other components. The text indicates that "Once the distribution is fitted, the coarse MLP is frozen." This may make the whole system sub-optimal, not really rate-distortion optimized. In addition, the choice of N and T appears to be ad-hoc and brute-force.

  • Lack of a Masking or Pruning Mechanism: Unlike rate-distortion-optimized backbones such as CAT-3DGS, the proposed method does not incorporate a masking or pruning mechanism to reduce the number of Gaussians. When a large number of points are sampled, all generated Gaussians must be retained during rendering, potentially leading to substantial memory overhead.

Questions for authors
  • Could the authors explain the significant collapse in PSNR, SSIM, and LPIPS observed in Figure 5 on the Tanks and Temples and Deep Blending datasets? Do these collapses indicate instability in the proposed method?

  • According to Eq. (2), the displacement appears to be applied in the "real" domain (a sigmoid inverse is applied to \alpha u + b) rather than the "logit" domain. However, the text reads "in the logit space."

  • It is interesting to learn that a simple MLP of 0.1MB is sufficient to model the shape distribution. I wonder if this has to do with how complex the scene is. Does this conclusion apply to both bounded and unbounded scenes?

  • What is the reason of using rANS coder? How about arithmetic coder?

  • The codec appears to be stochastic. How do you report PSNR/LPIPS? Do you take the average of several runs? There should be a confidence interval.

2 comments

We thank the reviewer for the detailed review, and for the observation that per-point attribute coding may not be necessary. We answer each point below and points shared with other reviewers are also summarized in the general response.

W1 / Q3 — Can a simple coarse MLP model complex, unbounded scenes, and at what weight precision? Does 0.1 MB hold for bounded and unbounded scenes alike?

Yes. The same coarse MLP is used on all five datasets. The scene transform (PCA alignment and the Mip-NeRF 360 contraction) first maps every scene, bounded or unbounded, into the unit cube (§3), so the coarse MLP sees all scenes in the same normalized frame.

Importantly,the coarse MLP is not expected to capture all scene details: it only models the spatial distribution of the points, while the fine position offset (predicted by fine MLP, not per-point stored), trained through the rasterizer, recovers the detail. Appendix A.8 shows this: the coarse positions alone already form recognizable views of the scenes, and the fine positions restore thin structures (Fig. 16).

Regarding precision, the coarse MLP has ~80K parameters stored at 10 bits, i.e. ~0.1 MB, the same on every dataset and a small share of the coded file (0.2–3 % on Mip-NeRF 360). Lowering it to 8 bits costs only 0.05 dB, and fp32 gains 0.01 dB (Table 3).

W2 — Initialization, the frozen coarse MLP, and the choice of N and T.

GSRC requires a dense target cloud, which we obtain it with EDGS (its inititialization cloud, not the trained Gaussians) in ~2 min per scene and reuse it across N and T (Appendix A.7). The method is not tied to EDGS: with a 3D-GS or a FastGS cloud, PSNR changes by only −0.16 / −0.03 dB, and only a sparse SfM cloud costs more (0.61 dB, Table 3).

We freeze only the coarse generator because hash grids require stable query coordinates (§3.1). The final positions are still optimized through the rasterizer and the rate–distortion objective, via the fine position offset, and the frozen part costs only ~0.1 MB. With the offset disabled, PSNR drops by ~2 dB (Appendix A.8, Fig. 17): the attributes recover most of the scene from the positions of a lightweight coarse MLP, and the offset adds the remaining accuracy.

Regarding N and T, a joint search is unnecessary because they serve different purposes: N mainly sets the rendering cost and T mainly controls the rate, while both affect quality. For example, at T = 20 on Mip-NeRF 360, increasing N from 2^18 to 2^22 improves PSNR by 0.8 dB while the coded size grows only from 14.7 to 17.4 MB. In practice, N is chosen from the rendering budget, and T is adjusted to target different bitrates, training one model per rate point, as λ does in other codecs.

W3 — No masking or pruning, memory overhead.

We acknowledge that GSRC does not currently employ masking or pruning and requires more GPU memory than HAC++ at matched PSNR (Appendix A.7, Table 6). However, the number of Gaussians (N) provides a way to control memory usage. At (N=2^{20}), GSRC uses approximately 1 GiB of GPU memory, comparable to CAT-3DGS with Gaussian masking.

We also investigated post-decoding pruning, which requires no changes to the bitstream. Removing Gaussians with opacity below 0.01 results in a negligible PSNR drop (−0.005 dB) while improving rendering FPS by 24%. Incorporating learned masking during training is a promising direction for future work. Please also see our general response (A4).

Q1 — The collapses in Fig. 5 (Tanks&Temples, Deep Blending). Do they indicate instability?

Thank you for highlighting this issue. We traced these collapses to an overly high learning rate for the position offsets, rather than an inherent instability of our method. Specifically, we adopted the per-attribute learning rates from 3D-GS, but the learning rate for position offsets was too large, causing the learned positions to drift significantly from their coarse positions. This affected 17 out of 120 runs on Tanks&Temples (all on the Train scene) and 1 out of 120 runs on Deep Blending in the original submission.

In the revised paper, we reduced the learning rate by a factor of 8 and retrained all models. The updated results show improved training stability, with no collapses observed in Fig. 5.

Q2 — "Logit space" in Eq. 2.

We would like to clarify that the displacement is indeed added in logit space. Specifically, in Eq. 2, x^=σ(σ−1(αu+β)+F(γ(u)))\hat x = \sigma\big(\sigma^{-1}(\alpha u + \beta) + F(\gamma(u))\big), the inner term σ−1(αu+β)\sigma^{-1}(\alpha u + \beta) is the logit of the scaled sample, FF is added to it, and σ\sigma maps the sum back to [0,1]3[0, 1]^3. We have clarified this operation explicitly in the revised §3.1.

Q4 — Why rANS rather than an arithmetic coder?

We chose rANS because it is widely used in neural compression and is readily supported by libraries such as CompressAI. Both rANS and arithmetic coding can achieve coding rates close to the entropy model's estimates, with negligible overhead. In our implementation, rANS with static distributions also allows the encoded tables to be partitioned into independently decodable chunks, enabling parallel decoding and improving GSRC's decoding efficiency.

We have provided the coding efficiency in Appendix A.3, where the actual coded sizes differ from the entropy model's estimates by less than 0.03%.

Q5 — Is the codec stochastic? Confidence intervals.

The codec is deterministic: the decoder regenerates the same coarse positions from the seed, and rANS is lossless. The variation comes from training only.

To further validate the robustness of our results, we have rerun the experiments for every table size on all three datasets using three random seeds. We report the updated results in Appendix A.6 (Fig. 14, Table 5). The standard deviation of the dataset-mean PSNR is at most 0.04 dB on Mip-NeRF 360 and NeRF-Synthetic, and 0.12 dB on Tanks&Temples. Notably, Seed 0 differs from the three-seed mean by no more than 0.04 dB on Mip-NeRF 360, confirming the consistency of our original results.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General response: summary of the revision (1/2)

We thank the reviewers for their careful reading and constructive feedback. We appreciate their recognition that:

  • GSRC stores no explicit Gaussian positions or attributes (fWTD, vyf2, 4dkD);
  • it outperforms the methods that explicitly code per-point attributes, suggesting that such coding may not be necessary (fWTD);
  • its compression gains are practically interesting and supported by actual coded sizes on multiple datasets (vyf2), with promising compression performance and competitive rendering quality (4dkD);
  • it supports a wide range of Gaussian counts at a comparatively small change in coded size, and decodes quickly (vyf2);
  • the evaluation is extensive (4dkD).

We have carefully addressed the reviewers' concerns through additional experiments, analyses, and clarifications. The main revisions are summarized below, with further details in our individual responses.

1. What the revision adds

  • Rendering and training cost (new Appendix A.7): FPS and GPU memory against PSNR (Fig. 15), a matched-size comparison with HAC++, ContextGS, PCGS and CAT-3DGS (Table 6), and per stage training and decoding times (Table 7). Table 2 is re-timed on the revised models. (vyf2, fWTD-W3, 4dkD-W2)
  • Baselines under a consistent protocol (Appendix A.5): we re-ran HAC++, ContextGS and PCGS on Mip-NeRF 360 at the same resolution and split. Our HAC++ runs reproduce the published points within 0.04 dB and 1 % in size. Appendix A.4 states which baselines are re-run and which are published, and how encoding and decoding are timed. (vyf2-W2/Q3)
  • Robustness across seeds (Appendix A.6, Fig. 14, Table 5): we retrained every table size on every dataset with three random seeds to assess result consistency. (fWTD-Q5, 4dkD-Q1)
  • Coarse and fine positions (Appendix A.8, Figs. 16–17): we added visualizations of coarse and refined positions and an ablation without the fine position offset. (fWTD-W1/W2/Q3)
  • Additional analyses: the rANS overhead (A.3) and GSRC-V against GSRC (A.5). (fWTD-Q4, 4dkD-Q2)
  • Related work (§2): a new paragraph on feed-forward models for Gaussian Splatting. (4dkD-W1)

2. Updated models

All results in the revision come from retrained models. The architecture, the bitstream and the codec remain unchanged. The main correction addresses the learning rate of the position offsets:

  • Position learning rate. GSRC inherited the per-attribute learning rates of 3D-GS. We found that the learning rate of the position offset was too large: the learned positions drifted far from their coarse positions. Reducing it by a factor of 8 gives most of the stability improvement, and it eliminates the collapses highlighted by fWTD (Fig. 5) and 4dkD (Fig. 13), most of which occurred on the Tanks&Temples Train scene.
  • λ tied to the table size. The submitted models used one fixed λ at every table size T. λ now doubles with each step in T, λ = 4096 · 2^(T − T_max), which is 1024 at T = 20 as before. This slightly improves the high rates.
  • Minor refinement: the learning-rate warm-up of the rate-aware fine-tuning is 1,500 iterations instead of 500.

Effect of the update

  • Training Stability. The original training recipe produced collapses in 17 of the 120 Tanks&Temples models. After the correction, the revised runs show stable training.
  • Compression performance. At matched PSNR, GSRC requires 46 % fewer bytes than the published HAC++ points on Mip-NeRF 360 (49 % in the submission; 45 % against our re-runs), and 54 % fewer on Tanks&Temples and Deep Blending pooled.
  • Performance variations. We also report some results decreased: the saving on NeRF-Synthetic decreased from 16% to 8%, while Deep Blending alone shows a 41% bitrate increase.
  • Computational cost. Table 2 is re-measured on all 270 Mip-NeRF 360 models: 130 min of training (median over every N and T) and 0.71 s of decoding (29× faster than HAC++), excluding the final fine forward. Inlcuding it, the largest GSRC models decode in 0.86 s (24×).
AuthorsOpenReview ↗

General response: summary of the revision (2/2)

3. Clarifications on Key Reviewer Concerns

  • A1 Training stability (fWTD-Q1, 4dkD-Q1): We traced the collapses in the submission to an excessively high learning rate for the position offsets, rather than an inherent instability of the framework (§2, part 1/2). After correcting the learning rate and retraining all models, the collapses are eliminated. Our three-seed experiments further confirm the consistency of the revised results (A2).
  • A2 Seeds and confidence (fWTD-Q5, 4dkD-Q1): Decoding is deterministic: the stored seed regenerates the same coarse positions, and rANS is lossless. The seed sets the pseudo-random samples, the network initialization and the random choices of training, so the variation comes from training. Over three seeds (Appendix A.6, at N = 2^20), the standard deviation of the dataset-mean PSNR is at most 0.04 dB on Mip-NeRF 360 and 0.12 dB on Tanks&Temples, demonstrating limited sensitivity to random seeds.
  • A3 Training cost (4dkD-W2; per-stage times for vyf2-Q2):We acknowledge that GSRC requires longer training than HAC++ (54 min): 126, 174 and 269 min at N = 2^20, 2^21 and 2^22 (Table 7). However, with half the training, GSRC still matches the PSNR of HAC++ at equal size on Mip-NeRF 360 (N = 2^20, against the published HAC++ points), and decoding is 24–29× faster. GSRC's training has not been optimized for speed yet and future work can reduce it, e.g. by meta-learning the network initialization across scenes. Details are in the replies to 4dkD and vyf2.
  • A4 Rendering cost and GPU memory (vyf2-W1/Q1, fWTD-W3): Appendix A.7 (Fig. 15, Table 6) measures FPS and GPU memory against HAC++, ContextGS, PCGS and CAT-3DGS on three Mip-NeRF 360 scenes. Rendering cost is primarily determined by the Gaussian count N rather than the bitrate. With N = 2^20, GSRC renders faster than HAC++ at small sizes (264 against 233 FPS at the same PSNR, at 6.0 against 8.9 MB). With N ≥ 2^21, and at about 20 MB with equal PSNR, it renders more slowly, with N = 2^22 more slowly than every baseline, and at equal PSNR it needs more memory than HAC++. Details, with partial results on all nine scenes, are in the reply to vyf2. The final version will report all nine Mip-NeRF 360 scenes.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.