Hierarchical Tiled Gaussian Splatting (HiGS)

• Hierarchically Tiled Gaussian Splatting (HiGS) is a multi-scale 3D representation that partitions scenes into coarse macro-tiles for sorting and fine render tiles for detailed rasterization.
• It employs spatial blocks, anchors, and octree level-of-detail techniques to enable localized training, efficient memory use, and dynamic scene processing.
• The architecture preserves exact front-to-back alpha compositing while significantly reducing computation, achieving real-time rendering performance and scalability.

Searching arXiv for the named method and closely related hierarchical/tiled Gaussian splatting work. Hierarchically Tiled Gaussian Splatting (HiGS) denotes a class of 3D Gaussian Splatting architectures that impose hierarchy over tiles, blocks, anchors, or macro-tiles in order to decouple representation, training, culling, and rasterization across scales. In the most specific sense, the name refers to “HiGS: A Hierarchical Rendering Architecture for Real-Time 3D Gaussian Splatting” (Pająk et al., 29 May 2026), which introduces a two-level rendering hierarchy in which partitioning and depth sorting operate on coarse macro-tiles while rasterization proceeds on fine render tiles, preserving exact front-to-back alpha compositing. More broadly, the term also describes a recurring systems pattern across recent Gaussian splatting research: spatial partitioning into blocks or anchors, hierarchical level-of-detail (LOD), coarse-to-fine activation, localized refinement, and redundancy filtering for scalability in large, dynamic, or high-resolution scenes (Kerbl et al., 2024, Su et al., 23 Apr 2025, Yang et al., 29 Aug 2025).

1. Definition and scope

HiGS extends standard 3D Gaussian Splatting (3DGS) from a flat set of Gaussians to a structured hierarchy in which spatial partitioning and multi-scale organization are explicit. In canonical 3DGS, the scene is represented by anisotropic 3D Gaussian primitives with mean, covariance, opacity, and appearance parameters, rendered through tile-based rasterization and front-to-back alpha compositing. This design is efficient for moderate scene sizes, but it couples binning, sorting, and rasterization to a single tile scale, and it lacks built-in mechanisms for LOD, streaming, or blockwise training (Pająk et al., 29 May 2026, Kerbl et al., 2024).

In the rendering-centric formulation of HiGS, the central innovation is to give partitioning and rasterization different granularities. “HiGS: A Hierarchical Rendering Architecture for Real-Time 3D Gaussian Splatting” partitions the screen into coarse macro-tiles for binning and segmented depth sort, while retaining fine render tiles for splatting. Rasterization work is then issued per $(\text{macro-tile}, \text{batch})$ rather than per render tile, so dense regions generate proportionally more parallel work instead of serializing behind a single heavy tile (Pająk et al., 29 May 2026).

In representation- and training-centric formulations, HiGS appears as blockwise reconstruction, octree or anchor hierarchies, or hierarchical Gaussian pyramids. “A Hierarchical 3D Gaussian Representation for Real-Time Rendering of Very Large Datasets” constructs a hierarchy of full 3D Gaussians over chunk-trained leaves and uses screen-space granularity to select an LOD cut through that hierarchy (Kerbl et al., 2024). “HUG” organizes large aerial scenes into blocks and, בתוך each block, an octree LOD of neural anchors (Su et al., 23 Apr 2025). “Scale-GS” organizes Gaussians hierarchically by scale within an anchor-based structure and selectively activates finer levels where coarse levels remain insufficient (Yang et al., 29 Aug 2025).

This suggests that HiGS is best understood not as a single implementation detail, but as a design family in which hierarchy serves at least one of four purposes: reducing partitioning and sorting cost, enabling LOD rendering, localizing optimization to tiles or blocks, and controlling memory growth through pruning or shared parameterization.

2. Historical context and relation to standard 3DGS

Standard 3DGS represents a scene with Gaussians

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$

projects them to screen-space ellipses, and composites color front-to-back: $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$ or equivalently in the simplified 3DGS form

$$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$

