LightCache: Cache-Based Acceleration Techniques

• LightCache is a family of cache-based acceleration methods that store and reuse intermediate computations, notably in radiance caching for rendering and inference tasks.
• It encompasses varied implementations—from DRC’s CNN-denoised hemispherical radiance maps to neural and volumetric caches—all designed to balance computation efficiency and image fidelity.
• LightCache extends beyond rendering by optimizing video diffusion and LVLM operations, demonstrating practical trade-offs between bias, variance, and memory usage.

LightCache denotes a family of cache-based acceleration schemes in which intermediate state is stored and reused to reduce sampling cost, inference time, or memory footprint. In rendering, the term is closest to radiance-caching systems that reuse indirect illumination, outgoing radiance, or visibility across pixels, surface points, and path vertices; representative formulations include local hemispherical radiance maps, two-level screen/world caches, adaptive spatial–angular radiance structures, visibility caches for light sampling, and path-space caches for volumetric transport (Jiang et al., 2019). More recent work applies the same label to stage-aware cache management in video diffusion and to prompt-aware reduction of LVLM vision-token KV state, which suggests that LightCache is better understood as a reusable systems pattern than as a single canonical algorithm (Xiao et al., 6 Oct 2025).

1. Rendering lineage and conceptual core

In global illumination, LightCache-style methods arise from the broader radiance-caching lineage. Traditional irradiance caching and typical LightCache systems precompute or incrementally build caches of diffuse indirect lighting values and interpolate them, while photon mapping accumulates photon density to estimate indirect light. Krivanek et al. (2005) extended caching to glossy and view-dependent effects by storing radiance rather than only diffuse irradiance. Within this lineage, Deep Radiance Caching (DRC) is presented as an efficient variant of radiance caching: it separates direct and indirect lighting, path traces the first intersection, builds a local hemispherical radiance cache there, and uses a convolutional autoencoder to reconstruct a high-quality radiance map from low-quality inputs. The resulting cache is queried with the material BRDF at the shading point, which preserves BRDF evaluation at the query point, supports glossy and specular materials, avoids per-scene training and any pre-bake, and runs efficiently on CPUs (Jiang et al., 2019).

The same conceptual core appears in more explicitly named LightCache systems. GI-1.0 defines a two-level LightCache in which a screen cache stores incoming radiance over the oriented hemisphere at primary visible surfaces, while a world cache stores outgoing radiance at secondary path vertices. The screen cache is the final carrier of GI for the frame; the world cache is the temporally persistent source for secondary-vertex lighting returned to screen rays. This division makes the cache both directional and stage-specific: primary visible shading consumes interpolated screen probes, whereas secondary transport is stabilized in a hashed world-space structure (Boissé et al., 2023).

Volumetric transport generalizes the idea further. Second-order occlusion-aware volumetric radiance caching extends LightCache-style reuse into participating media by storing radiance at sparse points in the medium and controlling reuse with a second-order Hessian-based error metric. The central claim is not merely that cached radiance is reused, but that reuse regions should shrink anisotropically along directions of high curvature induced by transmittance and occlusion changes. In this sense, the LightCache concept becomes an error-controlled interpolation framework rather than only a lookup table (Marco et al., 2018).

2. Cache representations and query mechanisms

Representative LightCache systems differ chiefly in what they cache, how they index it, and what estimator consumes the cached state.

System	Cache payload	Query mechanism
DRC	32×32 local hemispherical radiance map $R$	MIS over $R$ and BRDF, progressive grid interpolation
GI-1.0	screen-probe 8×8 octahedral radiance; world-cache outgoing radiance cells	reprojection, parallax correction, SH interpolation
OctaOctree	adaptive octree with octahedral directional features	trilinear spatial + barycentric angular interpolation
Neural Visibility Cache	MLP-predicted visibility to lights or clusters	WRS/RIS with one shadow ray
GSCache	per-path-length 3D Gaussian splats	rasterized cache images queried at path termination
LightCache for video diffusion	cached U-Net/DiT features	asynchronous swapping, feature chunk, sliced decode
LightKV	compressed vision-token KV states	prompt-aware message passing during prefill

