Papers for

graphics engine developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Neural texture compression improves image quality with anisotropic filtering

Explicit LOD-Conditioned Anisotropic Filtering for Neural Texture Compression

Abstract: Neural texture compression (NTC) stores material textures compactly, but the dominant feature-pyramid design receives no filtering from the GPU texture unit: it learns each material at a fixed UV and level of detail and has no explicit anisotropic-filtering (AF) mechanism. Setting the filter from the footprint aspect ratio alone is not enough: a single input cannot carry both the shape of the footprint and its size, so the image is too blurry near the camera by the same amount at every distance. Our method, AF-NTC, instead conditions the decoder on the same three bounded values a hardware sampler uses: minor-axis scale (LOD), aspect ratio, and major-axis orientation. These drive a tap line along the major axis and a level blend across the minor axis, and we train against anisotropically filtered ground truth. At $25\%$ of a full BC7 mip chain, AF-NTC beats the no-AF trilinear-BC7 baseline on all ten material--scene pairs we compare ($+1.3$ to $+7.6$\,dB), and it is $0.0$ to $3.4$\,dB below the $4\times$-larger anisotropic-BC7, depending on the material.

Mon 9 NovGraphics
The gist
Neural texture compression saves space when storing material images but usually treats every detail the same, causing blurry images near the camera. The authors created a way to teach the system to understand how images look from different angles and distances by using three geometric values that hardware also uses. Their method, called AF-NTC, creates sharper textures at much smaller sizes compared to standard methods. This technique improves visual details without needing large amounts of storage.
Open → 2611.12650v1

Ray-by-Ray improves GPU ray tracing performance with fine-grained control

Ray-by-Ray: Fine-Grained Resource Management for GPU Ray Tracing Units

Abstract: Ray tracing (RT) generates photorealistic images by simulating the physical behavior of light as it interacts with surfaces in a virtual scene. In film production and high-end rendering pipelines, this technique computes global illumination, reflections, refractions, and soft shadows by tracing millions of light rays per frame and accurately modeling their bounces and attenuation. Contemporary GPUs incorporate specialized ray tracing hardware to accelerate key operations in the traversal pipeline. By accelerating these stages in hardware, the unit enables real-time ray tracing for complex scenes that previously required offline computation. However, ray tracing introduces substantial control and data divergence. Each ray may traverse a different set of nodes in the acceleration structure, encounter distinct materials, or terminate at varying depths. This irregularity reduces thread coherence and exposes a fundamental disparity between the GPU SIMT and per-thread execution model of dedicated RT units, where each ray progresses independently. In this work, we seek to validate assumptions made in open-source infrastructure and identify potential inefficiencies in resource management within the ray tracing pipeline. To address inefficiency caused by mismatches between SIMT and RT granularities, we propose Ray-by-Ray, which decomposes on-chip buffers into the granularity of individual rays and introduces lightweight management structures that enable more warps to run in parallel without increasing buffer capacity. This approach improves ray tracing unit utilization and increases memory-level parallelism. Experimental results show that Ray-by-Ray achieves an average performance improvement of 1.91x over the baseline, with an area overhead of 0.19\%.

Thu 22 OctHardware Architecture
The gist
Rendering realistic images with ray tracing on GPUs can be slow because each light ray behaves differently, making it hard for hardware to handle many rays efficiently at once. The researchers found that current GPU designs waste resources due to this mismatch between how rays are processed and how hardware threads work together. They created Ray-by-Ray, a way to manage each ray individually to better share the hardware, improving speed without needing bigger memory buffers. Their tests showed this approach nearly doubles performance with very little extra hardware cost.
Open → 2610.31630v1

New faster method multiplies 3 by 3 matrices using fewer additions

A 55-Addition Rank-23 Scheme for $3\times3$ Matrix Multiplication via Exact Two-Sided Minimization

