Hierarchical Progressive Rendering (HiPR)

• HiPR is a dynamic render-scheduling method that updates image tiles based on light-path dependencies after scene edits.
• It orders pixel tiles by perceptual impact using dependency discovery and depth-tested reprojection to prioritize informative regions.
• By reordering tile updates without changing per-sample estimators, HiPR preserves unbiased convergence while accelerating feedback.

Hierarchical Progressive Rendering (HiPR) denotes a dynamic render-scheduling method in which an interactive path tracer responds to scene edits by recomputing only a priority-ordered subset of image regions while temporarily retaining previously rendered radiance elsewhere. In its 2026 formulation, HiPR is not a new light transport estimator but a scheduling layer over a standard unbiased path tracer: it organizes pixels, grouped into tiles, into a hierarchy of light-path dependencies that radiate outward from changed scene elements, prioritizes updates by perceptual impact, and aims to provide immediate visual feedback while preserving eventual unbiased convergence (Padilla et al., 25 Jun 2026).

1. Conceptual scope and historical setting

Within path tracing, HiPR addresses a specific failure mode of conventional progressive rendering: after an edit to geometry, materials, lighting, or camera, most renderers effectively mark the whole frame dirty and resume uniform resampling. Under that regime, there is no guarantee that the pixels most revealing the edit will be updated first. HiPR reframes the post-edit problem as one of priority scheduling. The central idea is that only some visible image regions depend strongly on the changed set, and that these dependencies can be inferred from light transport rather than from purely image-space error heuristics (Padilla et al., 25 Jun 2026).

The term also sits within a broader family of hierarchical and progressive rendering systems, although those systems operate on different data structures and targets. In astronomy, HiPS organizes sky surveys by HEALPix order so that clients progressively refine a view through hierarchical tiling and deterministic tile indexing (Fernique et al., 2017). In static 3D Gaussian Splatting, PRoGS constructs a global importance order over Gaussians from their accumulated radiance contribution and supports further spatial, frustum, and object-level prioritization for progressive loading and rendering (Zoomers et al., 2024). For dynamic Gaussian scenes, PD-4DGS decomposes a monolithic 4D model into a static scaffold, a global deformation layer, and a local refinement layer so that any transmitted prefix is renderable (Li et al., 12 May 2026). ProgressiveAvatars builds an animatable avatar hierarchy by adaptive subdivision on a template mesh and streams refinements in importance order (Song et al., 17 Mar 2026). Taken together, these systems suggest a broader usage in which “hierarchical progressive rendering” refers not to one fixed data structure but to a family of coarse-to-fine, prefix-renderable strategies.

A frequent misconception is therefore that HiPR must always denote a multiresolution scene representation. In the path-tracing sense, that is not the case. The 2026 HiPR method does not replace geometry, materials, or the path tracer with a new hierarchy; its hierarchy is an ordering over image tiles induced by discovered light-path dependencies, not an explicit scene tree (Padilla et al., 25 Jun 2026).

2. Dependency hierarchy and tile discovery

HiPR partitions the framebuffer into a uniform grid of tiles, each an $n \times n$ block of pixels, and defines a changed set

$$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$

After an edit, the method proceeds in three stages. The first stage is a visibility pass that traces one primary ray through each pixel center and records a G-buffer containing object identity and camera-space depth. Any tile containing at least one pixel whose primary hit belongs to $\mathcal{E}$ is inserted into the active set

$$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$

These tiles constitute the first level of the hierarchy, because they directly reveal the edit (Padilla et al., 25 Jun 2026).

The second stage renders the active tiles with an ordinary path tracer, but augments tracing with dependency discovery. For each secondary vertex $\mathbf{x}_k$ along a path, HiPR transforms the point into camera space,

$$\begin{bmatrix} x \ y \ z \end{bmatrix} = M_{\mathrm{cam}}^{-1} \, \mathbf{x}_k,$$

and projects it to the image plane with

$$\begin{bmatrix} u \ v \end{bmatrix} = \begin{bmatrix} O_x + f \dfrac{x}{z} \ O_y + f \dfrac{y}{z} \end{bmatrix},$$

where $[O_x,O_y]$ is the principal point and $f$ is the focal length. The projected point is accepted only if it lies within the frame and its depth matches the G-buffer within a tolerance $\epsilon$. This depth-tested reprojection identifies tiles that are indirectly affected by the edit through multi-bounce light transport rather than by direct visibility alone (Padilla et al., 25 Jun 2026).

