Reviewer3 (AI review)

October 2, 2026

AI Review (reviewer3.com)

Comments (3)

1. Redundancy between context sources — Major

the geometry context, the anchor latent, or both. Removing either source causes a small degrada- tion, indicating that the two context sources provide complementary information. When both are

The authors assert that both geometry context and anchor latents provide complementary and essential information for compression. However, the ablation curves in Figure 4 show that removing the geometry context ("Ours w/o geometry context") results in almost identical performance to the full model, and removing the anchor latent ("Ours w/o anchor latent") also results in only a very minor degradation. This indicates a high degree of redundancy between the two sources rather than them being complementary or individually essential. The authors should temper their claim or discuss why such redundancy exists, and whether the model could be simplified by omitting the geometry context entirely without sacrificing rate-distortion performance.

2. Asynchronous timing and transfer overhead — Minor

with transmitted CDFs. Coordinate- and attribute-coder times are measured with host timers, with- out synchronization at every component boundary. Context-network time is additionally measured with CUDA events. These component times are diagnostic rather than an exclusive decomposition:

The authors report that the neural context model introduces minimal decoding overhead, taking only 0.005 s on average. However, because the MLPs run on the GPU while the rANS entropy coding runs on the CPU, the causal sequential decoding of the 4 latent channels requires multiple sequential CPU-GPU round-trips. The reported "NN Dec." time of 0.005 s is measured using CUDA events, which only capture GPU execution time and completely omit the CPU-GPU transfer and synchronization overhead. Furthermore, the coordinate- and attribute-coder times are measured with host timers without synchronization at component boundaries, meaning these measurements do not accurately reflect the true execution and transfer overhead of each component due to PyTorch's asynchronous execution. The authors should provide a more rigorous timing analysis that includes CPU-GPU transfer overhead and uses proper synchronization to show the true cost of the sequential context modeling.

3. Systematic size increase in QAT model — Major

inference described in Sec. 3.7. Its rate–distortion curves remain close to the floating-point 15+30K model over most bitrate points, with only small differences at some low-bitrate points on DeepBlend-

The authors state that the QAT variant's rate-distortion curves remain close to the floating-point model with "negligible rate-distortion degradation." However, a closer look at the quantitative results in Tables 4 and 5 reveals a systematic and non-negligible increase in compressed scene size across all datasets and bitrates when using QAT. For example, on Tanks&Temples at lambda = 0.0160, the compressed size increases from 0.9933 MiB to 1.2088 MiB (a 21.7% increase), and on Mip-NeRF360 at lambda = 0.0080, it increases from 1.3158 MiB to 1.4831 MiB (a 12.7% increase). This systematic overhead is likely due to the reduced precision of the quantized context model leading to less accurate probability estimations and higher entropy. The authors should explicitly discuss this systematic size increase in the text and temper the claim of "negligible" degradation to accurately reflect this trade-off.

xPeerd (AI review)

October 2, 2026

AI Review (xPeerd — DAReview)

Summary

This manuscript, titled “Towards Practical Compression of 3D Gaussian Splatting,” introduces COSA-GS, a 3D Gaussian Splatting compression framework that replaces explicit spatial context aggregation with anchor-wise causal factorization and adds quantization-aware integer inference for cross-platform decoding consistency. The paper is clearly motivated by two practical concerns: the coding complexity of irregular spatial context modeling and floating-point inconsistency during entropy decoding across devices. The authors claim that COSA-GS achieves “state-of-the-art compression performance while retaining fast and consistent cross-platform decoding” and provide code for reproducibility . The manuscript’s main strengths are its focused practical objective, a relatively clean architectural idea, strong runtime improvements, and explicit attention to cross-platform consistency. The main weaknesses are that several central claims—especially “state-of-the-art” performance, practical generality, and consistency robustness—are framed somewhat more strongly than the evidence fully supports in the main text, and key methodological details needed to verify generality, fairness of comparison, and statistical robustness are underdeveloped or deferred to appendix/repository material. Overall, I find the work technically coherent and likely meaningful for practical 3DGS compression, but it would benefit from clearer qualification of claims, stronger experimental controls, and fuller reporting of limitations and failure cases.

Potential Major Revisions

1. The “state-of-the-art” claim is plausible but currently overgeneralized relative to the evidence shown. The abstract states that “Experiments demonstrate that COSA-GS achieves state-of-the-art compression performance while retaining fast and consistent cross-platform decoding” . The introduction similarly claims “state-of-the-art compression performance and fast decoding on Mip-NeRF360, DeepBlending, Tanks&Temples, and BungeeNeRF” . However, the performance discussion is more nuanced: on Mip-NeRF360, “SpeedyGS achieves higher SSIM and lower LPIPS at several bitrate points, while COSA-GS provides a stronger PSNR–size trade-off” . This means the paper is not uniformly dominant across quality metrics, and the contribution is better characterized as competitive or leading under selected operating points and metrics rather than unequivocally state-of-the-art. The authors should systematically qualify this language across the abstract, introduction, and conclusion, and ideally summarize exactly under which metrics, datasets, and bitrate ranges COSA-GS outperforms each baseline.

2. The fairness of comparisons needs more explicit methodological justification. The manuscript compares methods with different optimization budgets, e.g., “including HAC++ with 60K optimization steps” while COSA-GS default is “15+30K” and other variants are also considered . While this is useful, the paper does not fully explain whether all compared numbers are taken from original papers, re-run under a unified environment, or harmonized with identical preprocessing and evaluation settings. The appendix notes that “The rate–distortion results of the compared methods are based on the per-scene metrics reported in the corresponding papers” , which raises comparability concerns because implementation details, hardware, data preprocessing, and scene split conventions may differ across papers. Although the appendix says the authors “follow the image-resolution settings and training/test view splits used in the publicly released code of Scaffold-GS, HAC++, PCGS, and CAT-3DGS” , this still does not establish identical re-evaluation across all baselines. The paper should explicitly separate reproduced comparisons from extracted literature comparisons, state which baselines were run by the authors, and discuss the resulting limits on causal comparative claims.