These formulations recur across later hierarchical methods (Su et al., 23 Apr 2025, Pająk et al., 29 May 2026).

The limitations that motivate HiGS recur across several settings. For real-time rendering, the single-scale tile pipeline of 3DGS forces a compromise: larger tiles reduce binning and sort overhead, but smaller tiles reduce rasterization cost and mitigate “monster” tiles whose Gaussian count dominates frame time (Pająk et al., 29 May 2026). For very large static scenes, joint optimization of a monolithic model is prohibitive, and distant content is rendered at full detail despite tiny screen-space extent (Kerbl et al., 2024). For large urban or aerial reconstructions, flat 3DGS suffers from excessive memory consumption, slow training, prolonged partitioning, and quality degradation with increased data volume (Su et al., 23 Apr 2025). For high-resolution reconstruction, optimizing all Gaussians and all images jointly can exceed 24GB VRAM at approximately 5K resolution (Li et al., 17 Jun 2025). For streaming or dynamic scenes, dense Gaussians per frame, global deformation, or large-scale spawning create substantial data volume and per-frame optimization cost (Yang et al., 29 Aug 2025).

Hierarchical tiling addresses these problems by introducing a second structural axis absent from vanilla 3DGS: either a spatial hierarchy, a scale hierarchy, or both. In this sense, HiGS is to 3DGS what mipmapping, octrees, or blockwise decomposition are to traditional graphics or geometric processing, except that its primitives remain Gaussians rather than voxels or meshes. This suggests that the essential departure is not the Gaussian itself, but the decision to make locality and scale explicit.

3. Core architectural patterns

Three architectural motifs recur across HiGS-style systems: coarse-to-fine spatial partitioning, hierarchical primitive organization, and selective traversal or activation.

3.1 Coarse partitioning and fine rasterization

In the explicit HiGS renderer, the screen is divided into render tiles, typically $8\times 8$ pixels, and macro-tiles such as $8\times 4$ render tiles, i.e. $64 \times 32$ pixels. Partitioning and depth sort are performed at macro-tile granularity, while rasterization remains at render-tile granularity (Pająk et al., 29 May 2026). This reduces pair counts dramatically: at 1080p on Mip-NeRF360 scenes, the reported mean drops from approximately 10.1M render-tile pairs for gsplat with opacity-aware AABBs to approximately 1.51M macro-tile pairs in HiGS; at 4K, from 29.3M to 2.21M (Pająk et al., 29 May 2026).

The macro-tile lists are then split into fixed-size Gaussian batches. Each $(\text{macro-tile}, \text{batch})$ pair becomes an independent processing unit, so a dense region spawns multiple blocks rather than stalling a single render tile. This architecture eliminates the classic tail effect of one-block-per-tile rasterizers and is the defining systems contribution of HiGS (Pająk et al., 29 May 2026).

3.2 Spatial blocks, anchors, and octrees

Outside the rasterization problem, hierarchical tiling often begins with block or anchor partitioning. HUG uniformly divides the global bounding box into spatial blocks, each trained independently using only images that substantially see that block, and then equips each block with an octree of neural anchors, each anchor generating 10 Gaussians via a small MLP (Su et al., 23 Apr 2025). HRGS similarly contracts a scene into a bounded cube, partitions it into regular blocks, assigns Gaussians and training views to each block, refines each block at high resolution, and concatenates the results (Li et al., 17 Jun 2025). Scale-GS uniformly voxelizes the scene into anchors; each anchor stores position, scale factor, local features, and offsets that generate Gaussian centers relative to the anchor, while finer-scale Gaussians are activated selectively from coarser ones (Yang et al., 29 Aug 2025).

These methods all treat tiles as local carriers of Gaussian subsets and view subsets. The exact data structure differs—block grids, anchors, octrees—but the invariant is that optimization and rendering do not need to see the whole scene at once.

3.3 Multi-scale Gaussian hierarchy

