pith. sign in

arxiv: 2605.16697 · v1 · pith:TSUVO2P2new · submitted 2026-05-15 · 💻 cs.GR · cs.CG

Ordered Front-to-back Any-Hit Traversal in RTX

Ingo Wald This is my paper

Pith reviewed 2026-05-19 20:40 UTC · model grok-4.3

classification 💻 cs.GR cs.CG
keywords ray tracingany-hit traversalfront-to-back orderingRTXintersection reportinggraphics pipelinehardware ray tracing
0
0 comments X

The pith

Multiple techniques enable ordered front-to-back any-hit traversal on existing RTX ray tracing hardware without skipping intersections.

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

The paper investigates how to achieve ordered front-to-back any-hit traversal, meaning rays report successive intersections in guaranteed front-to-back order and without omitting any hits even at identical distances. It describes and evaluates several different realizations that stay inside the constraints of current ray tracing pipelines such as RTX. A sympathetic reader would care because correct ordering and completeness matter for rendering effects that depend on processing hits sequentially, including transparency and multi-layer geometry.

Core claim

The author claims that ordered front-to-back any-hit traversal can be realized in multiple ways within the constraints of the existing ray tracing pipeline, and evaluates the different realizations for their ability to maintain guaranteed ordering and visit every intersection.

What carries the argument

Shader and traversal configuration techniques inside the ray tracing pipeline that enforce front-to-back hit reporting and prevent skipping of intersections at equal distances.

If this is right

  • Transparency and layered surfaces can be rendered by processing intersections in strict depth order.
  • All coincident intersections are reported, supporting accurate multi-hit handling without omissions.
  • Different realizations let developers trade implementation complexity against traversal cost in existing hardware.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same pipeline controls could be adapted to enforce ordering in other hardware ray tracers that expose similar hooks.
  • Production renderers might combine these methods with existing denoising passes to reduce visual artifacts from unordered hits.

Load-bearing premise

The existing ray tracing pipeline supplies enough control to enforce ordering and visit all intersections without skipping or violating hardware guarantees.

What would settle it

A scene containing overlapping surfaces that produce multiple intersections at the exact same distance along a ray, where one of the proposed methods reports the hits out of order or omits any of them.

Figures

Figures reproduced from arXiv: 2605.16697 by Ingo Wald.

