Collaborative Texture Filtering

Bartlomiej Wronski; Matt Pharr; Pontus Ebelin; Tomas Akenine-M\"oller

REVIEW 2 major objections 4 minor 24 references

Collaborative Texture Filtering

T0 review · 2 major / 4 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read The paper claims that by distributing unique texel evaluations across the lanes of a GPU wave, exact zero-error texture filtering is possible at one texel evaluation per pixel whenever magnification is sufficiently large.

desk verdict A genuinely useful set of wave-communication tricks that make exact filtered texture lookups practical for expensive decompression formats; the headline magnification thresholds are empirically motivated rather than proven worst-case, but the core idea holds up. read the letter →

arxiv 2506.17770 v1 pith:2ILDUGIK submitted 2025-06-21 cs.GR cs.CV

Tomas Akenine-Möller , Pontus Ebelin , Matt Pharr , Bartlomiej Wronski This is my paper · ORCID

classification cs.GRcs.CV

keywords stochastictexturefilteringwaveintrinsicsmagnificationbilinearbicubiccompressionGPUshadingexact

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that when a texture is magnified, exact texture filtering does not require each pixel to decode all of its own texels. Instead, the lanes of a GPU wave can collaboratively determine every texel the wave needs, have each lane produce one unique texel, and then share those values so every pixel filters exactly. The paper presents three collaboration schemes, Box Sampling, Mask Sampling, and List Merge, that guarantee perfect bilinear filtering on 32-lane 8x4 waves once magnification reaches about 2.35 for Box Sampling and 1.59 for Mask Sampling and List Merge, at any orientation. This matters because modern compressed and neural texture formats cannot use the GPU's built-in texture filtering hardware, leaving stochastic filtering as the only cheap option, which introduces noise and flicker under magnification. The paper also contributes fallback methods that maintain higher quality than prior stochastic approaches when the wave cannot produce every needed texel.

What carries the argument

The machinery is GPU wave intrinsics, the register-level communication instructions that let shader lanes executing together as one wave exchange values without memory traffic, combined with three schedules for deciding which lane produces which texel. Box Sampling computes a wave-wide axis-aligned bounding box of all needed texel coordinates using WaveActiveMin and WaveActiveMax, then maps lane indices bijectively into that box. Mask Sampling encodes the wave's required texels in a 16x16 bitmask combined across lanes with WaveActiveBitOr, and uses a rank-and-select mapping that sends lane i to the i-th set bit and reverses the mapping when gathering taps. List Merge builds the exact duplicate-free list of needed texels hierarchically in shared memory and serves as the upper bound on how often perfect filtering is possible. These mechanisms convert redundant per-pixel texel decompression into one cooperative pass per wave.

What would settle it

Render a magnified textured quad with an 8x4 pixel wave layout at magnification factor at least 1.59 and any rotation, with the fallback disabled, and count for every wave the number of distinct integer texel coordinates lying in the bilinear footprints of its pixels. Mask Sampling and List Merge predict this count is never above 32; a single wave with 33 or more needed texels, or a pixel whose four taps are not all present after the gather, would refute the zero-error claim. For Box Sampling the corresponding critical magnification is 2.35.

Watch

Extended reading notes

Core claim

The central discovery is that exact texture filtering under magnification does not require each pixel to own its filter taps. The wave treats the union of all pixels' required texels as a shared job list: lanes first communicate which texel coordinates they need, then each lane produces one not-yet-produced texel from that list, then every lane gathers its filter taps from neighboring lanes via wave intrinsics and applies the true filter weights. When the number of unique texels fits within the 32 lanes, the result is identical to full bilinear or bicubic filtering, with zero error and at most one texel evaluation per pixel. For bilinear filtering, this success is guaranteed for magnification factors of about 1.59 and above with Mask Sampling and List Merge, and about 2.35 and above with Box Sampling, under the assumed 8x4 pixel wave layout. The same approach also handles filters with negative weights, such as Catmull-Rom, with at most one texel per lane, in contrast to the two taps that positivization requires in one-tap stochastic filtering.

