SkipGS: Efficient Backward-Skipping in 3DGS

Updated 4 July 2026

SkipGS is a training strategy in 3D Gaussian Splatting that adaptively skips backward passes during the post-densification phase based on per-view loss history.
It leverages a view-adaptive gating mechanism with an exponential moving average and a minimum backward budget to trace individual view convergence and reduce redundant updates.
Empirical results show up to a 23.1% overall training time reduction and a 42.0% drop in post-densification time, maintaining comparable reconstruction quality.

SkipGS is a post-densification backward-skipping method for 3D Gaussian Splatting (3DGS) training. It targets the late refinement stage that begins after densification stops, when the Gaussian set is fixed and many sampled views have near-plateaued losses. The method always performs the forward pass to measure each sampled view’s current loss and update per-view statistics, but selectively skips the backward pass when that view’s loss is consistent with its recent per-view baseline; a minimum backward budget is enforced to preserve optimization stability. In the reported evaluation, this design reduces end-to-end training time by 23.1% on Mip-NeRF 360 relative to vanilla 3DGS, driven by a 42.0% reduction in post-densification time, while maintaining comparable reconstruction quality (Li et al., 9 Mar 2026).

1. Problem setting and motivation

SkipGS is defined within the standard 3DGS training pipeline, which the source describes as having a two-phase structure: a densification phase, during which the Gaussian set grows rapidly, and a post-densification phase, during which densification has stopped and training becomes primarily refinement (Li et al., 9 Mar 2026).

The motivation is a runtime imbalance that emerges after densification ends. The reported profiling result is that “the backward pass dominates per-iteration cost (~62%) after densification stops.” The same analysis shows that per-Gaussian gradient norms decrease by approximately $2\times$ from early to late training and become nearly flat after $T_d$ , whereas Adam update norms remain comparatively stable, with only an approximately $1.2\times$ overall reduction, due to momentum inertia. The stated implication is that many late-stage backward passes yield weak gradients and confer limited optimization benefit, even though standard training still performs full backpropagation on every sampled view (Li et al., 9 Mar 2026).

The method therefore addresses a narrowly specified question: whether post-densification 3DGS training can be accelerated by executing backward propagation only when a sampled view remains sufficiently under-optimized. This makes SkipGS a training-schedule intervention rather than a change to the renderer, scene representation, or reconstruction objective.

2. View-adaptive backward gating

The core mechanism is a view-adaptive backward gate applied only in the post-densification phase. For each sampled training view $v$ at iteration $t$ , the method performs the forward pass, computes the forward loss $\mathcal{L}_v^{(t)}$ , compares that loss to a recent per-view baseline, and then decides whether to execute or skip backward (Li et al., 9 Mar 2026).

The gating rule is defined through a scale-invariant deviation score,

$s_v^{(t)} = \frac{\mathcal{L}_v^{(t)}}{\bar{\mathcal{L}}_v^{(t-1)}+\epsilon},$

with $\epsilon = 10^{-8}$ , and a binary decision

$g_t(v)=\mathbf{1}\!\left[s_v^{(t)} > 1\right].$

Under this rule, $g_t(v)=1$ means that backward is executed, and $T_d$ 0 means that backward is skipped. The interpretation stated in the source is direct: if $T_d$ 1, the current loss is worse than the recent EMA baseline and backward is likely useful; if $T_d$ 2, the view is doing better than its recent baseline and backward is usually redundant (Li et al., 9 Mar 2026).

A defining feature of the method is that the baseline is maintained separately for each training view. The paper motivates this by noting that different views converge at different rates because of varying visibility, occlusion patterns, and view-dependent appearance. As a result, SkipGS is not based on a single global loss statistic; it exploits per-view convergence heterogeneity.

3. Per-view statistics, budget control, and training schedule

SkipGS maintains a separate exponential moving average for each training view:

$T_d$ 3

with $T_d$ 4 in the reported experiments. The EMA is updated after each forward observation, unconditionally, regardless of whether backward is executed. This design is explicitly intended to make the per-view baseline track loss trends independently of gradient updates (Li et al., 9 Mar 2026).

To prevent over-aggressive skipping, the method enforces a minimum backward budget. If $T_d$ 5 denotes whether backward is executed at iteration $T_d$ 6, the cumulative backward ratio is

$T_d$ 7

The override rule is

$T_d$ 8

Thus, even when the deviation score favors skipping, backward can be forced if the overall execution rate has fallen below a calibrated floor (Li et al., 9 Mar 2026).

The minimum budget is not tuned per scene. Instead, it is auto-calibrated from warmup statistics. During warmup, the method still evaluates the gate and measures the fraction of iterations that would have triggered backward:

$T_d$ 9

The floor is then set by

$1.2\times$ 0

with $1.2\times$ 1 in all experiments (Li et al., 9 Mar 2026).

The reported training schedule is fixed across scenes. Densification runs until $1.2\times$ 2k iterations, total training lasts $1.2\times$ 3k iterations, and SkipGS is enabled only after densification stops. The warmup length is $1.2\times$ 4. The training loss remains the standard 3DGS objective,

$1.2\times$ 5

with $1.2\times$ 6. These choices reinforce the paper’s characterization of SkipGS as plug-and-play: it changes only the timing of backpropagation, not the loss or optimization framework (Li et al., 9 Mar 2026).

4. Empirical performance

