---
title: Hierarchical Tiled Gaussian Splatting (HiGS)
url: https://www.emergentmind.com/topics/hierarchically-tiled-gaussian-splatting-higs
type: topic
---

# Hierarchical Tiled Gaussian Splatting (HiGS)

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” [2606.00352], 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 [2406.12080], [2504.16606], [2508.21444].

## 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 [2606.00352], [2406.12080].

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 [2606.00352].

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 [2406.12080]. “HUG” organizes large aerial scenes into blocks and, בתוך each block, an octree LOD of neural anchors [2504.16606]. “Scale-GS” organizes Gaussians hierarchically by scale within an anchor-based structure and selectively activates finer levels where coarse levels remain insufficient [2508.21444].

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 [2504.16606], [2606.00352].

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 [2606.00352]. 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 [2406.12080]. For large urban or aerial reconstructions, flat 3DGS suffers from excessive memory consumption, slow training, prolonged partitioning, and quality degradation with increased data volume [2504.16606]. For high-resolution reconstruction, optimizing all Gaussians and all images jointly can exceed 24GB VRAM at approximately 5K resolution [2506.14229]. For streaming or dynamic scenes, dense Gaussians per frame, global deformation, or large-scale spawning create substantial data volume and per-frame optimization cost [2508.21444].

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 [2606.00352]. 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 [2606.00352].

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 [2606.00352].