Figure 1
Figure 1. Figure 1: Reference images for our test scenes; with pseudo-color visualization of total number of triangles visited along [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
read the original abstract

We look at the problem of Ordered Front-To-Back Any-Hit Traversal (FTB); i.e., a traversal that iterates through successive hits along a ray in a guaranteed front to back-sorted order, and without skip- ping any intersections even if they occur at the same distance. We describe multiple different ways of solving this problem within the constraints of the existing ray tracing pipeline, and evaluate the different realizations.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The paper addresses the problem of Ordered Front-To-Back Any-Hit Traversal (FTB) in the RTX ray tracing pipeline. It describes multiple algorithmic realizations that aim to report intersections in guaranteed front-to-back order without skipping any hits, including those occurring at identical distances, while remaining within the constraints of the existing hardware API. The different approaches are presented and compared through evaluations.

Significance. If the proposed realizations correctly guarantee the required ordering and completeness properties, the work would be a useful practical contribution to hardware-accelerated ray tracing. It could enable more reliable implementations of multi-hit queries and ordered transparency effects without falling back to software traversal. The evaluations of the different realizations provide concrete data on performance trade-offs that practitioners can use when selecting an approach.

major comments (2)
  1. [§4.1] §4.1 (Any-Hit Shader Realization): the description of the termination logic does not explicitly demonstrate how the implementation prevents premature termination via AcceptHitAndEndSearch (or equivalent) when multiple primitives share the same t-value. This directly affects the central claim that no intersections are skipped.
  2. [§5.3] §5.3 (Evaluation of Multi-Pass Method): the reported timings do not appear to include the cost of launching additional rays or resetting traversal state between passes; without this accounting, the performance comparison to single-pass methods cannot be used to support the claim that the approach is competitive.
minor comments (2)
  1. [§2] §2 (Background): the distinction between 'any-hit' and 'closest-hit' semantics is introduced without a reference to the relevant DXR/Vulkan specification sections, which would help readers unfamiliar with the exact hardware guarantees.
  2. [Figure 4] Figure 4: axis labels on the performance plot use inconsistent units (ms vs. normalized time); clarify the metric and add error bars if multiple runs were performed.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback on our manuscript. We address each major comment below and indicate the revisions we will make to strengthen the paper.

read point-by-point responses

  1. Referee: [§4.1] §4.1 (Any-Hit Shader Realization): the description of the termination logic does not explicitly demonstrate how the implementation prevents premature termination via AcceptHitAndEndSearch (or equivalent) when multiple primitives share the same t-value. This directly affects the central claim that no intersections are skipped.

    Authors: We agree that the termination logic in the any-hit shader realization requires a more explicit demonstration to fully support the no-skipping claim. The approach relies on the shader continuing to report hits at the current t-value without invoking termination until all co-located intersections have been processed, but the manuscript text does not walk through this case in sufficient detail. In the revised manuscript we will expand Section 4.1 with a step-by-step description of the shader logic (including pseudocode) that shows AcceptHitAndEndSearch is only reached after all hits sharing the same t have been reported. revision: yes

  2. Referee: [§5.3] §5.3 (Evaluation of Multi-Pass Method): the reported timings do not appear to include the cost of launching additional rays or resetting traversal state between passes; without this accounting, the performance comparison to single-pass methods cannot be used to support the claim that the approach is competitive.

    Authors: This observation is correct; the original timings focused on per-pass traversal but did not explicitly fold in the overhead of additional ray launches and state resets. We have re-run the experiments to capture these costs and will update the tables and discussion in Section 5.3 accordingly. The revised numbers still indicate competitiveness in several tested scenes, although the margins are narrower than previously reported. revision: yes

Circularity Check

0 steps flagged

No circularity: algorithmic realizations proposed and evaluated without derivation from self-inputs

full rationale

The paper describes multiple ways to implement ordered front-to-back any-hit traversal inside the existing RTX ray tracing pipeline and evaluates the realizations. No equations, fitted parameters, or mathematical derivations are present. No self-citations are used as load-bearing justification for a uniqueness theorem or ansatz. The central contribution is a set of concrete implementation strategies whose correctness is assessed by direct evaluation rather than by reducing to prior self-referential results. This is a standard self-contained systems/algorithms paper.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 0 invented entities

The paper rests on the domain assumption that current ray tracing hardware pipelines can be adapted for ordered traversal; no free parameters or new invented entities are indicated in the abstract.

axioms (1)
  • domain assumption Existing ray tracing pipeline constraints allow implementation of ordered any-hit traversal
    All proposed solutions must operate inside the limits of current hardware such as RTX without skipping intersections.

pith-pipeline@v0.9.0 · 5578 in / 1204 out tokens · 27730 ms · 2026-05-19T20:40:47.070599+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

18 extracted references · 18 canonical work pages

  1. [1]

    Gribble, Johannes Guenther, and Ingo Wald

    Jefferson Amstutz, Christiaan P. Gribble, Johannes Guenther, and Ingo Wald

    work page

  2. [2]

    An Evaluation of Multi-Hit Ray Traversal in a BVH Using Existing First-Hit / Any-Hit Kernels.Journal of Computer Graphics Techniques4, 4 (2015)

    work page 2015

  3. [3]

    Apple. 2026. Metal Shading Language Specification - Version 4. https://developer.apple.com/metal/Metal-Shading-Language-Specification.pdf

    work page 2026

  4. [4]

    Butler and Abe Stephens

    Lee A. Butler and Abe Stephens. 2007. Bullet Ray Vision. InProceedings of the 2007 IEEE Symposium on Interactive Ray Tracing

    work page 2007

  5. [5]

    Christiaan Gribble, Alexis Naveros, and Ethan Kerzner. 2014. Multi-Hit Ray Traversal.Journal of Computer Graphics Techniques (JCGT)3, 1 (2014)

    work page 2014

  6. [6]

    Christiaan P. Gribble. 2016. Node Culling Multi-Hit BVH Traversal. InEurograph- ics Symposium on Rendering

    work page 2016

  7. [7]

    Gribble, Ingo Wald, and Jefferson Amstutz

    Christiaan P. Gribble, Ingo Wald, and Jefferson Amstutz. 2016. Implementing Node Culling Multi-Hit BVH Traversal in Embree.Journal of Computer Graphics Techniques5, 4 (2016)

    work page 2016

  8. [8]

    Khronos Group. 2021. Vulkan Ray Tracing Final Specification Release. https: //www.khronos.org/blog/vulkan-ray-tracing-final-specification-release

    work page 2021

  9. [9]

    Johnson, and Johannes Meng

    Aaron Knoll, Gregory P. Johnson, and Johannes Meng. 2021. Path Tracing RBF Particle Volumes. InRay Tracing Gems II: Next Generation Real-Time Rendering with DXR, Vulkan, and OptiX, Adam Marrs, Peter Shirley, and Ingo Wald (Eds.). https://doi.org/10.1007/978-1-4842-7185-8_44

    work page doi:10.1007/978-1-4842-7185-8_44 2021

  10. [10]

    Daniel Meister, Paritosh Kulkarni, Aaryaman Vasishta, and Takahiro Harada

    work page

  11. [11]

    HIPRT: A Ray Tracing Framework in HIP.Procedings of the ACM on Computer Graphics and Interactive Techniques7, 3 (2024)

    work page 2024

  12. [12]

    DirectX Raytracing (DXR) Functional Spec

    Microsoft 2021. DirectX Raytracing (DXR) Functional Spec. https://microsoft. github.io/DirectX-Specs/d3d/Raytracing.html Version v1.15 3/26/2021

    work page 2021

  13. [13]

    Nicolas Moenne-Loccoz, Ashkan Mirzaei, Or Perel, Riccardo de Lutio, Janick Martinez Esturo, Gavriel State, Sanja Fidler, Nicholas Sharp, and Zan Gojcic. 2024. 3D Gaussian Ray Tracing: Fast Tracing of Particle Scenes.ACM Trans. Graph.43, 6 (2024)

    work page 2024

  14. [14]

    OWL – The Optix 7 Wrapper Library

    NVIDIA Corp 2026. OWL – The Optix 7 Wrapper Library. Available at https://github.com/NVIDIA/owl, Last accessed Feb 25, 2026

    work page 2026

  15. [15]

    NVIDIA Corporation. 2026. NVIDIA OptiX Ray Tracing Engine. Available at https://developer.nvidia.com/optix, Lasta accessed: Feb 27 2026

    work page 2026

  16. [16]

    Ingo Wald, Jefferson Amstutz, and Carsten Benthin. 2018. Robust Iterative Find- Next-Hit Ray Traversal. InProceedings of the Symposium on Parallel Graphics and Visualization

    work page 2018

  17. [17]

    Johnson, and Manfred Ernst

    Ingo Wald, Sven Woop, Carsten Benthin, Gregory S. Johnson, and Manfred Ernst. 2014. Embree: A Kernel Framework for Efficient CPU Ray Tracing.ACM Transactions on Graphics(2014)

    work page 2014

  18. [18]

    Stefan Zellmann, Mauritius Hoevels, and Ulrich Lang. 2017. Ray Traced Volume Clipping Using Multi-Hit BVH Traversal. InVisualization and Data Analysis

    work page 2017