The resulting hierarchy is implicit. HiPR does not build an explicit tree of influence. Instead, tiles are discovered outward from the edited elements through actual transport paths: directly visible tiles first, then tiles reached by bright reflections, transmitted light, indirect diffuse transport, and cast-shadow changes. Shadow changes are handled through next-event estimation: if a shadow ray toward a light is blocked by an edited element, the tile containing the shadowed point receives an occlusion-derived priority contribution (Padilla et al., 25 Jun 2026).

3. Priority weights, perceptual control, and convergence behavior

Each visible secondary vertex contributes a scheduling weight to the tile in which it projects:

$$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$0

where $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$1 is path throughput up to bounce $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$2, $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$3 is a user-defined priority for the sampled scattering lobe, $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$4 is a user-defined priority for the path class, and the factor $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$5 penalizes deeper bounces. Tile importance is then accumulated by

$$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$6

The lobe weights and path-class weights are normalized separately so that

$$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$7

These weights are not sampling probabilities; they are scheduling controls that encode perceptual preference (Padilla et al., 25 Jun 2026).

This construction yields a hierarchy ordered by transport significance. Tiles with large throughput, shallow bounce depth, and high-priority transport classes receive the largest $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$8 and are rendered earliest. In practical terms, this means that directly visible edits, strong specular reflections, bright transmission effects, and salient shadows can be surfaced before low-energy diffuse changes in far-away regions. A common misconception is that HiPR is merely adaptive sampling under a different name. The distinction is structural: classical adaptive sampling allocates samples to reduce estimator variance, whereas HiPR allocates post-edit work to reveal dependencies on the changed set. The two strategies are compatible, but they answer different questions (Padilla et al., 25 Jun 2026).

HiPR also preserves unbiasedness. The method “only reorders tiles; it does not alter the per-sample estimator for a tile’s pixels.” Within each tile, radiance remains the usual Monte Carlo mean over independent samples. The consequence is that final convergence is identical in distribution to that of the underlying progressive path tracer; only the temporal order in which different image regions are refreshed changes. The paper does not present a formal convergence proof, but its stated argument is that reordering pixel or tile updates does not introduce bias provided every tile continues to receive unbiased samples in the limit (Padilla et al., 25 Jun 2026).

4. Renderer integration and operating parameters

The reference implementation uses Vulkan with inline ray tracing rather than the full Vulkan ray-tracing pipeline. Hardware ray queries provide BVH traversal and hit information inside compute shaders, while materials are indexed manually by object ID. The stated motivation is engineering economy: a single megakernel-style path tracer can issue rays directly without the overhead and complexity of a shader binding table and multiple pipeline stages. Materials use Adobe’s OpenPBR BSDF implementation in GPU-aligned layouts (Padilla et al., 25 Jun 2026).

Two implementation parameters control much of HiPR’s behavior. The first is tile size $$\mathcal{E} = \{ \text{scene elements whose transformation, geometry, material, or emission changed} \}.$$9. Small tiles improve localization and make the dependency hierarchy spatially precise, but increase dispatch and sorting overhead. Large tiles improve coherence and reduce scheduling cost, but coarsen the hierarchy to the point where discovery approaches object-level visibility rather than localized influence. The second is the depth tolerance $\mathcal{E}$0 used when reprojecting secondary vertices against the G-buffer. Small $\mathcal{E}$1 yields stricter visibility testing but risks false negatives, especially on grazing or curved surfaces; large $\mathcal{E}$2 reduces misses but can admit false positives through thin occluders (Padilla et al., 25 Jun 2026).

The GPU implementation accumulates tile weights with atomic additions and sorts discovered tiles in parallel by decreasing $\mathcal{E}$3. After geometry, material, or light edits, the changed objects enter $\mathcal{E}$4 and the standard three-stage pipeline runs. Camera motion is treated more conservatively: the current formulation reprojects the entire frame after camera movement, reflecting the view that parallax can affect all objects, though not equally. This conservatism is explicit in the paper and is identified as a limitation rather than as a claimed optimal policy (Padilla et al., 25 Jun 2026).

The paper’s experimental description emphasizes qualitative responsiveness rather than rate tables. A reference implementation was demonstrated at SIGGRAPH 2026 Real-Time Live!, and the reported outcome is that direct-change tiles update first, perceptually salient indirect effects follow, and rendering effort is amortized toward the regions where it is most informative (Padilla et al., 25 Jun 2026).

5. Related hierarchical progressive schemes outside path tracing