Another recurring pattern is scale stratification of primitives themselves. In Scale-GS, Gaussians are partitioned across scale intervals so that coarse levels contain large Gaussians for low-frequency structure and fine levels contain smaller Gaussians for detail. Binary partitioning of scale intervals assigns each Gaussian to one level, producing a hierarchy ordered from coarsest to finest (Yang et al., 29 Aug 2025). In the large-scene HiGS system of INRIA, each interior node of the hierarchy is itself a merged 3D Gaussian approximating descendants, enabling direct rendering of intermediate levels (Kerbl et al., 2024). In Pyramid-GS, the scene is organized as a multi-resolution voxel/Laplacian pyramid in which each level represents a distinct spatial scale and finer levels hold residual detail (Wang et al., 7 Aug 2025).

This suggests a useful distinction between hierarchical tiling in space and hierarchical tiling in scale. Many practical systems combine both.

4. Rendering architecture and exact compositing

The 2026 HiGS renderer is the clearest instantiation of the term as a rendering architecture (Pająk et al., 29 May 2026). Its pipeline comprises projection and shading, macro-tile binning, segmented depth sort, macro-tile rasterization, and post-batch compositing.

Projection computes 2D Gaussian position, projected covariance, and view-dependent color. Rather than storing the full inverse $2\times2$ covariance directly, HiGS uses a Cholesky factor

$$\Sigma^{-1} = L L^\top,\quad L = \begin{bmatrix} l_0 & 0 \ l_1 & l_2 \end{bmatrix},$$

so that the Mahalanobis distance becomes

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$0

a sum of squares that is numerically stable in fp16 (Pająk et al., 29 May 2026). The paper reports a full fp16 data path while preserving image quality essentially indistinguishable from fp32 baselines against ground truth (Pająk et al., 29 May 2026).

Binning proceeds in two passes. For each batch of Gaussians, a shared-memory histogram counts overlaps with macro-tiles, then a prefix sum yields segment offsets, and a second pass writes $$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$1 pairs directly into per-macro-tile segments (Pająk et al., 29 May 2026). Because tile index is implicit in the segment, the sort key is only 32-bit depth rather than a 64-bit composite key. The segmented sort is correspondingly cheap: at 4K, the custom segmented sort is reported as under 0.08 ms across tested scenes, versus 2.5–4.2 ms for a global 64-bit CUB sort on render-tile pairs (Pająk et al., 29 May 2026).

Within each macro-tile batch, rasterization is reorganized around active fine tiles. Worker groups load Gaussian mini-batches, compute per-Gaussian tile masks, transpose those masks into tile-wise form, compact active tiles into a queue, and let warps dynamically claim tiles from that queue (Pająk et al., 29 May 2026). The crucial observation is that no global memory per-tile list is needed inside the macro-tile; visibility is computed inline as batches are loaded.

Partial contributions from different Gaussian batches are then post-composited per tile: $$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$2 Because batches are contiguous in depth order within a macro-tile, this exactly reproduces front-to-back compositing of the full list (Pająk et al., 29 May 2026). The paper explicitly frames this as exact compositing, distinguishing HiGS from approximate sort-free or stochastic schemes.

A broader rendering-oriented extension appears in AAA-Gaussians, which promotes tile-based culling to 3D. There, a screen tile is represented as a 3D frustum defined by four screen-space planes, and a Gaussian is culled if the minimum Mahalanobis distance within that tile frustum exceeds a threshold. The method also uses view-space angular bounds and 3D evaluation along rays, and it integrates these ideas with hierarchical rasterization from StopThePop (Steiner et al., 17 Apr 2025). This suggests that HiGS-style tile hierarchies need not be purely 2D screen partitions; they can be made fully 3D-aware while retaining tiled processing.

5. Training, refinement, and pruning

Hierarchical tiling in Gaussian splatting is as much a training strategy as a rendering strategy. Several papers converge on a coarse-first, localized-refinement pattern.

5.1 Divide-and-conquer on static large scenes