Load-bearing premise

The zero-error guarantee assumes the 32 lanes of a wave are arranged as a spatially coherent 8x4 tile of pixels, so the union of the texels they need is small enough to fit in 32 slots; if lanes were scattered over random screen positions or heavily divergent, the texel demand would overflow the wave and the method would fall back to approximate filtering.

Editorial extensions

If this is right

For neural texture decompression at magnification above the thresholds, collaborative filtering can produce zero-error results with about one texel evaluation per pixel; the paper's neural decompression test showed a path around 93 microseconds per megapixel versus 516 for per-pixel 2x2 decompression, making exact filtering practical for expensive formats.
When a wave needs only a few unique texels, the decompression work for a single texel can itself be distributed across lanes: the paper demonstrates a 1.64x speedup in a mixed scene and 2.5x when fully magnified for DCT-based decompression by splitting color channels across lanes.
Filters with negative weights, such as Catmull-Rom, can be filtered exactly with at most one texel per lane under sufficient magnification, removing the two-tap cost that positivization imposes on one-tap stochastic filtering.
Below the perfect-filtering thresholds, the new fallback estimators give higher image quality than both one-tap stochastic texture filtering and wave-communication stochastic texture filtering; the extended fallback uses otherwise idle lanes to produce additional unique texels, so quality continues to improve as magnification frees more lanes.
The same collaborative structure extends to larger discrete filters: perfect bicubic filtering is achievable with one texel per lane at higher magnification, or with two texels per lane at magnification factors close to the bilinear ones.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If wave size grew beyond 32 lanes, the same counting argument would push the perfect-bilinear magnification threshold below 1.59 and toward 1.0 for wide enough waves; the paper states the methods generalize to any wave size but does not measure this scaling.
The bitmask rank-and-select scheme only requires each pixel's needed values to form a small enumerable set, so the same cooperative pattern could be reused for other per-pixel gathers, such as sharing material samples or light-list queries among neighboring pixels.
For decompressors whose per-texel cost is very high, the fallback regime may also beat per-pixel deterministic filtering even below the zero-error thresholds; the paper's expensive-decompressor measurement only demonstrates the high-magnification regime.
A hybrid that combines several waves through shared memory, which the authors mention as future work, could extend exact filtering to lower magnification or wider filters without waiting for hardware with larger waves.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: this is the first practical way I've seen to get exact bilinear (and bicubic) texture filtering under magnification for formats that can't go through the fixed-function texture units, at roughly one texel decode per pixel. The wave-level work allocation is the real contribution, and it is genuinely new relative to WPAM25.

The paper gives three collaborative algorithms — List Merge, Box Sampling, Mask Sampling — plus a fallback estimator and edge remapping. The logic is constructive and clear: each lane reports its filter footprint, the wave builds the union, and if that union fits in 32 lanes, each lane produces one unique texel and gathers via wave intrinsics. When it doesn't fit, the fallback still beats prior STF methods. The evaluation is honest: multiple metrics, denoised and non-denoised, real NTC integration, and the performance numbers on the RTX 5090 are plausible. The Catmull-Rom handling with negative weights using a single tap is a nice bonus. No circularity; the comparison against ground-truth bilinear is external.

The soft spots are about the scope of the headline guarantee, not the core mechanism. The 1.59 / 2.35 thresholds come from one empirical scene (an 8x4 wave on a uniformly scaled, head-on rotated quad). The paper states these as if they are general guarantees, but the actual condition is simply that the union of needed texels over the wave fits in the active lanes. That union depends on sub-texel phase, anisotropic Jacobians, perspective shear, and active-lane masks. The paper does acknowledge fallback at edges and perspective growth for Box Sampling, but it never bounds the worst case for arbitrary content. That's a real gap, though it is a scoping issue rather than a flaw in the algorithm: when the set fits, the result is exact; when it doesn't, the fallback degrades gracefully. The authors could fix this by either proving a worst-case bound for 8x4 pixel waves or explicitly stating the guarantee as conditional on the unique-texel count.