Abstract: We give a scheme that multiplies two $3\times3$ matrices with 23 multiplications and 55 additions over any ring, one addition below the previous record of 56 (Sun, 2026) and the first below 56 for exact non-commutative $3\times3$ multiplication without a change of basis. The scheme forms 13 signed combinations of the entries of A and 14 of B, takes 23 products, and recombines them with 28 further additions; its correctness is machine-checked in Lean 4. The previous records, from 60 down to 56, were obtained by greedy common-subexpression elimination, which only bounds each side of a scheme from above. We minimize both input sides exactly by chain covering, and the output side exactly through the transposition principle: the 9-by-23 output map costs its transpose plus 14, and the transpose is a 9-input map that the input-side minimizer solves exactly. Applied to Perminov's cn122 scheme (class i19w225c4efh, published at 58 additions) this gives 55 = 13 + 14 + 28, where greedy elimination reaches only 29 on the output side. The same method shows that Sun's representative is output-optimal at 56, and an exact orbit-wide computation over the Heule-Kauers-Seidl database shows that the record class is the only database class attaining 55.

Tue 20 OctMathematical SoftwareComputational ComplexityData Structures and Algorithms
The gist
Multiplying two 3×3 matrices usually takes many steps. The authors found a way to do it with one less addition operation than the previous best method, making the process slightly more efficient. Their approach uses exact math techniques and even verified the method using a computer proof checker. This means computers can multiply matrices a bit faster without changing how the data is arranged.
Open → 2610.27451v1

Appearance changes can hide errors in volume density rendering

Appearance Compensation in Volume Rendering

Abstract: Can a volume that reproduces every external RGB view still have an incorrect density? We study this question in emission-absorption rendering with an independently parameterized, physically bounded effective source. Appearance compensates a density change by replacing the radiance that it removes from the rest of each ray. We characterize the surviving density information with a shared spatial appearance field. Our first result is an optimal density-only gain after finite-degree spherical-harmonic source refitting. A coupled tensor gauge and physical localized packets identify the sharp limiting nonlinear inverse coefficient as its reciprocal. Our second result realizes positive gain at every fixed finite degree for a residual set of isotropic spatial sources at one fixed density. At the same references, growing angular capacity hides a fixed nonzero density error while retaining physicality and any prescribed finite set of smoothness bounds. Local identifiability and the absence of a capacity-uniform recovery modulus therefore coexist. Our third result constructs an exact physical SH2 ambiguity: central density doubles and relative density $L^2$ error exceeds $14.52\%$, yet every external RGB ray is unchanged. We connect these continuum results to shared finite representations, continuous pixel measurements and density-sensitive acquisition. Complete-class certificates separate SH0, SH1 and SH2 fits at one learned density. Finite-camera results expose the distinct role of spatial capacity, and transmission measurements separate otherwise identical RGB fields. Controlled training tests and captured-smoke profiles supply mechanism evidence with explicit observation scopes. The results show why rendering accuracy alone cannot certify density: recovery also depends on appearance capacity, spatial resolution and measurement design.

Sat 10 OctComputer Vision and Pattern Recognition
The gist
The paper explores how 3D volumes that look correct from outside can still have wrong density inside. The authors show that changes in appearance can cover up these density errors without changing what is seen in external images. They mathematically prove that certain errors in density can remain invisible despite rendering multiple views. This means that accurately matching rendered images alone doesn’t guarantee knowing the true internal density of a volume.
Open → 2610.15030v1

Hybrid ray tracing method speeds up 3D Gaussian rendering up to nine times

A Hybrid and Hierarchical Ray Tracing Method for Efficient 3D Gaussian Rendering