### 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 [2504.16606]. 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 [2506.14229]. 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 [2508.21444].

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 [2508.21444]. 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 [2406.12080]. 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 [2508.04965].

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 [2606.00352]. 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
\[
q = (l_0 dx + l_1 dy)^2 + (l_2 dy)^2,
\]
a sum of squares that is numerically stable in fp16 [2606.00352]. The paper reports a full fp16 data path while preserving image quality essentially indistinguishable from fp32 baselines against ground truth [2606.00352].

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 \((\text{depth}, \text{gaussian-id})\) pairs directly into per-macro-tile segments [2606.00352]. 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 [2606.00352].

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 [2606.00352]. 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:
\[
C = C_0 + T_0 C_1 + T_0 T_1 C_2 + \cdots.
\]
Because batches are contiguous in depth order within a macro-tile, this exactly reproduces front-to-back compositing of the full list [2606.00352]. 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 [2504.12811]. 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 \(50\times 50\) m for walking captures or \(100\times 100\) m for vehicle captures, after a coarse global initialization and skybox optimization [2406.12080]. 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 [2406.12080]. 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:
\[
\mu^{(l+1)} = \sum_i w_i \mu_i^{(l)},
\]
\[
\Sigma^{(l+1)} = \sum_i w_i \left[\Sigma_i^{(l)} + \left(\mu_i^{(l)}-\mu^{(l+1)}\right)\left(\mu_i^{(l)}-\mu^{(l+1)}\right)^\top\right].
\]
The merging weights are derived from opacity and projected surface area, with unnormalized form
\[
w_i' = o_i \sqrt{|\Sigma_i'|},
\]
approximated in practice via projected ellipsoid surface area [2406.12080]. 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 [2506.14229]. Gaussian partitioning is done after contracting the scene into a bounded cube,
\[
\text{contract}(\hat{\mathbf{p}}_k)=
\begin{cases}
\hat{\mathbf{p}}_k, & \|\hat{\mathbf{p}}_k\|_\infty \le 1,\\
\left(2-\frac{1}{\|\hat{\mathbf{p}}_k\|_\infty}\right)\frac{\hat{\mathbf{p}}_k}{\|\hat{\mathbf{p}}_k\|_\infty}, & \|\hat{\mathbf{p}}_k\|_\infty > 1.
\end{cases}
\]
Views are assigned to blocks both by rendering-based SSIM difference and by block-local camera position [2506.14229]. 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
\[
S_i = \alpha_i\, \tilde{v}_i\, H_i,
\]
where \(H_i\) is a transmittance-weighted hit count over rays, \(v_i = \prod_{d=1}^3 s_{i,d}\), and \(\tilde{v}_i = \ln(1+v_i)\) [2506.14229]. 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 [2506.14229]. 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 [2508.21444]. 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 \(1/1000\) of the original domain [2508.21444]. The total loss includes multi-scale photometric terms plus a sparsity penalty on learnable per-Gaussian masks:
\[
\mathcal{L} = \sum_{l=1}^L \mathcal{L}^{(l)} + \lambda_r \sum_{v \in V}\sum_{i=1}^N \sigma(M_{v,i}).
\]
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
\[
\hat{L} = \left\lfloor \min\bigl(\max(\log_2(d_{\max}/d), 0), K-1\bigr) \right\rfloor.
\]
Only anchors with level \(L \le \hat{L}\) are rendered in a given view [2504.16606]. The method reports state-of-the-art results on MatrixCity and competitive or superior quality on real aerial scenes [2504.16606]. 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
\[
f_{depth} = 1 + \alpha \cdot \max\Bigl(0,\; \frac{\sigma_{z,j}}{\sigma_{z,\text{thresh}}} - 1\Bigr),
\]
a compensated distance
\[
d'_{ij} = d_{ij}\cdot f_{depth},
\]
and a continuous level index
\[
L_{ij} = \log_2\left(\frac{D_{std}}{d'_{ij}}\right)
\]
to bias important or high-depth-variation regions toward finer levels [2508.04965]. Combined with GGD-based compression, it reports 9.5 MB on Waymo and 44 MB on MatrixCity while maintaining strong quality and high FPS [2508.04965]. This is not tiled in the same sense as HiGS [2606.00352], 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:
\[
\boldsymbol\Theta_{\text{GF}} =
\left\{
\boldsymbol\mu,\,
\mathcal{F}_{\text{cov}}(\mathbf{f}; \gamma_s),\,
\alpha,\,
\mathcal{F}_{\text{rgb}}(\mathbf{f}, \vec{\mathbf{d}})
\right\}.
\]
Its claimed complexity after pruning is approximately \(O(3.5N\text{ to }7N)\) versus \(O(59N)\) for standard 3DGS, matching empirical compression of \(7\sim17\times\) [2406.08759]. 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
\[
\Delta D_i = (2 \alpha_i - 1)\cdot \eta\, \text{Interp}(D_{i-1}),\quad
D_i = \Delta D_i + \text{Interp}(D_{i-1}),
\]
and a Modulating Fusion Module that rescales opacity of previous levels based on current features and error maps [2410.06245]. 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 [2410.06245]. 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
\[
\ln \alpha = \mathbf{V}_{\text{hoisted}}^\top \mathbf{B}_{\text{local}}
\]
and warp-level culling within tiles make it a natural micro-kernel for a hierarchical tiled renderer [2606.16566]. A plausible implication is that a future HiGS implementation could combine macro-tile scheduling from [2606.00352] with warp-coherent tile-local blending from [2606.16566].

## 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 \(8\times8\) setting [2606.00352]. 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 [2606.00352]. The paper states speedups up to \(15.8\times\) 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 [2606.00352].

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 \(\tau_1=3\) px renders about 17.6M Gaussians, 19% of leaves, while a coarse threshold \(\tau_3=15\) px renders 2.68M, about 3% [2406.12080]. It reports around 30–45 FPS at \(\tau_1\), around 60 FPS at \(\tau_2\), and above 100 FPS at \(\tau_3\) on an RTX 40xx-class GPU [2406.12080]. 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 [2406.12080].

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 [2504.16606]. Partitioning via sparse points and SVM takes about 10 minutes versus about 1.1h for a CityGS partition on Rubble [2504.16606]. 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 [2504.16606].

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 [2506.14229]. 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 [2506.14229]. 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 [2606.00352] 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 [2406.12080]. Blockwise methods usually depend on strong SfM or COLMAP reconstructions for partitioning and initialization [2504.16606], [2506.14229]. Dynamic scene systems remain sensitive to growth in Gaussian count over time and require explicit masking or pruning [2508.21444]. Boundary treatment is often post hoc rather than based on overlapping tiles or shared optimization [2504.16606]. 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 [2606.00352], a Gaussian LOD tree over merged chunk Gaussians [2406.12080], an anchor-and-octree representation within blocks [2504.16606], a scale hierarchy inside anchors for streaming scenes [2508.21444], or a Laplacian pyramid over voxelized Gaussian levels [2508.04965]. 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 [2410.06245]. Likewise, coarse LOD without hierarchy optimization degrades quality, while optimized interior nodes restore much of the lost fidelity [2406.12080]. 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 [2606.00352], large-scene LOD representations [2406.12080], blockwise urban reconstruction [2504.16606], streaming dynamic updates [2508.21444], and memory-efficient high-resolution optimization [2506.14229].

Source: https://www.emergentmind.com/topics/hierarchically-tiled-gaussian-splatting-higs