“A Hierarchical 3D Gaussian Representation for Real-Time Rendering of Very Large Datasets” trains very large scenes in independent chunks, each approximately $$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$3 m for walking captures or $$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$4 m for vehicle captures, after a coarse global initialization and skybox optimization (Kerbl et al., 2024). Chunk training modifies 3DGS densification to use the maximum, rather than mean, screen-space gradient over an accumulation window, making densification more responsive under sparse coverage (Kerbl et al., 2024). After chunk optimization, a hierarchy is built by recursively splitting the chunk BVH along the longest axis and merging children into parent Gaussians using weighted Gaussian-mixture formulas: $$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$5

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$6

The merging weights are derived from opacity and projected surface area, with unnormalized form

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$7

approximated in practice via projected ellipsoid surface area (Kerbl et al., 2024). Interior nodes thus become renderable Gaussians rather than mere bounding volumes.

5.2 Block-level refinement under a global prior

HRGS uses a two-stage procedure: a global coarse Gaussian representation from low-resolution data, then blockwise refinement with high-resolution data (Li et al., 17 Jun 2025). Gaussian partitioning is done after contracting the scene into a bounded cube,

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$8

Views are assigned to blocks both by rendering-based SSIM difference and by block-local camera position (Li et al., 17 Jun 2025). This is not merely a storage partition: the global prior is used to initialize block Gaussians so adjacent blocks remain coherent.

HRGS also introduces Importance-Driven Gaussian Pruning (IDGP), which scores each Gaussian by

$$G(\mathbf{x}) = \exp\left(-\tfrac{1}{2}(\mathbf{x}-\boldsymbol{\mu})^\top \boldsymbol{\Sigma}^{-1}(\mathbf{x}-\boldsymbol{\mu})\right),$$9

where $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$0 is a transmittance-weighted hit count over rays, $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$1, and $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$2 (Li et al., 17 Jun 2025). The lowest 20% are pruned at specific iterations. On Mip-NeRF360, HRGS reports 313.72 MB model size and 19 GB GPU memory with IDGP versus 621.04 MB and 27 GB without it, with PSNR 27.91 versus 28.02 and SSIM 0.863 versus 0.821 (Li et al., 17 Jun 2025). The interpretation that pruning improves structural fidelity more than distortion metrics is directly supported by those numbers.

5.3 Streaming and dynamic scenes

Scale-GS formulates hierarchical tiling for streaming content. The per-frame pipeline initializes from the previous frame’s Gaussians, uses bidirectional adaptive masking to find dynamic anchors and informative views, then iterates over scale levels, deforming Gaussians and spawning new ones only where gradients remain above a threshold (Yang et al., 29 Aug 2025). Fine levels are activated selectively, and an octree within each anchor localizes spawning to high-gradient subspaces, recursively down to a minimum spatial resolution of $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$3 of the original domain (Yang et al., 29 Aug 2025). The total loss includes multi-scale photometric terms plus a sparsity penalty on learnable per-Gaussian masks: $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$4 This provides a concrete example of hierarchical tiles that are temporal as well as spatial.

6. Variants, extensions, and related formulations

HiGS has converged independently in several subdomains, and those variants clarify the design space.

HUG is a city-scale, blockwise, visibility-aware formulation. It uses regular tiling of the COLMAP bounding box, SVM-derived visibility masks, per-block masked loss, and an octree LOD of neural anchors with view-dependent level selection

$$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$5

Only anchors with level $$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$6 are rendered in a given view (Su et al., 23 Apr 2025). The method reports state-of-the-art results on MatrixCity and competitive or superior quality on real aerial scenes (Su et al., 23 Apr 2025). This is a blockwise training and LOD system rather than a rasterizer redesign.

Pyramid-GS is a compressed hierarchical pyramid over voxel levels. It introduces scene perception compensation using a depth compensation factor

$$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$7

a compensated distance

$$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$8

and a continuous level index