The spatial-coherence assumption (lanes are an 8x4 tile in screen space) is also worth flagging — if a future GPU schedules lanes in scattered patterns, the whole scheme loses its footing. That's a hardware assumption, not a failure of the current implementation.

Who is this for: anyone working on real-time rendering with neural or custom-compressed textures, and anyone building on wave intrinsics for shader-side filtering. It deserves a serious referee; the algorithms are reproducible enough that the core claims can be verified and the caveats can be tightened.

Recommendation: send it to review. It is a solid HPG-quality contribution, with the main caveat that the abstract's 'guarantee' language should be scoped to the empirical setting or backed by a worst-case analysis.

Referee Report

2 major / 4 minor

Summary. The paper introduces collaborative texture filtering (CTF), a family of wave-intrinsic algorithms for magnified texture filtering. The three proposed methods—List Merge, Box Sampling, and Mask Sampling—coordinate the lanes of an 8x4 GPU wave so that each lane produces a unique texel and then gathers the 2x2 (or 4x4) texels needed for exact bilinear or bicubic filtering. When the union of required texels fits in the active lanes, filtering is exact with at most one texel evaluation per lane; otherwise, the system falls back to novel stochastic methods that the authors show improve on One-tap STF and Wave Communication STF. The paper reports perfect bilinear filtering for magnification factors above 1.59 (Mask Sampling/List Merge) or 2.35 (Box Sampling) on a head-on rotated quad, evaluates PSNR/FLIP/ColorVideoVDP quality and RTX 5090 runtimes, and demonstrates extensions to Catmull-Rom filters and to distributing expensive decompression work across lanes.

Significance. If the threshold claims hold, this is a significant practical advance: it would give exact magnified filtering for expensive texture formats at no more than one texel evaluation per pixel, eliminating the noise and flicker of stochastic texture filtering while retaining its cost advantage. The core algorithmic mechanism is constructive and sound under a clearly stated condition: when the wave-wide unique-texel set fits in the active lanes, every required texel is produced and gathered. The supplemental pseudocode is concrete and reproducible, the evaluation is careful and transparent about metrics and hardware, and the fallback methods are a useful contribution in their own right. The main weakness is that the generality of the 1.59/2.35 thresholds is asserted more strongly than the evidence supports.

major comments (2)

[Section 1 and Section 4.1, Fig. 4] The abstract and Section 1 state that zero-error bilinear filtering is guaranteed for magnification factors of at least 1.59 (Mask Sampling/List Merge) or 2.35 (Box Sampling) with 32-lane waves, but Figure 4 only measures a single scene: a quad viewed head-on, uniformly scaled, and rotated in the image plane. The number of unique texels required by an 8x4 wave is a function of the full screen-to-texel Jacobian (including perspective shear and anisotropy), the sub-texel phase offset of the wave, and the active-lane mask at silhouettes. None of these are bounded in the statement of the guarantee, and 'magnification factor' is never formally defined. Please define the term precisely (e.g., as a bound on the singular values of the texel-to-screen Jacobian) and either prove a worst-case upper bound on the unique-texel count for 8x4 waves under that condition, or explicitly restrict the guarantee to locally isotropic, full-wave magnification. As written, the headline claim is stronger than the evidence in Figure 4 supports, and the fallback paths described in Section 3.2 and Section S2 show that the method itself is conditional by design.
[Section 5, Discussion and Limitations] The statement 'We have verified experimentally that for a screen-aligned quad with magnification factor 1.0, the bilinear filter requires no more than 54 unique texels ... Hence, ≤2 texel evaluations are sufficient to always succeed' uses the word 'always' on the basis of a single configuration family (a rotated quad viewed head-on). This is load-bearing for the paper's claim that simple extensions achieve perfect filtering at magnification 1.0. To support this, the authors should either provide a proof over phases and Jacobians or report a broader parameter sweep that includes perspective, anisotropic scaling, and partial waves. If such a sweep is not possible within scope, the sentence should be rephrased as an experimental observation for the tested configurations.