3. Cross-platform consistency evidence is promising but still narrow. A central practical claim is that integer inference enables “bit-exact consistency of entropy-decoded symbols across platforms” . Table 2 reports “45/45” decoding consistency across three GPU–CPU configurations . This is a good result, but the evidence remains somewhat limited for a broad practical claim because it covers a modest number of tested bitstreams and apparently one experimental setting on Mip-NeRF360. The manuscript should more explicitly state the scope of the evidence. For example, are these 45 bitstreams distributed across scenes and λ values only for the 15+30K QAT setting? Are software stacks and driver versions varied substantially? The appendix references “software versions of the default platform” in Table 23 , but the robustness claim would be stronger if the paper reported consistency across more datasets, more operating systems or compiler settings, and adversarial stress cases where floating-point methods are known to fail.

4. The core causal modeling idea is intuitive, but the manuscript does not fully probe when spatial aggregation is actually unnecessary. The paper’s core premise is that “3DGS optimization itself can reduce inter-anchor dependence” and thus “complex spatial context aggregation [can] be replaced by simpler anchor-wise modeling” . This is interesting and technically coherent. However, the current evidence mainly demonstrates that the proposed architecture works well on the tested benchmarks; it does not yet establish the broader principle that anchor-wise context is sufficient across scene regimes. The ablation shows that removing geometry context and/or anchor latent causes degradation and that anchor context is “essential to the compression performance of COSA-GS” , but this is an internal validation of the proposed design, not a direct test of the manuscript’s broader theoretical claim about inter-anchor dependence. The paper would be strengthened by experiments stratified by scene structure, density, scale variation, or geometric complexity to show when anchor-wise factorization remains effective and when it may fail relative to stronger spatial context models.

5. Reproducibility is addressed, but important implementation details remain insufficiently self-contained in the manuscript. The reproducibility statement says the authors provide “model implementations, training configurations, and scripts for compression, decompression, and evaluation” in code . That is positive. However, the main paper still leaves several practical details underdescribed. For example, the implementation section says, “We initialize from a Scaffold-GS representation optimized for 15K iterations and use 30K rate–distortion optimization iterations as the default setting” , but readers need a more complete specification of optimization schedules, loss weighting, initialization sensitivity, and quantization-aware training configuration to judge reproducibility without repository dependence. Since the method’s practical value is a major selling point, the paper should move more operational details from appendix/repository into the main methods section.

6. The evaluation emphasizes aggregate curves, but uncertainty and robustness are underreported. The reported evidence focuses on dataset-average PSNR/SSIM/LPIPS, compressed size, and coding times . The appendix offers detailed per-scene results and coding times , which is helpful. Still, the manuscript does not report variance across repeated runs, confidence intervals, or sensitivity to random seeds. Since neural compression and optimization-heavy 3DGS pipelines can exhibit run-to-run variability, the practical significance of small numerical advantages is difficult to assess. This is especially relevant where the manuscript argues that some variants show “little improvement” or “slightly improves” performance . Without uncertainty quantification, these conclusions may be accurate but are not fully supported statistically.

7. The runtime claims are impressive, but component-level interpretation should be clarified. The manuscript reports very fast decoding, e.g., “0.1279 s” on the flowers scene versus “24.95 s for HAC++ and 25.49 s for PCGS” , and states that the context model adds little overhead because “The neural context model requires only 0.003–0.008 s” . These are compelling numbers, but the paper should clarify which parts of the pipeline are included consistently across methods, whether baseline runtimes were measured by the authors or copied from original reports, and whether I/O, data transfer, and rendering setup are excluded. Otherwise, the practical decoding advantage may be real but not fully apples-to-apples.

8. Limitations and failure cases are not discussed sufficiently. The conclusion is strongly positive, stating that experiments “demonstrate the effectiveness of this simple anchor-wise architecture for practical 3DGS compression” . Yet I do not see a dedicated limitations discussion in the retrieved text. Given the practical framing, the paper should openly discuss the conditions under which the absence of spatial aggregation might become a liability, possible degradation on scenes with strong nonlocal dependencies, and the cost of transmitting “Model + metadata,” which increases fractionally at low rates according to the appendix bit-allocation analysis .

Potential Minor Revisions

1. Writing and phrasing issues The manuscript is generally well written, but several formulations should be softened for precision:

• In the abstract, “state-of-the-art compression performance” should be qualified, because later analysis acknowledges metric-specific trade-offs with SpeedyGS .
• In the introduction, “allowing complex spatial context aggregation to be replaced by simpler anchor-wise modeling” is a strong mechanistic statement that would benefit from wording such as “can often be replaced” or “is empirically shown here to be replaceable on the tested benchmarks” .
• “Practical” appears prominently in the title and framing ; the paper should define practical more explicitly, e.g., in terms of decoder stability, runtime, portability, or deployment constraints.

2. Formatting and presentation issues

• The PDF text extraction shows hyphenation and character-encoding artifacts such as “rate–distortion,” split words, and accent corruption in citations; these may partly be extraction artifacts, but the authors should still verify the final typeset version carefully for typography consistency .
• Several important experimental qualifications are relegated to appendix references such as “More implementation details are provided in the appendix and the repository” . A compact main-text summary table of training settings would improve readability.
• The notation “15+30K,” “15+30K QAT,” and “15+45K” is eventually explained , but a reminder in figure captions or tables would reduce reader burden.

3. Typographic/grammatical observations I do not identify major grammatical errors from the retrieved passages, but there are a few style improvements:

• “This raises a practical question: can we achieve…” is effective prose, but the introduction could transition more explicitly from prior methods to the manuscript’s hypothesis .
• “Note that anchor-wise does not mean discarding spatial information” is helpful but slightly defensive; it might be better integrated with a concise formal intuition .
• The sentence “The sum of the component decoding times may slightly exceed the total decoding time, as expected” would benefit from a brief explanation directly following it rather than leaving the justification implicit .