The reported evaluation covers Mip-NeRF 360, Deep Blending, and Tanks and Temples. Training is performed for 30K iterations on a single NVIDIA RTX Ada 5000 (32 GB) GPU, with SkipGS active only in the post-densification stage. Reconstruction quality is measured by PSNR, SSIM, and LPIPS, and efficiency is reported through total end-to-end training time $1.2\times$ 7 and post-densification refinement time $1.2\times$ 8 (Li et al., 9 Mar 2026).

On Mip-NeRF 360, vanilla 3DGS and 3DGS with SkipGS have identical reported PSNR and SSIM averages, with only a minor LPIPS change, while training time decreases substantially. The same pattern is reported on Deep Blending and Tanks and Temples: substantial time reduction with small metric differences.

Dataset	Quality change	Training-time change
Mip-NeRF 360	PSNR $1.2\times$ 9, SSIM $v$ 0, LPIPS $v$ 1	$v$ 2, $v$ 3
Deep Blending	PSNR $v$ 4, SSIM $v$ 5, LPIPS $v$ 6	$v$ 7, $v$ 8
Tanks and Temples	PSNR $v$ 9, SSIM $t$ 0, LPIPS $t$ 1	$t$ 2, $t$ 3

The headline result on Mip-NeRF 360 is an end-to-end training-time reduction of 23.1% and a post-densification-time reduction of 42.0%. The paper further notes that the final number of Gaussians is unchanged, indicating that the speedup arises from backward gating rather than model compression or scene simplification (Li et al., 9 Mar 2026).

5. Compatibility, ablations, and optimization trade-offs

A central claim of SkipGS is that it is orthogonal to other 3DGS efficiency strategies. The method does not change the renderer, the Gaussian representation, the loss, or the optimizer formulation; it changes only when backward is executed. On that basis, the paper evaluates SkipGS in combination with several baselines, including FastGS, Taming 3DGS, GaussianSpa, LightGaussian, and Speedy-Splat (Li et al., 9 Mar 2026).

The reported combined results show reduced post-densification time across all named baselines. On Mip-NeRF 360, the examples given are $t$ 4 s for FastGS, $t$ 5 s for Taming 3DGS, $t$ 6 s for GaussianSpa, $t$ 7 s for LightGaussian, and $t$ 8 s for Speedy-Splat. The paper characterizes these as additive speedups with nearly unchanged quality (Li et al., 9 Mar 2026).

The ablation evidence also defines the method’s principal trade-off. With budget control enabled, the reported outcome is good speedup with nearly unchanged quality. Without budget control, the method becomes more aggressive and faster, but quality degrades significantly. The cited example is Taming 3DGS on Mip-NeRF 360: the baseline reports PSNR $t$ 9 and $\mathcal{L}_v^{(t)}$ 0; full SkipGS reports PSNR $\mathcal{L}_v^{(t)}$ 1 and $\mathcal{L}_v^{(t)}$ 2; SkipGS without the budget reports PSNR $\mathcal{L}_v^{(t)}$ 3 and $\mathcal{L}_v^{(t)}$ 4. The minimum backward budget is therefore presented as essential for preserving optimization stability (Li et al., 9 Mar 2026).

A common misconception is that SkipGS skips rendering or suppresses the forward pass. The method does neither. Forward computation is always retained so that the current loss can be observed and the per-view EMA updated. Only the backward pass is gated.

Within current arXiv usage, “SkipGS” refers specifically to the post-densification backward-skipping method for efficient 3DGS training introduced in 2026 (Li et al., 9 Mar 2026). It is distinct from several other “GS”-related lines of work that use the same initials for unrelated technical concepts.

In astrophysics, “Optimized gyrosynchrotron algorithms and fast codes” describes fast approximate gyrosynchrotron emission codes for solar and stellar radio modeling; there, “GS” denotes gyrosynchrotron emission rather than Gaussian Splatting (Kuznetsov et al., 2010). In graph-based clustering, “A Convergence Theorem for the Graph Shift-type Algorithms” uses “GS” for Graph Shift algorithms on the simplex $\mathcal{L}_v^{(t)}$ 5 with convergence analysis via Zangwill’s theorem (Fan et al., 2013). In progressive radiance-field rendering, “PRoGS: Progressive Rendering of Gaussian Splats” prioritizes splats for partial rendering and streaming, which is a rendering-time importance-ordering problem rather than a training-time backward-gating problem (Zoomers et al., 2024). In compression, “Structured Image-based Coding for Efficient Gaussian Splatting Compression” introduces GSICO, an image-based codec for post-training compression of GS scene parameters (Martin et al., 20 Jan 2026). In sparse-view completion, “GSCompleter: A Distillation-Free Plugin for Metric-Aware 3D Gaussian Splatting Completion in Seconds” is a completion plugin based on a Generate-then-Register workflow (Gao et al., 22 Apr 2026). In unsupervised learning, “Gram-Schmidt Methods for Unsupervised Feature Extraction and Selection” uses “GS” in the sense of Gram–Schmidt orthogonalization over function spaces (Yaghooti et al., 2023).

This terminological overlap matters because SkipGS is neither a compression method, nor a progressive viewer, nor a completion module, nor a Graph Shift procedure, nor a gyrosynchrotron solver. Its contribution is narrower and more specific: it exploits redundancy in post-densification 3DGS training by using per-view loss history to decide when full backpropagation is still warranted.