Abstract: 3D Gaussian Splatting (3DGS) is a powerful representation for real-time neural reconstruction and rendering. While existing 3DGS systems rely on rasterization for efficiency, recent work explores ray tracing to enable secondary lighting, highly distorted cameras, and depth-of-field effects. However, compared with rasterization, ray-traced 3DGS introduces three major challenges: (1) the highly non-uniform spatial distribution of massive numbers of Gaussian primitives creates severe load imbalance; (2) neighboring pixels often generate rays with highly similar traversal paths, leading to substantial redundant traversal overhead; and (3) supporting both Gaussian and triangle primitives yields heterogeneous intersection workloads that are not well matched to existing GPU architectures. We present H2-Ray, a hybrid and hierarchical ray tracing architecture for efficient 3D Gaussian rendering. H2-Ray introduces three techniques. Load-Balanced Spatial BVH (LB-SBVH) partitions the scene into uniform grids and uses density-aware representations to convert an imbalanced global workload into balanced local traversal units. Ray-Cluster Path Reuse (RCPR) lets a proxy ray share traversal state with neighboring rays to amortize redundant traversal. The Unified Intersection Engine (UIE) supports mixed Gaussian and triangle intersections through a mode-multiplexed datapath that shares 40% of its floating-point units across both primitive types. Across 8 scenes, H2-Ray achieves a geometric-mean speedup of 3.77x and a maximum speedup of 9.26x over RaySplats on the NVIDIA RTX A5000, combining a cycle-accurate model of the modified RT Core with measured CUDA timings.

Fri 9 OctHardware ArchitectureGraphics
The gist
Rendering 3D images using many tiny Gaussian shapes can be slow and unevenly balanced for computers. The authors developed a new method called H2-Ray that organizes these shapes to balance the work better, lets nearby pixels share parts of their calculations, and efficiently handles different shape types together. This approach gives a big speed boost during rendering while keeping details like special lighting and blurring effects.
Open → 2610.13498v1

WarpDRF clarifies safe warp-level programming on GPUs

WarpDRF: Data-Race Freedom for Warp-Level Programming

Abstract: Warp primitives such as tensor core operations, shuffles, reductions, and barriers are critical to high-performance GPU kernels, and every major GPU language supports some set of them. The threads that participate in a primitive, and therefore synchronize, are determined dynamically by how threads diverge and reconverge, and by intra-warp scheduling such as independent thread scheduling. In practice, many high-performance kernels use these primitives and behave as expected, following an intuitive but unwritten data-race-freedom contract that has never been stated precisely or empirically tested. We present WarpDRF, the first abstract warp programming model to make this contract precise, with participation rules parameterized by reconvergence guarantees and per-primitive requirements so that instantiations match different GPU languages. We prove (formalized in Rocq) that a kernel satisfying WarpDRF executes every warp primitive with the participants the reference semantics assigns and produces the same results, so a programmer can reason in the reference semantics alone. We implement the model in MLIR with a reference interpreter and fuzz 10K conformance tests for each of three configurations across CUDA, HIP, HLSL, Metal, and SPIR-V on 16 device and backend pairs; at least one WarpDRF configuration describes each, with CUDA honoring the strictly weakest configuration. Finally, we extend Faial, a static data-race analyzer for CUDA, into the first DRF checker for an empirically validated warp model, and apply it to llama.cpp, where most kernels that use warp primitives already satisfy the contract, but three contain previously unknown data races, showing the need for tools that check it.

Tue 6 OctProgramming Languages
The gist
Modern graphics processors run many threads in groups called warps that work closely together using special commands. These commands rely on threads cooperating without causing data conflicts, but the exact rules for this are complicated and weren't clearly defined before. The authors created WarpDRF, a precise way to describe when these threads can safely share data and synchronize. They tested this with real GPU languages and built tools that find programming errors in GPU code using these warp commands. This helps programmers write faster and more reliable GPU programs.
Open → 2610.07541v1

Neural fields learn faster with smarter region sampling techniques

Efficient Neural Field Learning via Adaptive Coverage and Focused Sampling