4. AI content analysis The manuscript includes an explicit AI use statement: “we used generative AI tools to assist with language editing and the implementation and debugging of code” and further states that the authors reviewed the outputs and “take responsibility for the manuscript, code, and reported results” . Based on the writing style in the retrieved sections, I see no obvious signs of low-quality synthetic text generation, fabricated conceptual transitions, or semantically incoherent exposition. The prose is comparatively uniform, technically consistent, and discipline-appropriate. My conservative estimate is that the manuscript may include light AI-assisted phrasing or polishing in limited sections, consistent with the disclosure, but not pervasive AI-generated scientific reasoning. Estimated AI-generated content: low to moderate, roughly 10–20%, primarily at the level of language refinement rather than core technical argumentation. Assessed epistemic impact: low, provided the disclosed use statement is accurate, because the technical claims, equations, and experiments appear internally coherent in the retrieved material.

5. Anti-fraud / coherence check I do not detect obvious paper-mill indicators in the retrieved content. The manuscript fits a recognized computer vision / neural compression paradigm, engages directly with recent literature, defines a concrete method, reports benchmarked experiments, provides code availability, and includes ablations and reproducibility disclosures . The main risk is not fabrication but overstatement of comparative conclusions relative to heterogeneous baseline evidence.

Recommendations

Overall, I regard this as a technically credible and potentially strong manuscript with a clear practical contribution. Its main revision need is not conceptual repair, but sharper evidential framing: the paper should align its strongest claims more carefully with the scope and granularity of the reported evidence.

XSci (AI review)

October 2, 2026

Referee Report

Manuscript: "Towards Practical Compression of 3D Gaussian Splatting" (COSA-GS) Recommendation: Major revision

Summary and Recommendation

This manuscript addresses the storage cost of 3D Gaussian Splatting scene representations and proposes COSA-GS, a codec built on the Scaffold-GS anchor parameterization whose defining choice is to abandon spatial context aggregation. Where HAC, HAC++, and ContextGS construct context by querying a learned hash grid at anchor locations or by conditioning finer anchors on already-decoded coarser ones, COSA-GS confines context construction to a causal chain inside each anchor. An MLP maps the anchor's own normalized reconstructed coordinate to a geometry context; that context conditions a four-channel anchor latent factorized autoregressively across its channels in Eq. (3); the two are fused in Eq. (5) into an anchor context that conditions the anchor feature, position scaling, offsets, and Gaussian scaling in Eq. (6). Coordinates are coded by octree occupancy coding with per-level empirical distributions. Training follows a rate–distortion objective with learnable offset masking and anchor pruning, and Section 3.7 with Appendix A.4 develops an integer inference pipeline, including a shared fixed-point scale, a lookup-table GELU derived from the decomposition in Eq. (12), and precomputed integer CDF tables, so that entropy decoding is bit-exact across hardware. Evaluation spans Mip-NeRF360, DeepBlending, Tanks&Temples, and BungeeNeRF against five recent anchor-based codecs.

The work is well motivated and carefully engineered, and two of its elements deserve particular credit. The integer pipeline is specified at a level of detail this literature rarely attempts, down to tie-breaking conventions and the distinction between variables that feed back into entropy prediction and those that do not, and the authors are commendably precise in scoping the guarantee to entropy-decoded symbols and fixed-point causal states rather than to rendered output. The appendix, with per-scene tables for four training configurations and an explicit timing protocol, is generous and honest. The recommendation is nonetheless major revision, because the manuscript's claims currently outrun the evidence offered for them in three distinct ways. The central architectural thesis is supported by comparison rather than by control, so the reported gains cannot be attributed to the mechanism the paper proposes. The system that actually delivers the portability guarantee is not the system whose numbers carry the headline claims, and the gap between the two is larger than the text acknowledges. And several claims, including the unqualified assertion of state-of-the-art performance, are stated more broadly than the experiments support. None of these requires redesigning the method; all are addressable with measurements the authors are already equipped to make.

Major Concern Category 1: Attribution of the Reported Gains

1.1 The comparison rests on transcribed numbers rather than a matched pipeline

The thesis of the paper is that context construction without spatial aggregation suffices, and that the resulting codec matches or exceeds spatially aggregating codecs. Section 4.1 states that "the rate–distortion results of the compared methods are based on the per-scene metrics reported in the corresponding papers." This is common practice, but here it sits directly on the claim most in need of support, and it introduces several simultaneous differences that cannot be disentangled from the architectural difference of interest. COSA-GS initializes from a 15K-iteration Scaffold-GS model and adds 30K rate–distortion iterations, while Section 4.2 compares against HAC++ at 60K steps and Figure 2 labels it at 30K; beyond training budget, COSA-GS brings its own masking and pruning policy, its own learned per-group quantization steps, its own octree coordinate coder, and its own entropy backend. That at least one of these exerts real leverage is evident from the paper's own bit allocation, where Appendix A.2 reports anchor coordinates growing from 5.8% to 15.4% of the bitstream as the rate falls. What would settle the matter is a substitution experiment inside the authors' own codebase, holding initialization, schedule, masking, quantization, coordinate coding, and entropy backend fixed while varying only the context source between the proposed anchor-wise construction and a hash-grid or coarse-to-fine spatial alternative. If the two match, the claim is established in a way no cross-paper table can establish; if they do not, the contribution remains real but should be reframed as a favourable complexity–performance trade.

1.2 The ablations do not vary spatial aggregation, and one result undercuts the framing

Section 4.3 and Appendix A.6 ablate the geometry context, the anchor latent, the position-scaling dimensionality, and the channel counts. None of these varies spatial aggregation, which is the quantity the title, the abstract, and the method name are organized around. The informative experiment is the opposite of the ones performed: adding a spatial branch to the full model and measuring what it recovers. If it recovers nothing, the thesis is demonstrated directly; if it recovers something, the paper has quantified the cost of its simplification, which is equally publishable. Compounding this, one existing ablation works against the narrative. Section 4.3 reports that "the geometry-free variant remains close to the full model, further indicating that the learnable anchor latent can provide informative context even without coordinate conditioning," and Appendix A.6 concurs that retaining either source "recovers much of this loss." Yet the conceptual contribution rests on the claim in Section 1 that "the context for each anchor can still be derived from its own coordinate." If a variant with no coordinate conditioning performs nearly as well, the operative mechanism is the transmitted latent rather than derived context, and the narrative should be revised to match, or the geometry context's contribution quantified in bits and shown to be substantial.

