BlitzGS: Accelerated City-Scale 3D Gaussian Splatting

• BlitzGS is a distributed framework for city-scale 3D Gaussian Splatting that minimizes redundant Gaussian processing across system, model, and view levels.
• It employs non-spatial index parity sharding, scheduled importance scoring, and view-based culling to balance GPU workloads and trim redundant primitives.
• BlitzGS achieves a 5–10× reduction in training time over previous methods without compromising high-fidelity urban reconstruction quality.

BlitzGS is a distributed framework for city-scale 3D Gaussian Splatting (3DGS) that achieves an order-of-magnitude reduction in training time by minimizing redundant Gaussian primitive processing at three interdependent levels: system, model, and view. The method enables efficient optimization of hundreds of millions of Gaussians—required for high-fidelity urban reconstruction—by ensuring that computational and memory resources are expended only on primitives that substantively contribute to each rendering step. BlitzGS matches the rendering quality of prior state-of-the-art city-scale 3DGS approaches, yet reduces end-to-end training time from multiple hours to tens of minutes on standard multi-GPU configurations (Wang et al., 13 May 2026).

1. Three-Level Workload Reduction Strategy

BlitzGS systematically reduces the active Gaussian workload through mechanisms operating at distinct but interlocked levels:

1. System Level: Sharding is performed by index parity rather than by spatial location. This ensures each GPU is assigned a balanced, geometry-agnostic subset of primitives, effectively eliminating cross-block redundancy and the need for global result merging.
2. Model Level: Primitives are pruned using scheduled importance-scoring passes. Each Gaussian receives a contribution score $s_i$, a visibility ratio $\phi_i$, and a per-view cull mask. These metrics are leveraged to permanently remove low-contribution primitives and bias further densification toward those more likely to impact rendering.
3. View Level: For each camera frustum, active primitive sets are trimmed before rasterization using a distance-based Level-of-Detail (LOD) gate and an importance-based culling mask, thereby skipping Gaussians with negligible influence in the specific view.

This multi-tiered approach reframes city-scale 3DGS as a workload-control problem, directly addressing the computational bottlenecks endemic to large-scale scene optimization.

2. System-Level Design: Non-Spatial Sharding and Distributed Rendering

Traditional spatial partitioning schemes, such as tiled blocks or octrees, suffer from problematic cross-block visibility at view boundaries, resulting in load imbalances and expensive post-merge steps. BlitzGS replaces this paradigm with index-parity sharding, assigning to each of $M$ GPUs a shard

$G^{(m)} = \{ g_i \in G : i \bmod M = m \}$

for a global set of $N$ Gaussians. Each shard thus contains approximately $N/M$ primitives, regardless of scene geometry, ensuring load balance without geographic shuffling.

At each iteration and for every sampled view, GPUs execute the following steps in parallel:

1. Project local Gaussians $G^{(m)}$ to 2D ellipses and determine overlapping image tiles $T_i$.
2. Perform an all-to-all MPI-style exchange, sending each projected Gaussian to the GPUs responsible for its covered tiles.
3. Each GPU rasterizes only those ellipses assigned to it, assembling its partial result before global image gathering.

A cost-aware tile partitioning algorithm further distributes rasterization load, preventing straggler GPUs. The algorithm achieves bit-identical results to single-GPU processing while ensuring communication and computation scale linearly with the number of GPUs.

3. Model-Level Primitives Scoring and Pruning

After repeated densification, city-scale 3DGS models retain significantly more Gaussians than required for high-quality rendering; these excess primitives incur substantial per-iteration overhead. BlitzGS introduces a global importance-scoring pass wherein all Gaussians are rasterized across all $V$ training views for statistics collection (not full shading).

For each Gaussian $g_i$ and each view $\phi_i$0:

• The alpha-weighted contribution $\phi_i$1 and affected pixels $\phi_i$2 are accumulated.
• Contribution score: $\phi_i$3.
• Visibility ratio: $\phi_i$4, conveying how often $\phi_i$5 meaningfully contributes when visible.
• Per-view cull mask: $\phi_i$6 (bit-packed for efficiency).

Two scheduled passes are used:

1. Early pruning (pass 1): Stochastic sampling retains Gaussians with probability proportional to $\phi_i$7.
2. Late pruning (pass 2): Deterministic prefix cut retains the prefix set whose cumulative $\phi_i$8 sums to 99% of the total.

Adaptive density control between iterations 2,000 and 20,000 clones or prunes Gaussians every 500 steps, with gradient magnitudes weighted by $\phi_i$9 once available. Shard balancing via index parity is maintained after each pruning operation.

4. View-Level Culling: Distance-Based LOD and Importance Masks

Despite reductions at the system and model levels, each camera view requires only a subset of the remaining population for perceptually faithful rasterization. Two lightweight filters are applied before rasterization:

1. Distance-Based LOD Gate: After Structure-from-Motion preprocessing and multi-scale voxelization, each Gaussian is assigned an LOD level $M$0. For camera $M$1 at iteration $M$2, with center $M$3 and Gaussian mean $M$4, the maximum usable level is

$M$5

where $M$6 (octave), $M$7 reference distance.

Gaussians with $M$8 are excluded unless their proportion is below a 5% threshold, ensuring minimal redundant computation.