Outside interactive path tracing, hierarchical progressive rendering is often realized through representation design rather than scheduling alone. HiPS is exemplary in this regard: it uses hierarchical tiling of the celestial sphere with HEALPix, where order $\mathcal{E}$5 contains

$\mathcal{E}$6

cells, parent and child indices are obtained arithmetically by $\mathcal{E}$7 and $\mathcal{E}$8, and clients progressively request higher-order tiles as zoom increases (Fernique et al., 2017). In that setting, hierarchy is explicit, spatial, and file-addressable.

For explicit radiance-field primitives, PRoGS defines a global Gaussian importance score

$\mathcal{E}$9

derived from per-pixel compositing contribution in training views. Gaussians are then sorted by $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$0 and optionally redistributed by octree, frustum, or object grouping. The resulting prefix order supports both progressive rendering and progressive streaming, and provides a clear quality–resource tradeoff for 3D Gaussian Splatting scenes (Zoomers et al., 2024).

More elaborate 3DGS hierarchies introduce explicit multilevel models. Iterative Gaussian Synopsis constructs LODs $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$1 by top-down “unfolding” of a full-resolution anchor-based model, using learnable mask-based pruning, shared multi-resolution grids, and a shared Anchor Codebook so that higher LODs can be transmitted largely as deltas rather than as independent models (Lu et al., 13 Apr 2026). In volumetric video, 4DGCPro organizes 4D Gaussians into perceptually weighted layers using

$$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$2

and combines that layer hierarchy with motion-aware adaptive grouping and layer-wise rate–distortion supervision so that a single bitstream supports multiple qualities and bitrates (Zheng et al., 22 Sep 2025). PD-4DGS extends the same principle to deformation networks by externalizing a static scaffold, global deformation, and local refinement as independently transmittable layers for dynamic-scene streaming (Li et al., 12 May 2026). ProgressiveAvatars applies a related logic to animatable human heads, binding Gaussians to a subdivided FLAME mesh hierarchy and ranking faces by

$$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$3

for incremental loading and rendering (Song et al., 17 Mar 2026).

These examples indicate a broader taxonomy. In some systems, hierarchy is a scheduling order over image tiles; in others, it is a geometric, semantic, or compression hierarchy over scene primitives. The shared property is prefix utility: any early portion of the computation or bitstream already produces a valid, interpretable result.

6. Limitations, open problems, and research directions

The path-tracing form of HiPR has several explicit limitations. Its weighting function depends on throughput, path type, and bounce depth, but not on the actual magnitude of the edit; the paper identifies “delta-aware weighting” as a future direction. Its perceptual model is manually parameterized through $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$4 and $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$5 rather than learned or psychophysically calibrated; a formal perceptual salience formula is named as an open problem. Camera motion is currently handled by full-frame reprojection rather than by finer per-object motion criteria. The method also incurs overhead from vertex projection, depth testing, and GPU sorting, and the tradeoff between localization and throughput still depends on empirical choices of $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$6 and $$\mathcal{A} = \{ T \in \mathcal{T} \mid \exists \text{ pixel in } T \text{ directly seeing an element in } \mathcal{E} \}.$$7 (Padilla et al., 25 Jun 2026).

Related hierarchical progressive systems expose parallel limitations. PRoGS notes that its frustum prioritization is view-dependent but not fully visibility-aware and suggests online adaptation or reinforcement learning as future possibilities (Zoomers et al., 2024). Iterative Gaussian Synopsis is limited to static scenes and still reports mild popping when switching between discrete LODs (Lu et al., 13 Apr 2026). 4DGCPro emphasizes training cost, reliance on dense multiview capture, and difficulty scaling to larger spatial scenes, while also pointing toward gaze-adaptive and view-dependent progression (Zheng et al., 22 Sep 2025). PD-4DGS is designed around three deformation layers and emphasizes streaming feasibility over city-scale spatial complexity (Li et al., 12 May 2026). ProgressiveAvatars is centered on head avatars and leaves broader-body or general-scene extension open (Song et al., 17 Mar 2026).

A plausible implication is that future HiPR systems will increasingly combine both senses of hierarchy at once: transport-aware scheduling in image space and compressible multilevel scene representations in object space. The existing literature already supplies many of the components—deterministic tile hierarchies, contribution-based primitive ranking, top-down LOD unfolding, temporal decomposition, and layer-wise rate–distortion training—even though they currently appear in different subfields rather than in a single unified framework.