1.3 The decoding speedup is attributed to the architecture but is not decomposed

Figure 2 reports 24.95 s for HAC++ and 25.49 s for PCGS against 0.1279 s for COSA-GS on the flowers scene, and the abstract presents this as a consequence of the architectural choice. The manuscript's own measurements make that attribution difficult to sustain. Section 4.2 and Table 1 report that the entropy coder dominates decoding at 0.064 s on average, anchor-coordinate decoding takes 0.012 s, and "the neural context model requires only 0.003–0.008 s." A component costing at most eight milliseconds cannot account for a twenty-five-second difference. Appendix A.3 identifies the likely driver: a CPU rANS backend with 16-bit probability precision, each stream split into four blocks across up to four worker threads, which is orthogonal to whether context is aggregated spatially. A second genuine but distinct factor is the number of serial decoding passes, since ContextGS decodes anchor groups hierarchically while COSA-GS decodes all anchors in parallel after four channel steps. Running the baselines' context models on the authors' entropy backend, and COSA-GS on a single-threaded unsplit one, would partition the speedup into entropy-backend, serial-pass, and context-network components and would let readers see precisely what the architecture buys.

1.4 The premise about inter-anchor dependence is asserted rather than measured

Section 1 argues that "3DGS optimization itself can reduce inter-anchor dependence when guided by an appropriate context model," so that complex spatial aggregation can be replaced by anchor-wise modeling. This is the most interesting idea in the paper, because it is a claim about the structure of learned 3D representations rather than about one codec, yet it appears once and is never revisited with a measurement. Several diagnostics would serve, all cheap and all internal to the existing codebase. The most direct is a post-hoc conditional entropy test: after training, fit an auxiliary spatial predictor on the already-decoded latents and features and report how much additional rate it can remove. A complementary test would compare residual inter-anchor redundancy between representations trained under anchor-wise and under spatial contexts at a matched rate point, which is what the stronger reading of the claim requires. A simpler statistic would be the correlation between coded symbols of spatially adjacent anchors, compared against a representation trained without a rate term. Without one of these, the contribution reduces from a structural insight to a performance report.

1.5 The anchor latent is load-bearing but neither analyzed nor positioned

The ablations indicate that the anchor latent carries most of the conditioning power, and Appendix A.2 shows it consuming between 3.4% and 8.5% of the bitstream, yet Section 3.4 devotes roughly a paragraph to it and no analysis follows. Three things are missing. First, a rate ledger: the latent is transmitted side information that must pay for itself, and a table showing bits spent on latents against bits saved on the attribute groups they condition would show whether it does and by how much. Second, a characterization of what it represents, since a per-scene per-anchor free variable could be learning a genuine summary of attribute statistics or could be functioning as a learned cluster index, and these have different implications for generality. Third, positioning. The construction in Eq. (3), where a compact transmitted variable is factorized autoregressively across channels with a separate head per channel, is the channel-autoregressive entropy model standard in learned image compression since 2020, and the construction in Eq. (5) is a hyperprior. Section 2.2 itself notes that ContextGS already uses "a low-dimensional per-anchor hyperprior" without distinguishing it from the proposed latent. One paragraph stating what is new would resolve the ambiguity, and the likely honest answer, that the novelty lies in removing spatial aggregation and in the integer realization rather than in the entropy model, would be perfectly acceptable if stated.

1.6 The baseline set spans one family, with neither a quality ceiling nor a control

All five compared methods descend from the same Scaffold-GS representation COSA-GS uses, so the comparison establishes a ranking within one lineage. Two reference points are missing that would cost almost nothing. The first is the uncompressed representation: no table reports the size and quality of the 15K Scaffold-GS model the method starts from, so the overall compression ratio is never stated and the quality ceiling is invisible. The second is a context-free control that takes the same optimized, masked, pruned representation and codes it with a fixed entropy model, which would isolate the value of the learned context from the value of the surrounding pipeline. Section 2.1 cites a much wider literature on pruning, vector quantization, and feature-plane coding, none of which appears in the comparison figures, and a short discussion of which of these compose with the anchor-wise structure and which are mutually exclusive would help readers place the contribution.

Major Concern Category 2: The Deployable System and Its Accounting

2.1 The integer variant carries a rate penalty that the text understates

Section 4.2 describes the quantization-aware variant as remaining "close to the floating-point 15+30K model over most bitrate points, with only small differences at some low-bitrate points on DeepBlending and BungeeNeRF," and Appendix A.5 repeats the characterization. Comparing Tables 4 and 5 directly gives a different picture, and the largest discrepancy falls on a dataset neither sentence mentions. On Tanks&Temples at λ = 0.0160 the floating-point model reaches 23.4090 dB at 0.9933 MiB while the integer variant reaches 23.4018 dB at 1.2088 MiB, a 21.7% size increase at marginally lower quality; at λ = 0.0080 on the same dataset the increase is 13.3%, again at slightly lower PSNR. On DeepBlending at λ = 0.0160 the variant is simultaneously 10.9% larger and 0.22 dB worse. On Mip-NeRF360 at λ = 0.0080 the increase is 12.7%, though here quality also rises, so the effect is a shift along the curve. BungeeNeRF, one of the two datasets the text names, is among the best behaved, with differences under one percent. Two consequences follow. The comparison cannot be made at fixed λ, since λ evidently does not index the same operating point under the two regimes, which is exactly the situation BD-rate exists to handle. More importantly, the headline rate–distortion claims rest on the floating-point model while the portability guarantee is available only in the integer one, so a practitioner cannot have both. The same asymmetry appears in runtime, where the integer variant is slower at both ends, and where Appendix A.7's summary range is explicitly scoped to "the three floating-point settings." The integer variant should be promoted to the primary system, with the floating-point model presented as an upper bound.