2. Importance-Based Cull Mask: $M$9 derived from the previous scoring pass identifies Gaussians outside the top-99% cumulative mass for the view. Only Gaussians meeting both $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$0 and $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$1 are submitted, reducing per-view primitive counts by 50–80% in typical city scans.

5. Training and Rendering Benchmark Results

BlitzGS was evaluated on five city-scale benchmarks: Building, Rubble (Mill-19, ≈2K images), Residence, Sci-Art (UrbanScene3D, ≈2–3K), and MatrixCity (5.6K). Experiments used 4 × NVIDIA A6000 GPUs with batch size $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$2.

Method	Building (PSNR/SSIM/LPIPS/Time)	Rubble	Residence	Sci-Art	MatrixCity
VastGaussian	21.80/0.728/0.225/5h48m	25.20/0.742/0.264/2h16m	21.01/0.699/0.261/5h05m	–	–
CityGaussian V1	21.55/0.778/0.246/8h07m	25.77/0.813/0.228/3h50m	22.00/0.813/0.211/8h33m	21.39/0.837/0.230/3h56m	27.46/0.865/0.204/12h17m
CityGaussian V2	22.23/0.759/0.217/7h01m	24.58/0.767/0.252/4h16m	21.71/0.780/0.225/7h45m	21.49/0.811/0.238/10h35m	27.23/0.857/0.169/8h48m
Momentum-GS	23.19/0.816/0.193/7h04m	25.91/0.829/0.197/5h03m	21.18/0.760/0.248/9h09m	20.75/0.794/0.266/6h27m	28.07/0.879/0.183/6h14m
HUG	22.35/0.792/0.228/5h16m	26.42/0.839/0.197/2h37m	22.33/0.813/0.207/6h31m	21.83/0.846/0.204/2h58m	28.02/0.883/0.142/10h04m
CityGS-X	22.14/0.816/0.186/4h30m	24.92/0.831/0.199/6h03m	21.49/0.828/0.177/4h45m	23.31/0.872/0.178/3h14m	27.02/0.852/0.240/9h18m
BlitzGS	23.02/0.798/0.234/36m35s	26.98/0.821/0.245/31m56s	22.50/0.829/0.210/35m08s	23.23/0.875/0.181/37m04s	27.02/0.856/0.224/1h16m

BlitzGS achieves a 5–10× speedup over competing city-scale 3DGS methods with no loss in PSNR/SSIM/LPIPS metrics. For example, on the “Building” dataset, BlitzGS produces $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$323 dB PSNR in 36 minutes compared with 4–7 hours for previous state-of-the-art (Wang et al., 13 May 2026). Multi-GPU scaling from 1 to 8 A800 GPUs on “Rubble” and “Residence” yields a further $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$43.5× reduction in runtime without measurable loss in reconstruction quality.

6. End-to-End Pipeline and Implementation

The BlitzGS workflow comprises clearly defined preprocessing, data partitioning, training, and communication steps:

• Preprocessing employs Structure-from-Motion on $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$5–$G^{(m)} = \{ g_i \in G : i \bmod M = m \}$6K aerial images to yield camera poses and a point cloud. The point cloud is voxelized at $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$7 scales to determine initial LOD levels. Gaussians are initialized with small isotropic covariance and SH color from nearby images.
• Shard Initialization involves global Gaussian concatenation and index-parity partitioning. Each GPU only maintains optimizer state for its assigned shard.
• Training Loop (typically $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$8 iterations):
  • Adaptive density control (iterations $G^{(m)} = \{ g_i \in G : i \bmod M = m \}$9–$N$0) prunes/clones Gaussians based on gradient magnitude, reweighted by $N$1 if available.
  • Importance-scoring passes are carried out at two scheduled points (early stochastic, late deterministic), followed by pruning and shard rebalancing.
  • In each mini-batch, GPUs project their local Gaussians, communicate via a single all-to-all exchange, apply LOD and importance culling, rasterize, composite, and update parameters by backpropagation.
• Data Structures and Communication use contiguous arrays for $N$2 and bit-packed $N$3 matrices for efficiency. Projections are partitioned by target GPU per-tile, exchanged in small buffers, and the tile ownership map is precomputed once per view.
• Optimizations include cost-aware tile partitioning, LOD gate fallback, fixed-schedule importance passes to avoid stride synchronizations, and sparse index lookups for Cull masks in the GPU rasterizer.

The method notably keeps per-GPU memory and compute demands nearly constant even as the overall dataset scales.

7. Significance and Future Outlook

BlitzGS operationalizes the principle of “touching only the Gaussians that matter” across system, model, and view levels, offering a generalizable blueprint for scaling distributed 3DGS. By decomposing the global active primitive set into minimally redundant, dynamically filtered subsets, the framework bridges the qualitative gap between computationally affordable city-scale modeling and real-time multi-GPU execution. Benchmark results underscore that aggressive primitive culling and rebalancing can yield substantial acceleration—5–10× or more—without quality regression, supporting city-scale reconstruction use cases previously untenable under multi-hour training time constraints (Wang et al., 13 May 2026).

A plausible implication is the extension of similar workload-control paradigms to other high-dimensional scene representations or to interactive large-scale editing scenarios, contingent on further advances in distributed communication and dynamic primitive management.