DRC stores per-cache inputs as 32×32 hemispherical latitude-longitude maps of radiance/intensity at 1 sample per pixel, normals, and distance, aligned to a local frame in which the surface normal points to the $Z$ direction of the map. The network predicts a 32×32 radiance map $R$, excluding direct light. At shading time, DRC evaluates the BRDF $f_r$ and integrates the predicted map using MIS, alternating samples from $R$ and from the BRDF distribution. Its rendering split is explicit:

$L_o(x,\vec{\omega}_0)=L_e(x,\vec{\omega}_0)+\int_{\Omega_{2\pi}} f_r \cos(\theta_i)\,R_i(\vec{\omega}_i)\,d\omega_i+\int_{\Omega_{2\pi}} f_r \cos(\theta_i)\,D_i(\vec{\omega}_i)\,d\omega_i,$

where direct illumination is handled independently so that edges and hard shadows are preserved (Jiang et al., 2019).

GI-1.0 adopts a different representation. Each screen probe stores an 8×8 octahedral map of incoming radiance, with alpha storing hit distance for parallax correction, while the world cache is a GPU hash map with open addressing and linear probing that groups cells into tiles, each tile being a linear 8×8 array of cells including mip levels. Query validity depends on geometric guards such as plane distance and normal-angle checks; irradiance is recovered by projecting each probe’s 8×8 radiance to SH, interpolating four directional neighbor probes, and dotting the cached SH coefficients with the projected cosine lobe (Boissé et al., 2023).

OctaOctree makes the spatial–angular decomposition explicit. It organizes outgoing radiance with an adaptive octree in 3D space and associates each spatial node with an octahedral directional map. Coarse spatial cells retain higher directional resolution, whereas fine spatial cells retain lower directional resolution but denser cells. At a primary hit, the method performs a single cache query: it interpolates features from the 8 neighboring spatial cells, uses octahedral mapping and barycentric weights within each directional triangle, concatenates multi-level features, and decodes final radiance with a lightweight MLP. The stored quantity is not raw radiance but a learned feature vector per directional vertex (Ren et al., 7 Jun 2026).

Neural Visibility Cache uses a neural cache rather than a geometric radiance record. A multi-resolution hash-grid encoding of world-space position feeds a fully-fused MLP that predicts non-binary visibility to each light or light cluster. The cache output is not final lighting; it defines a learned proposal:

$\hat w(l|x)=I(l)\cdot LTC(x,l)\cdot \max(\hat V(x,l),\epsilon),$

which then drives weighted reservoir sampling. A single shadow ray is traced only for the selected light, so the cache stores visibility guidance rather than radiance itself (Bokšanský et al., 6 Jun 2025).

GSCache, by contrast, is a path-space LightCache for volume rendering. It stores attenuated radiance for paths of length exactly $n$ in separate cache levels, each represented by sets of 3D Gaussians. Before each path tracing pass, all levels are rasterized into cache images; at early or natural path termination, the renderer queries the corresponding level and corrects the contribution by the cascaded miss probability. The cache is therefore spatial, multi-level, and indexed by path length rather than by screen tile or octree node (Bauer et al., 25 Jul 2025).

3. Neuralization and online adaptation

A major development in LightCache research is the shift from fixed interpolation rules toward learned cache payloads and online adaptation. DRC uses a U-Net-like convolutional autoencoder with skip connections and a symmetric encoder–decoder. Its 7-channel 32×32 input comprises radiance RGB, normals XYZ, and distance Z; the output is a 3-channel radiance map. The model is trained once on 43 scenes with 16,000 training examples of hemispherical maps, using PyTorch, Adam with learning rate $6e{-5}$, mini-batch size 32, and about 3 epochs over augmented data; the result is used without per-scene retraining. Inference runs on CPU only, and the paper reports high-quality images within 180 seconds on a single CPU (Jiang et al., 2019).