2.2 The cross-platform evidence is narrower than the cross-platform claim

Table 2 encodes on an NVIDIA 5880 Ada with an AMD EPYC 9654 and decodes on that configuration plus an NVIDIA 4090 with an AMD EPYC 7R32 and an NVIDIA V100 with an Intel Xeon Gold 6258R. All three are x86-64 hosts with NVIDIA GPUs running a single pinned stack per Table 23. The axes that vary are GPU microarchitecture and CPU vendor within one instruction set; the axes held fixed are instruction set, GPU vendor, compiler toolchain, math library, and library version, which are precisely where the cited prior work locates floating-point divergence. The deployment scenarios that motivate the paper, such as a mobile client, a browser target, or an Apple Silicon workstation, exercise the untested axes, and since the context model is integer by construction and the entropy coder runs on CPU there is good reason to expect the method would survive such a test. The experiment also covers only Mip-NeRF360, whereas BungeeNeRF, with bitstreams reaching 16.5 MiB, would be the more demanding case, and the authors appear to have those bitstreams already. Finally, the experiment lacks a negative control: the manuscript asserts that floating-point inference "can introduce numerical inconsistencies across platforms, causing entropy-decoding failures" but never measures whether the floating-point model actually fails on these machines. Reporting that failure rate alongside the integer results would establish the magnitude of the problem being solved.

2.3 Scene size excludes resources the decoder requires

Every size comparison depends on a definition of scene size given only in Appendix A.4, which states that "decoding also requires the project source code, the model configuration files, and the shared Gaussian and GELU tables" and that "these shared resources are not counted in the scene size." Excluding source code is uncontroversial; excluding the tables is less so, and their size is never reported. The GELU table is small, but the 128 integer CDF tables cannot be bounded from the information given, since the symbol alphabet each spans is unstated. This matters because Table 4 reports DeepBlending bitstreams of 0.6383 MiB and Tanks&Temples bitstreams of 0.9933 MiB at the highest λ, so a shared asset of a few hundred kilobytes would be a meaningful fraction of a single scene, and the amortization argument depends on how many scenes a client holds. The more consequential issue is commensurability, since baseline sizes are transcribed from papers that make their own accounting decisions, and Appendix A.2 shows that model parameters and metadata rise from 0.6% to 3.9% of the stream for COSA-GS itself. Reporting the shared-table size, stating the amortization assumption, and tabulating which components each compared method counts would make the comparison auditable.

2.4 The offset mask is coded but omitted from the rate objective

Section 3.5 introduces a binary offset mask, Appendix A.3 confirms it is categorically coded with transmitted CDFs, and Figure 1 lists it as a bitstream component. Section 3.6, however, defines the total training rate as the sum of the latent, feature, position-scaling, offset, and Gaussian-scaling terms, with no mask term. The optimizer therefore faces an artificially free mask and has no incentive to produce compressible activation patterns, while the measured scene size pays for them; this bias is systematic, and the mask's share is unreported, consistent with Appendix A.2's breakdown leaving roughly a fifth of the low-rate bitstream unassigned. A related gap concerns the anchor activity indicator in Eq. (7), which gates every anchor-level rate term. Straight-through gradients are specified for the mask but nothing is specified for this indicator, so as written the rate of an entire anchor switches discontinuously as its last offset crosses the threshold, with no statement of whether the discontinuity is smoothed, whether pruned anchors can be revived, or how pruning is scheduled. Finally, Eq. (6) conditions the offset distribution on the mask, but Section 3.5 describes only the anchor context and the embedded position scaling entering that distribution, leaving the conditioning either misleading or unexplained.

Major Concern Category 3: Scope of the Claims Relative to the Evidence

3.1 The state-of-the-art claim is metric-specific and contradicted by the paper's own text

The abstract claims state-of-the-art compression performance without qualification, while Section 4.2 states that "SpeedyGS achieves higher SSIM and lower LPIPS at several bitrate points, while COSA-GS provides a stronger PSNR–size trade-off." A claim that holds on one metric and fails on two others is a claim about PSNR. This matters in a domain evaluated by human viewers and in a regime where high-frequency detail is sacrificed: Table 4 shows that on Mip-NeRF360, moving from λ = 0.0006 to λ = 0.0080 costs 1.40 dB but raises LPIPS from 0.2340 to 0.3409, a 46% relative degradation. The remedies are to scope the claim in the abstract and contribution bullet, to replace the contested adjectives with per-dataset BD-rate computed separately against PSNR, SSIM, and LPIPS, and ideally to add perceptual evidence beyond the single qualitative view in Figure 2. It is also unfortunate that Figure 3 reports only PSNR and SSIM for Tanks&Temples and only PSNR for BungeeNeRF, relegating to the appendix precisely the metrics on which the competitive picture is least favourable.

3.2 Robustness, generalization, and the coordinate coder are unexamined

Every result derives from a single recipe, a 15K Scaffold-GS initialization followed by rate–distortion optimization, with only the second stage's length varied. Since the paper's thesis is that this optimization reshapes the representation, the budget available to do the reshaping is load-bearing rather than incidental, and the 15K figure is unmotivated. A short sensitivity study over initialization lengths, together with anchor counts before and after optimization at each rate point, would show how much of the gain comes from pruning rather than context modeling. Equally absent is any discussion of failure across twenty-nine scenes and several hundred reported numbers, even though the per-scene tables invite it: Table 7 shows garden losing 2.78 dB across the λ range while treehill loses 0.30 dB, close to a tenfold difference in rate sensitivity within one dataset. The octree coordinate coder is a third unexamined element. It is entirely non-learned, never ablated, and no alternative is considered, yet Appendix A.2 reports it growing from 5.8% to 15.4% of the bitstream while metadata grows from 0.6% to 3.9%, so at the low-rate points where comparisons are most favourable close to a fifth of the stream is spent on components the contribution does not touch.