minor comments (4)

[Supplement S1.1 and S1.2] In the pseudocode for both Box Sampling (line 22) and Mask Sampling (line 41), the condition 'if (curLaneIdx <= activeTexelsNeeded)' should likely be 'curLaneIdx < activeTexelsNeeded'. When activeTexelsNeeded is less than 32, the current condition selects one extra lane and may invoke the bijective mapping with an index outside the set of set bits; the prose in Section 3.3 correctly says 'If i < n, where i is the current lane's index'.
[Section 3.2, fourth paragraph] There is a typo: 'If the arean of the global bounding box' should read 'If the area of the global bounding box'.
[Section 4.1, Fig. 4 caption and surrounding text] The term 'magnification factor' appears in Figure 4, Figures 6 and 7, and throughout Section 4.1 without a formal definition. Adding one sentence defining it would substantially improve precision, especially given Major Comment 1.
[Section 5] The phrase 'occuring' in 'no more than 54 unique texels (occuring at, e.g., 30◦ rotation)' should be 'occurring'.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the zero-error property is constructive and the magnification thresholds are empirical characterizations, not fitted inputs or self-citation load-bearing claims.

full rationale

The paper's central claim is self-contained and constructive. In Sections 3.1-3.3, List Merge, Box Sampling, and Mask Sampling establish the zero-error property directly: each lane computes the texel coordinates needed for its filter footprint, the wave computes the union of those requirements, and if that union fits within the number of active lanes, every required texel is produced exactly once and gathered via wave intrinsics. Perfect filtering then follows by construction from weighting the complete 2x2 (or wider) footprint with the original filter weights; no parameter is fitted to the quality metrics and then renamed as a prediction. The magnification thresholds 1.59 and 2.35 are empirical measurements reported from the rotated-quad scene in Figure 4, characterizing when the required texel set fits in a 32-lane 8x4 wave; they are not derived from or identical to the inputs of the algorithm. Citations to PWSF24 and WPAM25 are used as baselines, historical context, and inspiration for wave communication, but the new algorithms do not rely on those papers' conclusions as load-bearing premises. No uniqueness theorem, prior ansatz, or fitted constant is imported to force the result. The main caveat, noted in the skeptical summary, is that the 1.59/2.35 threshold is demonstrated for a head-on quad and may not be worst-case over all sub-texel phases, anisotropic Jacobians, perspective shear, or silhouette active-lane masks; that is a correctness and generality concern, not a circularity concern.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The algorithms are constructive and rely on standard GPU wave semantics plus a spatial-coherence assumption. No free parameters are fitted to data; the magnification thresholds come from geometric analysis and experiments. No invented entities are introduced.

assumptions (4)

domain assumption Wave lanes execute as a spatially coherent 8x4 tile of pixels, so the wave-wide AABB or bitmask captures the collective filter footprint.
Section 3 states the assumption directly: 'we assume that each wave has 32 lanes and is configured as 8x4 pixels.' The zero-error guarantee depends on the wave covering a compact screen region.
domain assumption Wave intrinsics such as WaveActiveMin, WaveActiveMax, WaveActiveBitOr, and WaveReadLaneAt have their specified semantics for active and inactive lanes.
The algorithms use these intrinsics to compute bounding boxes, OR bitmasks, and gather texel values. The edge remapping in Section S2 partially handles inactive lanes, but still assumes the intrinsics return defined values.
domain assumption The texture filter has finite support, so its required texels form an enumerable set.
Section 5 explicitly notes the methods are inapplicable to infinite-support filters because the complete set of texels cannot be enumerated.
domain assumption A lane assigned to produce a texel can always decode it, and the decoded value is available for WaveReadLaneAt gathering.
This is the standard execution contract of wave intrinsics; the paper relies on it implicitly in the produce-and-gather steps of Box and Mask Sampling.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Collaborative Texture Filtering." pith.science (2026). https://pith.science/paper/2ILDUGIK