$$\mathbf{C}(\mathbf{x}') = \sum_i T_i\,\alpha_i\,G'_i(\mathbf{x}')\,\mathbf{c}_i,\quad T_i = \prod_{j=1}^{i-1}\bigl(1-\alpha_j\,G'_j(\mathbf{x}')\bigr)$$9

to bias important or high-depth-variation regions toward finer levels (Wang et al., 7 Aug 2025). Combined with GGD-based compression, it reports 9.5 MB on Waymo and 44 MB on MatrixCity while maintaining strong quality and high FPS (Wang et al., 7 Aug 2025). This is not tiled in the same sense as HiGS (Pająk et al., 29 May 2026), but it is clearly hierarchical Gaussian splatting.

Gaussian-Forest organizes Gaussians into trees of shared latent features. Each hybrid Gaussian stores explicit per-leaf parameters and shares implicit attributes via root and internal features decoded by small MLPs: $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$0 Its claimed complexity after pruning is approximately $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$1 versus $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$2 for standard 3DGS, matching empirical compression of $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$3 (Zhang et al., 2024). This is a hierarchy for parameter sharing and compression rather than tiles per se, but it aligns with the broader HiGS intuition that groups of neighboring Gaussians should share structure.

HiSplat applies hierarchy to generalizable sparse-view reconstruction. It predicts three stages of Gaussians at progressively higher resolution, with an Error Aware Module producing bounded depth offsets

$$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$4

and a Modulating Fusion Module that rescales opacity of previous levels based on current features and error maps (Tang et al., 2024). A pure hierarchy without such inter-scale coupling underperforms MVSplat, whereas the full model reaches PSNR 27.21 on RealEstate10K and 28.75 on ACID in the reported two-view setting (Tang et al., 2024). This suggests that hierarchy alone is insufficient unless scales interact.

Local-GS is not hierarchical, but it is relevant because it redefines tile-local rendering around warp coherence. Its hoisted quadratic form

$$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$5

and warp-level culling within tiles make it a natural micro-kernel for a hierarchical tiled renderer (Luo et al., 15 Jun 2026). A plausible implication is that a future HiGS implementation could combine macro-tile scheduling from (Pająk et al., 29 May 2026) with warp-coherent tile-local blending from (Luo et al., 15 Jun 2026).

7. Performance, trade-offs, and limitations

The rendering-oriented HiGS paper reports the strongest raw speed numbers. On RTX PRO 6000 Blackwell, mean frame time across seven Mip-NeRF360 scenes is 0.52 ms at 1080p and 0.82 ms at 4K for HiGS, versus 2.49 ms and 6.92 ms for gsplat in the like-for-like $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$6 setting (Pająk et al., 29 May 2026). Against a tile-size-optimized baseline, HiGS remains faster: 0.52 ms versus 1.85 ms at 1080p, and 0.82 ms versus 3.64 ms at 4K (Pająk et al., 29 May 2026). The paper states speedups up to $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$7 over original 3DGS and reports 1937 FPS at 1080p and 1214 FPS at 4K averaged over seven scenes, outperforming FlashGS, Faster-GS, TC-GS, Speedy-Splat, StopThePop, gsplat, and original 3DGS (Pająk et al., 29 May 2026).

Large-scene hierarchical representation papers emphasize different trade-offs. The INRIA HiGS system can render kilometer-scale captures in real time using LOD cuts; for BigCity, a fine threshold $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$8 px renders about 17.6M Gaussians, 19% of leaves, while a coarse threshold $$C_{\text{out}} = C_{\text{in}} + T_{\text{in}}\,\alpha_i\,c_i,\quad T_{\text{out}} = T_{\text{in}}(1-\alpha_i).$$9 px renders 2.68M, about 3% (Kerbl et al., 2024). It reports around 30–45 FPS at $8\times 8$0, around 60 FPS at $8\times 8$1, and above 100 FPS at $8\times 8$2 on an RTX 40xx-class GPU (Kerbl et al., 2024). The price is memory overhead: about 284 bytes theoretical or roughly 400 bytes actual per Gaussian, about 69% more than vanilla 3DGS, and about 68% larger disk models (Kerbl et al., 2024).

HUG shows that block partitioning and hierarchical anchors can improve both quality and scalability on large aerial scenes. On MatrixCity, it reports SSIM 0.883, PSNR 28.02, LPIPS 0.142, versus CityGS at 0.865/27.46/0.204 and Octree-GS at 0.814/26.41/0.282 (Su et al., 23 Apr 2025). Partitioning via sparse points and SVM takes about 10 minutes versus about 1.1h for a CityGS partition on Rubble (Su et al., 23 Apr 2025). The limitation is that HUG still loads all anchors and all per-block MLPs for rendering and does not provide out-of-core tile streaming (Su et al., 23 Apr 2025).

HRGS shows that hierarchical block optimization is particularly effective at high image resolution. On full-resolution Mip-NeRF360, it reports PSNR 27.91, SSIM 0.863, LPIPS 0.342, outperforming Mip-Splatting at 26.22/0.765/0.392 (Li et al., 17 Jun 2025). Yet its block count is delicate: on an ablation, 4 blocks outperform 2, 8, and 16 blocks, with too many blocks causing data fragmentation and lower PSNR/F1 (Li et al., 17 Jun 2025). This highlights a general HiGS trade-off: finer tiling improves memory locality but increases boundary management and risks local overfitting.

Several limitations recur across the literature. Forward-only renderers like (Pająk et al., 29 May 2026) do not address differentiable backward passes and note the need for additional per-pixel, per-batch state in training. Large-scene hierarchical systems often still rely on fixed global LOD thresholds rather than budget-driven policies (Kerbl et al., 2024). Blockwise methods usually depend on strong SfM or COLMAP reconstructions for partitioning and initialization (Su et al., 23 Apr 2025, Li et al., 17 Jun 2025). Dynamic scene systems remain sensitive to growth in Gaussian count over time and require explicit masking or pruning (Yang et al., 29 Aug 2025). Boundary treatment is often post hoc rather than based on overlapping tiles or shared optimization (Su et al., 23 Apr 2025). These are not contradictions so much as boundary conditions of the current design space.

A common misconception is that “hierarchical” in Gaussian splatting always means an octree of spatial nodes. The literature shows otherwise. HiGS may mean a two-level screen-space rendering factorization (Pająk et al., 29 May 2026), a Gaussian LOD tree over merged chunk Gaussians (Kerbl et al., 2024), an anchor-and-octree representation within blocks (Su et al., 23 Apr 2025), a scale hierarchy inside anchors for streaming scenes (Yang et al., 29 Aug 2025), or a Laplacian pyramid over voxelized Gaussian levels (Wang et al., 7 Aug 2025). The unifying property is not the exact tree structure, but the deliberate separation of coarse and fine responsibilities.

Another misconception is that hierarchy alone guarantees better quality or efficiency. HiSplat’s ablation demonstrates that a vanilla hierarchical stack without inter-scale coupling does not outperform strong single-scale baselines (Tang et al., 2024). Likewise, coarse LOD without hierarchy optimization degrades quality, while optimized interior nodes restore much of the lost fidelity (Kerbl et al., 2024). This suggests that the benefit of HiGS depends on how hierarchy is traversed, optimized, and pruned, not merely on its existence.

In aggregate, HiGS marks the transition of 3D Gaussian Splatting from a flat explicit representation into a family of multi-scale systems. Whether the goal is real-time rasterization, kilometer-scale rendering, high-resolution reconstruction, or streaming scene updates, the central idea remains the same: organize Gaussians into tiles or levels that can be sorted, optimized, activated, or discarded locally, while preserving the rendering semantics of 3DGS. The recent literature shows that this idea is now mature enough to support exact compositing renderers (Pająk et al., 29 May 2026), large-scene LOD representations (Kerbl et al., 2024), blockwise urban reconstruction (Su et al., 23 Apr 2025), streaming dynamic updates (Yang et al., 29 Aug 2025), and memory-efficient high-resolution optimization (Li et al., 17 Jun 2025).