3.3 The statistical base does not support the specificity of several claims

No measure of variability appears anywhere: no seeds, no repeated runs, no error bars. Against a pipeline that includes stochastic densification, a hard mask threshold, and anchor pruning, several claims sit at or below a plausible noise floor, including Appendix A.7's assertions that the 15+30K setting produces smaller bitstreams than 15+20K "at every tested rate weight λ" and that extending to 45K "increases PSNR at every listed λ," and Section 4.3's finding that 50 feature channels improve PSNR at the highest rate but degrade it at lower ones. Scene counts compound this, since Tanks&Temples and DeepBlending contain two scenes each per Appendix A.1 yet carry equal narrative weight with nine-scene Mip-NeRF360. Scene heterogeneity adds further noise, with Table 7 spanning 21.4197 dB on flowers to 33.2550 dB on bonsai at a single λ. One result also contradicts the asserted monotonicity: Appendix A.7 notes that on BungeeNeRF the 15+20K setting yields both larger bitstreams and higher quality than 15+30K at the same λ, confirmed by Tables 4 and 6. The underlying point is that λ does not index a fixed operating point across configurations, which matters because several comparisons, including the floating-point versus integer comparison, are made at matched λ rather than matched rate.

3.4 Notational inconsistency obstructs verification of the bit-exactness claim

For a paper whose second contribution is bit-exact decoding, the specification carries unusual weight, since a reader must be able to follow the arithmetic exactly. The treatment of rounding is the most consequential problem. Section 3.3 declares that the floor symbol "denotes rounding," and the same symbol then appears in Eqs. (4), (9), (11), and (13), while Appendix A.4 introduces an explicit operator for nearest rounding with half ties away from zero and notes that parameter export instead uses half ties to even. A reader cannot tell which bracket means which, and a single tie-breaking discrepancy between encoder and decoder would break the guarantee the paper exists to establish. Smaller inconsistencies accumulate around it: the text before Eq. (11) describes a divisor 2^r while the equation uses 2^τ, with r already bound to the position scaling in Section 3.1; Eq. (13) produces a hatted quantity while the following sentence defines a tilded one, where the tilde is elsewhere reserved for noise-relaxed training variables; Eq. (7) sums over an index that does not match its summand; and Appendix A.4 says Eq. (18) implements Eq. (13) "without floating-point arithmetic" although Eq. (13) is already in integer form with different subscripts. Adopting the appendix's explicit operators throughout the main text would resolve most of this.

3.5 The practicality account is incomplete

The title promises practicality and the paper delivers on portability and decoding latency, but leaves three other dimensions unmeasured. The first is the true cost of encoding: Appendix A.3 defines encoding as beginning from a trained in-memory model, so the reported 0.036–0.090 s excludes the 479 s initialization and the 3,206–3,321 s optimization that produce that model, roughly an hour per scene per operating point, with five λ values per dataset each requiring its own run. Juxtaposing a 0.09 s encoding time against a 25 s baseline decoding time in Figure 2 invites a reading the training numbers do not support, and a single clarifying sentence would cost nothing. The second is rendering. 3D Gaussian Splatting exists because it renders quickly, yet no frames-per-second figure, memory footprint, or surviving anchor or Gaussian count appears anywhere, even though masking and pruning make the representation structurally different across operating points and the comparison would likely favour the authors. The third is bitstream functionality: Section 2.2 notes that PCGS supports incremental bitstreams, and whether the anchor-wise design admits progressive decoding, quality layering, or spatial random access is a natural question for a practicality paper and belongs in the conclusion.

Minor Issues

1. No BD-rate or BD-PSNR figure appears anywhere in the manuscript, and every rate–distortion comparison, against baselines, between training budgets, between context variants, and between the floating-point and integer models, is presented as overlapping curves assessed with adjectives such as "close" and "favourable." These are standard metrics in the compression venues this work targets, and adopting them would make each of the paper's comparative claims independently checkable at negligible cost.

2. HAC is introduced in both Sections 2.1 and 2.2 as the origin of the hash-grid spatial context the paper argues against, but is absent from the comparison list in Section 4.1. Relatedly, baseline training budgets are labelled inconsistently, with Figure 2 showing HAC++ at 30K while Section 4.2 references HAC++ at 60K optimization steps. Both may be correct in their own contexts, but the mapping should be made explicit.

3. The λ grids differ across datasets, running from 0.0006 to 0.0080 on Mip-NeRF360, 0.0010 to 0.0160 on DeepBlending and Tanks&Temples, and 0.0002 to 0.0010 on BungeeNeRF, with no stated rationale. The normalizing constant of 8·10⁶ in Eq. (8) is likewise unexplained. Since λ is the principal experimental control variable, a sentence on both would help readers map λ onto the rate axis.

4. Several quantities that define the representation are introduced symbolically but never given numerically, including the number of Gaussians per anchor K, the anchor-feature dimension C_f, the masking threshold ε_m, and the coordinate quantization step Δ_x. The latent dimension is only inferable from Section 4.3's reference to a default of four channels. Deferring these to the repository is reasonable for secondary hyperparameters but not for these.

5. Two tables do not render as described. Table 1's training-time columns pair 3321 with .3271 and 479 with .3238, while the text states 479 s for the initialization and 3,206–3,321 s for the optimization. Table 2's caption promises a final column reporting consistent bitstreams out of 45, but the final data column contains the average decoding time and the counts appear only in prose.

6. Figure 2 places per-view PSNR values of 21.20, 21.22, and 21.37 dB adjacent to full-scene sizes and coding times. The caption notes that PSNR is measured on the displayed target view, but marking the per-view quantities distinctly within the figure would prevent misreading them as scene averages.

7. The relationship between the optimized rate and the realized rate is never examined. Section 3.4 replaces rounding with additive uniform noise during training while Section 3.5 uses straight-through gradients for the mask, and the stream is produced by a 16-bit-precision rANS coder over quantized CDF tables. Reporting the gap between estimated and realized rate at a few operating points would characterize how much of the entropy model's advantage survives into the bitstream.