Abstract: Implicit neural representations (INRs) provide a flexible framework for modeling high-dimensional continuous fields, but their training is often inefficient due to uniform subsampling that ignores spatial heterogeneity. Existing adaptive sampling methods partially address this issue by prioritizing high-error samples, but typically operate at the point level, often leading to redundant sampling in localized regions and insufficient coverage of the domain. We propose ACES (Adaptive Coverage-aware Efficient Sampling), a structured sampling framework that improves training efficiency by decoupling coverage and importance. ACES constructs adaptive spatial partitions to ensure domain coverage and reduce redundancy, and applies region-level importance weighting to prioritize informative regions during training. We provide a theoretical analysis showing that adaptive partitioning reduces gradient variance by increasing within-region homogeneity, and that controlled bias in region-level weighting may improve optimization efficiency relative to standard unbiased estimators. Experiments on scientific field learning tasks demonstrate that ACES achieves faster convergence and lower error than uniform and pointwise adaptive sampling baselines, with the largest gains in fields with highly localized complexity.

Thu 1 OctMachine LearningArtificial Intelligence
The gist
Training neural networks to represent complex continuous data like scientific fields can be slow because typical methods sample points evenly across space, missing areas that need more attention. The authors propose ACES, a method that divides the space into adaptive regions and focuses learning on important ones while still covering the whole area. This approach reduces redundant samples in simple regions and better targets complex parts, speeding up training and improving accuracy. Their experiments show ACES works best when the data has areas of localized complexity.
Open → 2610.02410v1

FactorSplat enables flexible color control in medical volume images

FactorSplat: Appearance-Controllable Gaussian Proxies for Medical Volume Rendering

Abstract: Transfer functions (TFs) control color and visibility in medical volume rendering, but image-trained Gaussian proxies typically bake one transfer function into their appearance. We present FactorSplat, a per-scene N-dimensional Gaussian splatting (N-DGS) proxy that accepts region-specific intensity-to-RGBA curves at inference. A local lookup applies the authored color and opacity change, while a shared functional encoder and low-rank per-Gaussian factors learn the residual appearance response. Geometry and directional appearance remain shared across presets, with visibility control and TF-aware pruning preserving the ability to hide and reveal structures. On seven CT and MR scans, FactorSplat improves mean PSNR and changed-region error over region-aware VEG across validation, interpolation, unseen composition, and out-of-distribution (OOD) edits. Across these four splits, seven-scan mean PSNR gains over VEG range from 1.10 to 1.52 dB. One checkpoint per scan supports unseen edits without retraining. At $1600^2$, the cached fast renderer averages 524 FPS with 1.17 ms TF switches. Project page: https://gaozhongpai.github.io/FactorSplat/.

Thu 1 OctComputer Vision and Pattern Recognition
The gist
Medical volume images show detailed views of the inside of the body, but it can be hard to change colors and visibility of different areas quickly. The authors developed FactorSplat, a method that lets you control colors and transparency on the fly for specific regions in CT and MRI scans. This method keeps the shape and shading consistent while allowing different color settings without retraining the model. It delivers better image quality and fast rendering, making it easier to explore medical scans with different appearances.
Open → 2610.02382v1

Payne-hanek range reduction method made faster and more accurate

A performance enhancement of the Payne-Hanek range reduction algorithm

Abstract: Range reduction plays a crucial role in the accuracy and performance of evaluating trigonometric functions, and is often the primary bottleneck for large floating-point inputs. While fast algorithms such as Cody--Waite work efficiently over narrow intervals, the Payne--Hanek algorithm remains the standard technique for accurate reduction across large floating-point inputs. However, existing implementations of Payne--Hanek suffer from high latency due to heavy branching, conversion overheads, and the use of multi-word integer arithmetic, which hinders SIMD vectorization. In this paper, we analyze and present a branch-free variation of the Payne--Hanek algorithm using only floating-point arithmetic. Our method operates directly over large double-precision inputs ($|x| \ge 2^{16}$) and is well suited to hardware with FMA instructions. We formulate the precision constraints in terms of a truncation error budget, construct a compact lookup table indexed by the input exponent, and prove that the reduced argument is accurate to within one ulp for every input. The same routine can serve both as the complete range reduction of a single-stage implementation and as the fast path of a correctly rounded one, and it improves both latency and throughput over existing implementations. The algorithm is currently implemented in the LLVM libc project.