@misc{pith2026250617770,
  author       = {Pith},
  title        = {Pith review of: Collaborative Texture Filtering},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2ILDUGIK}},
  note         = {Machine review of arXiv:2506.17770}
}

read the original abstract

Recent advances in texture compression provide major improvements in compression ratios, but cannot use the GPU's texture units for decompression and filtering. This has led to the development of stochastic texture filtering (STF) techniques to avoid the high cost of multiple texel evaluations with such formats. Unfortunately, those methods can give undesirable visual appearance changes under magnification and may contain visible noise and flicker despite the use of spatiotemporal denoisers. Recent work substantially improves the quality of magnification filtering with STF by sharing decoded texel values between nearby pixels (Wronski 2025). Using GPU wave communication intrinsics, this sharing can be performed inside actively executing shaders without memory traffic overhead. We take this idea further and present novel algorithms that use wave communication between lanes to avoid repeated texel decompression prior to filtering. By distributing unique work across lanes, we can achieve zero-error filtering using <=1 texel evaluations per pixel given a sufficiently large magnification factor. For the remaining cases, we propose novel filtering fallback methods that also achieve higher quality than prior approaches.

Figures

Figures reproduced from arXiv: 2506.17770 by the authors.

**Figure 1.** During texture magnification, where previously only stochastic texture filtering (STF) was a viable option due to the expense of texel evaluation, our algorithms often produce zero-error results at negligible cost. We compare original One-tap STF [PWSF24] and Wave Communication STF [WPAM25] to our approach, both with and without DLSS [NVI25]. For this scene, one of our methods uses only 0.34 texel evaluations per pi… view at source ↗

**Figure 2.** High-level overviews of our three algorithms for the bilinear filtering case, shown with only four lanes (in gray) and where algorithm flow is downward. See our pseudocode in Section S1 for details of early outs to fallback methods. Shared memory is shown in yellow, while cross-wave operations are green. List Merge performs a hierarchical list merge on the 2×2 texel integer coordinates per lane. This gives a list of… view at source ↗

**Figure 3.** Illustration of our bijective function t = h(i,B) used in Mask Sampling. Assume the lane index i = 2, then h(2,B) = 4 since the bit number of the 2nd set bit is 4, as illustrated by the left arrow. Note that we start counting from 0, so the 0th set bit is at position 1 in the example above. To the right, we map from t = 4 to lane index i by counting the number of set bits to the right of t = 4. The result is 2, so h… view at source ↗

Figures from the paper (5 more)

**Figure 4.** Figure 4: Plot of magnification factors where our algorithms are unable to produce all texels necessary for perfect bilinear filtering and need to rely on fallback methods (Section 3.4). This magnification factor is a function of the rotation of the texel grid compared to the s…

**Figure 5.** Figure 5: Pareto frontier (dashed line) indicating the most quality/performance-efficient algorithm alternatives. The corresponding PSNR range for this plot was approximately 35–67 dB. 1.00 1.20 1.40 1.59 1.80 2.00 2.20 2.35 2.50 Magnification factor 9.4 9.5 9.6 9.7 9.8 9.9 10.…