8. Three aspects of the integer pipeline are asserted rather than measured. Eq. (16) clips the CDF index to 128 log-spaced tables spanning standard deviations from 0.1 to 256, with no report of clipping frequency or grid-quantization cost. The GELU correction is tabulated over [0, 6] and "set to zero outside the tabulated range," with no error bound. And Eq. (15) is defined only for coordinate ranges exceeding one, with no stated fallback for degenerate axes.

9. Appendix A.4 states that quantization observers are frozen at iteration 25,000 of the default 30K schedule, with no rationale and no sensitivity analysis. This choice interacts directly with the rate penalty discussed above, and a brief sweep would indicate whether that penalty is intrinsic to integer inference or an artifact of the calibration schedule.

10. Decoder cold-start costs are excluded throughout: Appendix A.3 excludes constructing the integer-network modules, checkpoint loading, and scene-file input and output. These exclusions are disclosed, but they are precisely the costs a streaming client pays on first use, and reporting them separately would complete the practical picture without weakening the steady-state result.

11. Table 2 labels its rows by GPU, yet Section 4.2 identifies the entropy coder as the dominant decoding component and Appendix A.3 states that it is a CPU rANS backend using up to four worker threads. The timing spread across platforms may therefore reflect CPU single-thread performance rather than the GPU configurations named in the row labels. Labelling by CPU, or reporting single-threaded times, would make the comparison interpretable.

12. Two design choices in the latent path are unexamined. The autoregressive channel ordering in Eq. (3) is arbitrary and untested despite there being only four channels, and the per-channel head cost is unreported. The claim in Section 3.4 that channels decode sequentially while anchors decode in parallel is never timed, although measuring decoding latency against channel count would substantiate the design rationale directly.

13. The anchor latent's training-side costs are not reported. A per-anchor learnable vector adds optimizer state proportional to anchor count, which matters for the BungeeNeRF scenes producing 16.5 MiB bitstreams, and peak training memory relative to Scaffold-GS and HAC++ would be useful. Separately, the learned quantization step and the latent scale are mutually compensating and jointly learnable, so their identifiability deserves a sentence and the learned values are worth reporting.

14. The masking mechanism is named three different ways, as "adaptive Gaussian pruning" in the abstract, "adaptive masking" in the contribution bullet, and as an offset mask with anchor pruning in Sections 3.5 and 3.6. Relatedly, the simplicity claim central to the paper's positioning is never quantified: no parameter count, multiply-accumulate count, or comparison against the context models of HAC++ or ContextGS is given.

15. Appendix A.1 holds out every eighth view for Mip-NeRF360, Tanks&Temples, and DeepBlending but uses the first 31 views for BungeeNeRF. Given BungeeNeRF's multi-scale structure the first views are not an arbitrary sample, so if this follows prior work it should say so and otherwise warrants a justification.

16. The bit-allocation breakdown in Appendix A.2 accounts for roughly four fifths of the low-rate bitstream, reporting features and offsets jointly and leaving the offset mask, position scaling, and Gaussian scaling unassigned. Appendix A.3 also notes that coordinate occupancy and offset-mask CDFs are transmitted, a cost that scales with octree depth and is folded into metadata without being broken out.

Missing and Inadequately Integrated Literature

Cited but Inadequately Integrated

Several works the manuscript cites would do substantially more work if engaged with rather than listed. Ballé et al. (2019) and Koyuncu et al. (2022) are cited as the origins of integer networks and of device-interoperability study, but neither their documented rate penalties nor their evaluation methodology is adopted; the latter in particular frames consistency as something to be established by measuring failure rates on floating-point baselines, which is exactly the negative control missing from Section 4.2. Ballé et al. (2018) and Minnen et al. (2018) are cited as general background, yet they are the structural antecedents of the anchor latent and of the serial-decoding problem the paper sets out to avoid, so framing the latent explicitly as a per-anchor hyperprior and the channel factorization as a relocation of the autoregression from the spatial to the channel axis would both credit prior work and sharpen the novelty claim. Wang et al. (2024b) is acknowledged in Section 2.2 to use a low-dimensional per-anchor hyperprior without that acknowledgement being followed through.

A second group concerns mechanisms adopted without attribution at the point of use. Lee et al. (2024) introduced learnable per-Gaussian masking with a sigmoid, a threshold, and straight-through gradients, which is structurally the mechanism of Section 3.5, yet it appears only in a list in Section 2.1. Wang et al. (2024a) established the joint rate–distortion optimization of 3DGS representations on which Eq. (8) builds, and since the paper's thesis concerns what that optimization does to the representation, it deserves direct engagement. Hanson et al. (2025) and Zhang et al. (2025) are the natural comparison points for decomposing how much of the reported gain comes from pruning, and should be discussed where pruning is introduced rather than in a bibliographic list.

A third group concerns competitors treated too briefly. Zhang et al. (2026) is the one baseline the manuscript concedes outperforms it on two of three metrics, yet receives no discussion beyond that concessive sentence. Chen et al. (2024) is argued against conceptually but omitted from the comparison. Chen et al. (2026) is compared quantitatively while its distinguishing capability, incremental bitstreams, is set aside. Xu et al. (2026) and Lee et al. (2025) operate on the same anchor attributes and the same practical concerns by different routes, the latter notably achieving cross-platform determinism by delegating to standard video codecs, which is a direct alternative resolution of the manuscript's motivating problem. Finally, Kerbl et al. (2023) is cited for the representation and its storage cost but not for the real-time rendering property that motivates the entire line of work, which is consistent with the absence of any rendering measurement.

Truly Missing Papers