Real-time Neural Radiance Caching (NRC) pushes adaptation further by replacing explicit cache records with a single small MLP $R$0 that approximates scattered radiance $R$1. The cache is trained online while rendering, without precomputation and without assumptions about lighting, geometry, or materials. Queries occur when a path terminates into the cache, while updates are obtained by extending a small fraction of paths by a short training suffix and forming self-training targets that combine a short Monte Carlo estimate with the current cache prediction at the suffix tail. The reported overhead is about 2.6 ms on full HD resolution, with about 1.59 ms for inference and about 1.11 ms for training on an RTX 3090 (Müller et al., 2021).

OctaOctree and GSCache occupy an intermediate position between static and fully online learned caches. OctaOctree is scene-specific: it trains a fixed $R$2-level hierarchy per scene, uses a disparity predictor with an Instant-NGP-style multi-resolution hash encoding and a tiny MLP, and a 4-hidden-layer decoder of width 128. Runtime is real-time, with reported averages of 10–20 ms across test scenes at 720p–1024p, but the representation is static-scene and requires about 1 hour of training per scene. Its contribution is to move high-frequency angular structure into the cache itself, reducing the burden on the decoder to hallucinate sharp glossy lobes from positional features alone (Ren et al., 7 Jun 2026).

GSCache is online-trainable on the fly. It seeds a point cloud with a single delta-tracking pass, typically with $R$3 points, replicates and logarithmically sub-samples it per path-length level, and optimizes Gaussian parameters with AdamW using an HDR Noise2Noise loss. The cache adapts dynamically to changes in scene parameters such as lighting configurations and transfer functions, and an example 3-level configuration with $R$4 seed points uses about 28 MB total cache size (Bauer et al., 25 Jul 2025).

4. Estimator properties, bias control, and failure modes

LightCache systems differ sharply in their estimator guarantees. DRC is explicitly a biased method: it does not converge to an unbiased result, SSIM does not approach 1 with more tasks, small and high-frequency details in indirect reflections are lost because the radiance map resolution is fixed at 32×32, and caustics are not accurately reproduced. Without persistent caching, per-pass tile variation can cause low-frequency flickering across frames, so the method is not adequate for animations unless a temporal cache is added (Jiang et al., 2019).

GI-1.0 also accepts bias as part of its systems design. Its screen probes use a biased shadow-preserving temporal hysteresis, world-space ReSTIR uses only one shadow ray after resampling, omits spatial resampling, and performs a single temporal reuse pass. The paper states that this deliberately increases bias, often visible as darkening, in exchange for lower noise at a fixed ray budget. Multi-bounce GI is approximated through temporal radiance feedback, which can lag when contributing reflectors were not visible in the previous frame (Boissé et al., 2023).

By contrast, second-order occlusion-aware volumetric radiance caching is organized around an explicit error metric. It derives first- and second-order spatial derivatives of radiance from a proxy triangulation of the incoming light field, uses the Hessian to estimate the relative error of first-order extrapolation,

$R$5

and converts the Hessian eigenstructure into anisotropic ellipsoidal reuse regions. In practical three-dimensional scenarios, the method reports improved results while reducing computation time by up to 30\% compared to previous work (Marco et al., 2018).

Neural Visibility Cache is notable because it uses a learned proposal while preserving an unbiased estimator. After WRS selects light $R$6 using surrogate weights $R$7, the final estimate is

$R$8

and unbiasedness is maintained by clamping predicted visibility to $R$9 so that every light with nonzero true contribution retains nonzero sampling density. The learned cache therefore changes only the proposal, not the estimator’s correctness class (Bokšanský et al., 6 Jun 2025).

NRC and GSCache occupy the usual variance–bias trade-off of learned caches. NRC reports significant noise reduction at the cost of little induced bias and injects correct source values by making every 16th training suffix unbiased (Müller et al., 2021). GSCache uses a user-defined coefficient $Z$0 in its early termination heuristic; lower $Z$1 increases cache hits and image metrics but increases bias, while higher $Z$2 favors unbiased long paths and increases variance and runtime (Bauer et al., 25 Jul 2025).

5. LightCache beyond light transport