**Figure 6.** Figure 6: Quality at different magnification factors. As indicated by [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 7.** Figure 7: Performance for an NVIDIA RTX 5090 under different levels of magnification. The numbers in parentheses show the algorithms’ average runtime costs. For reference, running at 60 FPS at 2560×1440 corresponds to 4741 µs/Mpixel, indicating that all methods consume a tiny f…

**Figure 8.** Figure 8: Visual comparison and error measurments with the bicubic B-spline and Catmull–Rom filters. All three error metrics indicate that our method achieves very high quality, both with and without denoising. For Catmull–Rom filters with negative weights, our method requires 0…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

24 extracted references · 22 canonical work pages

[1]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...
[3]

o ller T., Oskarsson M., str \

Andersson P., Nilsson J., Akenine - M \" o ller T., Oskarsson M., str \" o m K., Fairchild M. D. : : A Difference Evaluator for Alternating Images . Proceedings of the ACM on Computer Graphics and Interactive Techniques 3, 2 (2020), 15:1--23

work page 2020
[4]

: Spatiotemporal Reservoir Resampling for Real-Time Ray Tracing with Dynamic Direct Lighting

Bitterli B., Wyman C., Pharr M., Shirley P., Lefohn A., Jarosz W. : Spatiotemporal Reservoir Resampling for Real-Time Ray Tracing with Dynamic Direct Lighting . ACM Transactions on Graphics 39, 4 (July 2020). https://doi.org/10/gg8xc7 doi:10/gg8xc7

work page 2020
[5]

: Intel Co-Presents Cooperative Vectors with Microsoft

Dupuy J., Benyoub A., Belcour L., Merecki M., Chambon T. : Intel Co-Presents Cooperative Vectors with Microsoft . Game Developers Conference, 2025. [Online; accessed 2025-03-25]

work page 2025
[6]

: Neural Texture Block Compression

Fujieda S., Harada T. : Neural Texture Block Compression . In Workshop on Material Appearance Modeling (2024), Hardeberg J. Y., Rushmeier H., (Eds.), The Eurographics Association

work page 2024
[7]

: High Performance Post-Processing

Hoobler N. : High Performance Post-Processing . In Game Developers Conference (2011)

work page 2011
[8]

: High-Quality Temporal Supersampling

Karis B. : High-Quality Temporal Supersampling . Advances in Real-Time Rendering in Games, SIGGRAPH Courses 1, 10.1145 (2014), 2614028--2615455

work page 2014

Show all 24 references

[9]

: The falcor rendering framework

Kallweit S., Clarberg P., Kolb C., Davidovi c T., Yao K.-H., Foley T., He Y., Wu L., Chen L., Akenine - M \" o ller T., Wyman C., Crassin C., Benty N. : The falcor rendering framework. BSD-Licensed Github Repository, August 2022

2022
[10]

: A High-Performance Software Graphics Pipeline Architecture for the GPU

Kenzel M., Kerbl B., Schmalstieg D., Steinberger M. : A High-Performance Software Graphics Pipeline Architecture for the GPU . ACM Transactions on Graphics 37, 4 (2018), 1--15

2018
[11]

: NeuralVDB: High-Resolution Sparse Volume Representation Using Hierarchical Neural Networks

Kim D., Lee M., Museth K. : NeuralVDB: High-Resolution Sparse Volume Representation Using Hierarchical Neural Networks . ACM Transactions on Graphics 43, 2 (2024), 20:1--21

2024
[12]

E., Sengupta S., Owens J

Lefohn A. E., Sengupta S., Owens J. D. : Resolution-Matched Shadow Maps . ACM Transactions on Graphics 26, 4 (Oct. 2007), 20--37

2007
[13]

K., Hanji P., Ashraf M., Asano Y., Chapiro A

Mantiuk R. K., Hanji P., Ashraf M., Asano Y., Chapiro A. : ColorVideoVDP: A Visual Difference Predictor for Image, Video and Display Distortions . ACM Transactions on Graphics 43, 4 (2024), 129:1--20

2024
[14]

https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12, 2021

Microsoft : HLSL Shader Model 6.0 . https://learn.microsoft.com/en-us/windows/win32/direct3dhlsl/hlsl-shader-model-6-0-features-for-direct3d-12, 2021. [Online; accessed 2024-09-11]

2021
[15]

: Scalable Ambient Obscurance

McGuire M., Mara M., Luebke D. : Scalable Ambient Obscurance . In High Performance Graphics (2012), pp. 97--103

2012
[16]

https://research.nvidia.com/labs/adlr/DLSS4/, 2025

NVIDIA : DLSS 4: Transforming Real-Time Graphics with AI . https://research.nvidia.com/labs/adlr/DLSS4/, 2025. Technical Report

2025
[17]

: Clustered Deferred and Forward Shading

Olsson O., Billeter M., Assarsson U. : Clustered Deferred and Forward Shading . In High Performance Graphics (2012), pp. 87--96

2012
[18]

: Shader Amortization Using Pixel Quad Message Passing

Penner E. : Shader Amortization Using Pixel Quad Message Passing . In GPU Pro 2. CRC Press, 2011, pp. 349--366

2011
[19]

: Filtering After Shading with Stochastic Texture Filtering

Pharr M., Wronski B., Salvi M., Fajardo M. : Filtering After Shading with Stochastic Texture Filtering . Proceedings of the ACM on Computer Graphics and Interactive Techniques 7, 1 (2024), 14:1--20

2024
[20]

: Designing Efficient Sorting Algorithms for Manycore GPU s

Satish N., Harris M., Garland M. : Designing Efficient Sorting Algorithms for Manycore GPU s . In IEEE International Symposium on Parallel & Distributed Processing (2009), pp. 1--10

2009
[21]

J., Garland M., Owens J

Sengupta S., Harris M. J., Garland M., Owens J. D. : Efficient Parallel Scan Algorithms for Many-Core GPU s . In Scientific Computing with Multicore and Accelerators, Jakub Kurzak D. A. B., Dongarra J., (Eds.). 2011, pp. 413--442

2011
[22]

: Random-Access Neural Compression of Material Textures

Vaidyanathan K., Salvi M., Wronski B., Akenine - M \" o ller T., Ebelin P., Lefohn A. : Random-Access Neural Compression of Material Textures . ACM Transactions on Graphics 42, 4 (2023), 88:1--25

2023
[23]

: Improved Stochastic Texture Filtering Through Sample Reuse

Wronski B., Pharr M., Akenine-M\"oller T. : Improved Stochastic Texture Filtering Through Sample Reuse . Proceedings of the ACM on Computer Graphics and Interactive Techniques 8, 1 (2025). http://arxiv.org/abs/2504.05562 arXiv:2504.05562

2025 arXiv
[24]

: A Survey of Temporal Antialiasing Techniques

Yang L., Liu S., Salvi M. : A Survey of Temporal Antialiasing Techniques . Computer Graphics Forum 39, 2 (2020), 607--621

2020

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.

[1] [1]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

[3] [3]

o ller T., Oskarsson M., str \

Andersson P., Nilsson J., Akenine - M \" o ller T., Oskarsson M., str \" o m K., Fairchild M. D. : : A Difference Evaluator for Alternating Images . Proceedings of the ACM on Computer Graphics and Interactive Techniques 3, 2 (2020), 15:1--23

work page 2020

[4] [4]

: Spatiotemporal Reservoir Resampling for Real-Time Ray Tracing with Dynamic Direct Lighting

Bitterli B., Wyman C., Pharr M., Shirley P., Lefohn A., Jarosz W. : Spatiotemporal Reservoir Resampling for Real-Time Ray Tracing with Dynamic Direct Lighting . ACM Transactions on Graphics 39, 4 (July 2020). https://doi.org/10/gg8xc7 doi:10/gg8xc7

work page 2020

[5] [5]

: Intel Co-Presents Cooperative Vectors with Microsoft

Dupuy J., Benyoub A., Belcour L., Merecki M., Chambon T. : Intel Co-Presents Cooperative Vectors with Microsoft . Game Developers Conference, 2025. [Online; accessed 2025-03-25]

work page 2025

[6] [6]

: Neural Texture Block Compression

Fujieda S., Harada T. : Neural Texture Block Compression . In Workshop on Material Appearance Modeling (2024), Hardeberg J. Y., Rushmeier H., (Eds.), The Eurographics Association

work page 2024

[7] [7]

: High Performance Post-Processing

Hoobler N. : High Performance Post-Processing . In Game Developers Conference (2011)

work page 2011

[8] [8]

: High-Quality Temporal Supersampling

Karis B. : High-Quality Temporal Supersampling . Advances in Real-Time Rendering in Games, SIGGRAPH Courses 1, 10.1145 (2014), 2614028--2615455

work page 2014