Mon 28 SeptMathematical Software
The gist
When computers calculate sine or cosine for very large numbers, they first simplify the number through a process called range reduction. This step can be slow and complicated, especially for big numbers. The authors improved an existing method called Payne-Hanek by removing slow parts like branching and complex integer math, relying only on fast floating-point math instead. Their new approach works efficiently on large inputs and keeps answers very accurate, making trigonometric calculations faster.
Open → 2609.35015v1

Omnidirectional image compression boosts virtual reality rendering speed and quality

Rate-Distortion Adaptive Primitive Selection for Omnidirectional Gaussian Splatting

Abstract: Learned image codecs (LICs) achieve high reconstruction quality, but their decoding speed is often insufficient for immersive virtual reality (VR). Gaussian splatting (GS) codecs render much faster, yet still lag in reconstruction quality and typically decide primitive allocation without considering the coding cost of each primitive. We introduce OIC-GS, an omnidirectional GS codec with a new hierarchical HEALPix primitive grid representation. Gaussian primitives are anchored at predefined spherical locations, eliminating explicit coordinate coding. Finer levels refine their coarser ancestors, naturally supporting coarse-to-fine reconstruction and layered transmission. The predefined grid also enables efficient viewport decoding by selecting only view-relevant primitives. We further introduce a lightweight entropy model for quantized primitives and optimize the codec under a spherical rate-distortion objective. Primitives with insufficient rate-distortion benefit are automatically removed when their quantized opacity becomes zero, allowing OIC-GS to adapt both primitive density and level of detail without a fixed primitive budget. A single bitstream supports full-sphere, viewport-dependent, and progressive decoding. The first viewport reaches final quality after decoding only 52% of the bitstream, and is then rendered at 1,270 FPS. On a 100-image omnidirectional benchmark, OIC-GS outperforms all evaluated GS codecs, reducing WS-PSNR BD-rate by 49.6% over GaussianImage++ and 68.6% over SGI, which uses a learned entropy model.

Mon 28 SeptComputer Vision and Pattern Recognition
The gist
Virtual reality needs very fast and good-quality images so users feel immersed, but current methods often force a trade-off between speed and image quality. The authors created a new way to represent these images using Gaussian dots arranged on a special sphere grid, which makes encoding more efficient and lets the system focus on the part of the image the user is looking at. Their method adapts by removing less useful dots automatically to keep the data size small, all while supporting smooth and fast loading of images. This approach shows better image quality and much faster rendering compared to previous methods in tests.
Open → 2609.34367v1

ControlGS improves extended reality image quality by adapting rendering

ControlGS: Conditioning Neural Gaussians for Downstream-Processing-Aware XR Rendering

Abstract: Extended Reality (XR) users do not directly perceive the output of a rendering engine. Instead, rendered images pass through a post-processing pipeline and the physical display-optics path before reaching the eye. Critically, the exact downstream processing can vary significantly at run time, influenced by, for instance, camera pose and display power budget. Traditional 3DGS methods either implicitly assume that this downstream pipeline preserves image quality or cannot adapt to downstream processing changes. To bridge this gap, we present ControlGS, an XR Gaussian rendering pipeline that optimizes end-to-end visual quality. ControlGS models and integrates the entire downstream processing, between the rendering output and the human eye, into the optimization objective. To adapt to downstream processing at run time, ControlGS dynamically generates Gaussian primitives conditioned upon the downstream processing parameters. Experiments show that ControlGS consistently improves end-to-end post-optics XR quality across different neural Gaussian backbones and datasets, with minimal overhead. Code is available at https://horizon-lab.org/controlgs/.

Fri 25 SeptComputer Vision and Pattern RecognitionGraphics
The gist
Images created for virtual or augmented reality go through many changes before you actually see them, like adjustments from your device and display. The way these changes happen can vary a lot depending on things like where you are looking or how much power your device uses. The authors created ControlGS, a method that adjusts the image-making process by taking these changes into account ahead of time, making the final images look better to the user. Their experiments show that ControlGS works well across various setups with little extra cost.
Open → 2609.32038v1