Three omissions bear on how the entropy model should be positioned. Minnen and Singh (2020) introduced channel-wise autoregressive entropy modeling specifically to retain backward adaptation while avoiding serial spatial processing, which is the same trade Eq. (3) makes, and is the direct antecedent of the design. He et al. (2021) resolves the same tension differently, obtaining parallel decoding while retaining spatial context, and therefore represents a counterexample to the framing that spatial aggregation and speed are fundamentally opposed. He et al. (2022) studies exactly the channel-versus-spatial-context-versus-speed trade and concludes that the two context types combine well, which is in genuine tension with the present framing and would sharpen the argument if addressed.

Four further omissions concern techniques used without citation. Jacob et al. (2018) supplies the quantization scheme of Section 3.7 essentially verbatim, including per-tensor affine activations, per-channel symmetric weights, int8 operands with int32 accumulation, fixed-point rescaling by multiplier and shift, and quantization-aware training with straight-through gradients; citing it would let the authors focus their contribution claim on the entropy-specific parts. Kim et al. (2021) is the standard reference for integer-only GELU evaluation, the exact operation addressed by Eq. (12), and comparing the proposed lookup table against its polynomial approximation on accuracy, memory, and latency would justify the design choice. Bengio et al. (2013) is the standard reference for the straight-through estimator used in Sections 3.5 and 3.7, and attributing it would also surface the estimator's bias, which is relevant to the mask-threshold dynamics. Duda (2013) underlies the rANS backend of Appendix A.3, and citing it would support rather than complicate the paper's own speed narrative. Agustsson and Theis (2020) is likewise absent although it addresses the noise-relaxation mismatch of Section 3.4 directly, showing that the resulting degradation is worst in low-complexity models at low bitrates, which describes this system precisely.

Finally, three omissions concern evaluation. Wang et al. (2004) and Zhang et al. (2018) introduced SSIM and LPIPS, both used in the training objective or the results throughout, and neither is cited; the LPIPS omission additionally leaves the backbone unspecified, which affects comparability with transcribed baseline numbers. Bjøntegaard (2001) defines the metric whose absence is noted among the minor issues above. Morgenstern et al. (2024) exploits spatial redundancy by a route orthogonal to both context aggregation and the anchor-wise approach, and is a natural non-anchor reference point for the broader comparison requested above.

Agustsson, E., and L. Theis. 2020. Universally quantized neural compression. NeurIPS 33:12367-12376.
Bengio, Y., N. Leonard, and A. Courville. 2013. Estimating or propagating gradients through
    stochastic neurons for conditional computation. arXiv:1308.3432.
Bjontegaard, G. 2001. Calculation of average PSNR differences between RD-curves. Document VCEG-M33,
    ITU-T SG16 Q.6, 13th VCEG Meeting, Austin, TX.
Duda, J. 2013. Asymmetric numeral systems: Entropy coding combining speed of Huffman coding with
    compression rate of arithmetic coding. arXiv:1311.2540.
He, D., Y. Zheng, B. Sun, Y. Wang, and H. Qin. 2021. Checkerboard context model for efficient
    learned image compression. CVPR, pp. 14771-14780.
He, D., Z. Yang, W. Peng, R. Ma, H. Qin, and Y. Wang. 2022. ELIC: Efficient learned image
    compression with unevenly grouped space-channel contextual adaptive coding. CVPR,
    pp. 5718-5727.
Jacob, B., S. Kligys, B. Chen, M. Zhu, M. Tang, A. Howard, H. Adam, and D. Kalenichenko. 2018.
    Quantization and training of neural networks for efficient integer-arithmetic-only
    inference. CVPR, pp. 2704-2713.
Kim, S., A. Gholami, Z. Yao, M. W. Mahoney, and K. Keutzer. 2021. I-BERT: Integer-only BERT
    quantization. ICML, pp. 5506-5518.
Minnen, D., and S. Singh. 2020. Channel-wise autoregressive entropy models for learned image
    compression. ICIP, pp. 3339-3343.
Morgenstern, W., F. Barthel, A. Hilsmann, and P. Eisert. 2024. Compact 3D scene representation via
    self-organizing Gaussian grids. ECCV, pp. 18-34.
Wang, Z., A. C. Bovik, H. R. Sheikh, and E. P. Simoncelli. 2004. Image quality assessment: From
    error visibility to structural similarity. IEEE Transactions on Image Processing 13(4):600-612.
Zhang, R., P. Isola, A. A. Efros, E. Shechtman, and O. Wang. 2018. The unreasonable effectiveness of
    deep features as a perceptual metric. CVPR, pp. 586-595.

Conclusion and Path Forward

The problem this manuscript takes on is well chosen and the system built to address it is carefully made. The integer inference pipeline is the strongest element: it is specified in enough detail to be reimplemented, it addresses a deployment hazard that this subfield has largely ignored, and the verification of all forty-five Mip-NeRF360 bitstreams across three machines is a concrete result rather than an assertion. The GELU decomposition in Eq. (12) is correct and economical, the separation between variables that feed back into entropy prediction and those that do not is reasoned rather than assumed, and the per-scene appendices and explicit timing protocol set a documentation standard worth emulating. The operating range achieved on the four benchmarks is genuinely competitive, and the decoding latencies, whatever their ultimate attribution, are a real practical advance.

What stands between the manuscript and publication is the distance between its claims and the evidence currently offered. The architectural thesis needs a controlled context-source substitution rather than a cross-paper table, and the premise about inter-anchor dependence needs a measurement rather than a sentence. The speedup needs decomposing into entropy-backend, serial-pass, and context-network components, since the paper's own timings show the context network cannot explain it. The integer variant should become the primary system, with its rate penalty reported quantitatively rather than characterized by adjectives that do not match Tables 4 and 5. The performance claim should be scoped to the metric on which it holds, the rate objective should account for the mask it codes, the notation should be unified so that the determinism claim can be checked from the text, and the practicality account should include the optimization cost, the rendering behaviour, and the bitstream functionalities the design supports. None of this requires a new architecture or new infrastructure; it requires additional measurement and a more careful statement of what the measurements show. The authors are well positioned to make these revisions, and several of the missing experiments seem likely to favour them. With them, this would be a strong and useful contribution to practical 3DGS compression.