In 2025, the term LightCache was used directly for training-free acceleration of video diffusion inference. This system decomposes inference into encoding, denoising, and decoding, and targets the VRAM surge created by resident caches in denoising and by VAE activation peaks in decoding. The method combines three stage-specific strategies: Asynchronous Cache Swapping, Feature chunk, and Slicing latents to decode. Cached features from selected U-Net or DiT blocks are stored in pinned host memory and asynchronously swapped with a dedicated CUDA stream; feature maps $Z$3 are chunked along height and width; and the VAE decodes frames in temporal slices instead of decoding an effective batch of $Z$4 images at once. Reported examples include AnimateDiff-Lightning at 512×512, where the baseline is 3.84 s with peak VRAM about 13.6 GB and LightCache with $Z$5 is 2.41 s with peak VRAM about 5.6 GB, and Stable Video Diffusion Img2Vid XT at 1024×576, where the baseline is 47.39 s with peak VRAM about 15.3 GB and LightCache with $Z$6 is 16.57 s with peak VRAM about 13.9 GB (Xiao et al., 6 Oct 2025).

A related but distinct application appears in LVLM inference as LightKV, described as a LightCache idea for making the KV cache lightweight. The method addresses the fact that the vision-token KV cache dominates memory during prefill because $Z$7 is large, with approximate baseline memory

$Z$8

LightKV reconstructs vision tokens to a 2D grid, partitions them into windows, computes feature divergence with cosine distance, derives prompt-guidance weights from cross-modal attention,

$Z$9

and performs prompt-aware message passing and aggregation:

$R$0

With only 55\% of the original vision tokens, the method halves the vision-token KV cache size, reduces computation by up to 40\%, and preserves general-purpose performance while significantly outperforming existing baselines (Chen et al., 1 May 2026).

These non-rendering systems retain the defining LightCache pattern—store reusable intermediate state and restructure execution around reuse—but the object being cached is no longer radiance or visibility. In video diffusion it is intermediate denoising features and decode-time latent slices; in LVLMs it is the effective depthwise footprint of vision-token KV state during prefill.

6. Terminological scope and common misconceptions

A recurring misconception is that LightCache denotes a single rendering algorithm. The literature instead spans on-the-fly, CPU-accessible radiance caching with CNN-denoised hemispherical maps (Jiang et al., 2019), explicit two-level screen/world radiance caches (Boissé et al., 2023), online-trained neural visibility proposals for unbiased light sampling (Bokšanský et al., 6 Jun 2025), and stage-aware memory control for diffusion inference (Xiao et al., 6 Oct 2025). This suggests that the term is overloaded across domains and should be interpreted through the cached quantity, the reuse policy, and the estimator wrapped around that reuse.

Another misconception is that LightCache implies either precomputation or training-free operation. DRC requires no precomputation and no per-scene retraining, but it still relies on a pretrained CNN (Jiang et al., 2019). NRC, NVC, and GSCache train while rendering or while adapting to scene changes (Müller et al., 2021); the video-diffusion LightCache is explicitly training-free (Xiao et al., 6 Oct 2025); LightKV is also training-free and plug-and-play during prefill (Chen et al., 1 May 2026). The shared property is therefore not whether training occurs, but whether cached intermediate state amortizes future computation.

A third misconception is that caches are always either unbiased or high fidelity. The rendering literature shows several incompatible design points: DRC and GI-1.0 accept bias to obtain smoother indirect illumination and lower ray budgets (Jiang et al., 2019); (Boissé et al., 2023), second-order volumetric radiance caching imposes a principled Hessian-based reuse test (Marco et al., 2018), and Neural Visibility Cache maintains unbiasedness by confining learning to proposal generation and correcting with RIS reweighting (Bokšanský et al., 6 Jun 2025). LightCache is therefore best viewed as a design space structured by three tensions: what state is worth caching, how that state is queried and updated, and what guarantees are retained or relaxed in exchange for reuse.

Under that broader interpretation, LightCache has become a technical idiom for computation reuse under strict runtime constraints. In rendering, it mediates between sparse path sampling and stable global illumination; in generative inference, it mediates between feature redundancy and VRAM peak; in LVLMs, it mediates between prompt-aware relevance and KV cache growth. The common architecture is persistent reuse, but the scientific content lies in the representation, the update rule, and the estimator-specific correction layered on top.