Image credit: Image provided by Jon Peddie Research
This article was contributed by Jon Peddie of Jon Peddie Research.
Cages, neural stages, and coding agents converge.
Real-time graphics keeps getting more capable without waiting for bigger GPUs. AMD wraps animated foliage in lightweight tetrahedral cages and renders 500 million moving triangles at more than 60 fps with 47 times less BVH memory. NVIDIA folds neural texture, shading, geometry, and rendering stages into the RTX pipeline. A developer also had Claude Opus 5.5 write a dual-GPU path tracer in about an hour.
Cages Cut BVH Cost
Real-time ray tracing asks the GPU to find which surfaces a ray might hit. A bounding volume hierarchy (BVH) organizes the geometry so that search runs efficiently, and a renderer builds the BVH for static geometry once and reuses it across frames. Animation adds work. When thousands of objects deform independently, their vertex positions change every frame, and a conventional renderer must maintain acceleration-structure state for each changing mesh. That upkeep consumes memory capacity, bandwidth, and GPU time.
AMD Fellow Holger Gruen published a fix on GPUOpen on 17 September. His system encloses dense geometry in a simple deformable structure of tetrahedra. The cage moves, and the high-resolution mesh and its BVH stay static and reusable. During traversal, the system transforms each ray back into the geometry’s original reference frame and tests it against the dense triangle set. Animation cost therefore scales with cage complexity, independent of the triangle count inside the cage.
Figure 1. Tetrahedral cages deform; dense meshes and their BVHs stay static. (Source: AMD)
Gruen demonstrated the technique on a terrain scene with about 25,000 independently animated plants, each responding to a wind-field simulation with locally varying directions. At full level of detail (LOD), the vegetation holds about 2.8 billion triangles. After LOD selection, the GPU ray-traces about 500 million animated triangles per frame, using primary and shadow rays, at more than 60 fps at 1080p on one Radeon RX 9070 XT.
| Rendering metric | Conventional BVH | Tetrahedral cage |
| Active triangles tested | 500 million | 500 million |
| BVH memory | Up to 80 GB | ~1.7 GB |
| BVH update time | 300+ ms | ~3.3 ms |
| Test GPU | Radeon RX 9070 XT | Radeon RX 9070 XT |
Table 1. AMD’s independently animated foliage demonstration on the Radeon RX 9070 XT. (Source: AMD GPUOpen)
Those figures work out to about 47 times less BVH memory and a ninetyfold cut in BVH update time. An 80 GB acceleration structure exceeds the memory of any gaming GPU, and 1.7 GB fits on a consumer card with room to spare. The savings also free bandwidth. Every gigabyte the GPU moves for acceleration-structure upkeep competes with shading, geometry processing, ray traversal, and AI inference for the same frame budget.
Figure 2. 80 GB and 300 ms become 1.7 GB and 3.3 ms per frame.(Source: JPR)
The technique suits forests, grasslands, crowds, and distant characters. A tree can contain hundreds of thousands of triangles, and its cage holds a small fraction of that geometry. Cages give up per-vertex control, so facial animation, complex cloth, and changing topology still need conventional deformation and BVHs.
Silicon designers should note the split between dynamic and static data. Faster RT hardware accelerates traversal and intersection, and AMD’s technique removes work before it reaches those units. That gives algorithm designers a route to higher effective performance that demands no proportional increase in compute or VRAM.
AMD has not turned tetrahedral cages into a Radeon feature. The paper, “Ray Tracing Massive Amounts of Animated Geometry”, took third place in the Wolfgang Straßer paper awards at High-Performance Graphics (HPG) 2026. AMD says it is developing DXR samples and a header-only C++ library that builds cages for skinned, keyframe-animated, and static objects. ISVs will need that code, plus measurements of cage-construction cost, deformation quality, and ray-transformation overhead.
Visualization, simulation, and digital-twin applications face the same problem whenever many objects move independently. For CIOs, the research shows that visual complexity does not have to push memory capacity and bandwidth up at the same rate.
Neural Stages Enter the Pipeline
NVIDIA works the same frame budget with RTX Kit 2026.3, RTX Mega Geometry 2.0, and DLSS 5, and it extends several components to Windows Arm64.
Neural Texture Compression 0.10 beta supports Microsoft’s DirectX 12 Agility SDK preview with Linear Algebra, so developers can run neural texture decompression on RTX Tensor Cores inside DirectX shaders. RTX Neural Shading 1.4 adopts the same toolchain. That integration makes neural processing another programmable graphics resource, and ISVs no longer need a separate software path for it.
| Component | Update | Developer relevance |
| RTX Mega Geometry 2.0 | Continuous LOD-cluster streaming for dense geometry | Keeps more high-detail geometry available to ray-traced effects |
| RTX Neural Texture Compression 0.10 beta | DirectX 12 Linear Algebra preview support | Uses Tensor Cores for neural texture decompression in DirectX shaders |
| RTX Neural Shading 1.4 | Updated DirectX Linear Algebra toolchain | Supports neural work inside shader workflows |
| RTX Texture Filtering 1.3 | Collaborative Texture Filtering | Targets magnification quality for stochastic texture filtering |
| RTX Character Rendering 1.4 | Better far-field hair BCSDF sampling and energy conservation | Improves strand-based character rendering across distance and lighting |
| RTX Dynamic Illumination 3.1 | DLSS Ray Reconstruction and ReSTIR PT updates | Supports real-time path-traced illumination workflows |
| DLSS 5 | 3D-Guided Neural Rendering with masks and controls | Adds a developer-directed neural stage after engine rendering |
Table 2. RTX Kit 2026.3 components. Tool availability, performance, and integration options vary by SDK release, GPU family, engine, and game configuration. (Source: NVIDIA developer and product materials)
Mega Geometry 2.0 streams continuous LOD clusters for dense meshes, and NVIDIA showed it in a revised Zorah demo with textured glTF assets. The target application is Unreal Engine 5 Nanite, which lets developers fill scenes with dense terrain, foliage, and buildings and automatically manages visible detail. Current DXR 1.2 and Vulkan implementations cannot economically ray-trace full Nanite geometry, so games substitute a simpler static proxy mesh for ray tracing. The rasterized object then carries far more geometry than its ray-traced proxy, and that mismatch produces inaccurate reflections, shadow errors, and flicker. Mega Geometry lets ray tracing keep more of Nanite’s detail. NVIDIA says the work will contribute to Microsoft’s DirectX Raytracing 2.0 standard, and “Gears of War: E-Day” will combine Mega Geometry with Nanite in a shipping title.
Figure 2. Streamed LOD clusters and neural stages feed one RTX pipeline. (Source: JPR)
DLSS 5 adds 3D-Guided Neural Rendering as a final stage. The engine supplies the rendered frame, geometry, textures, lighting, color, and motion vectors, and NVIDIA’s model refines the image from those inputs. Developers pick models per scene, adjust structure and tone intensity, and apply semantic or engine-level masks that confine neural processing to chosen objects and materials. The one-frame-in, one-frame-out design uses motion vectors for temporal stability, and the compact model runs locally on GeForce RTX 50 Series GPUs at up to 4K. In “NBA 2K27”, Visual Concepts uses DLSS 5 to improve skin subsurface scattering, light transmission through hair and ears, and contact shadows on scanned facial geometry.
Rendering leads and CIOs who plan visual computing for virtual production, engineering simulation, and digital twins should budget for Tensor Core throughput, VRAM capacity, driver stability, and asset-pipeline integration alongside raw raster frame rates.
AI Writes the Renderer
A developer posting on Reddit as Zealousideal_View_12 asked Anthropic’s Claude Opus 5.5 to build a hardware-accelerated ray tracer for two RTX 5090 GPUs. According to the account, Claude generated a C++ and CUDA codebase on NVIDIA OptiX 9.1 in about an hour. The renderer splits each frame horizontally across the two GPUs, balances load dynamically, handles host-device synchronization, and reportedly reached 34 fps at 267 million ray samples per second. The code uses Shader Execution Reordering, Next-Event Estimation, and Multiple Importance Sampling.
The experiment demonstrates how fast a coding agent can wire existing APIs, hardware features, and algorithms into working software. Production engines demand maintainability, validation, debugging, and security work, and a one-hour build tells us nothing about those.
Figure 3. AI now refines pixels and writes the code behind them. (Source: JPR)
Where the Pieces Meet
These developments share one theme: Each buys back frame budget or engineering time without waiting for bigger silicon. AMD’s cages decouple visible geometric complexity from animation cost. NVIDIA turns Tensor Cores into a shader resource and pushes ray-traced detail toward Nanite parity. Coding agents compress the work of assembling those pieces, so an ISV could soon describe a rendering goal, let an agent build the pipeline against RTX or Radeon libraries, profile it, and iterate. The next gain may come as much from deciding what the GPU does not need to calculate as from raising what it can calculate. The proof points arrive in production: AMD needs its cage library inside engines and tested against real assets, and NVIDIA needs “Gears of War: E-Day” and “NBA 2K27” to show Mega Geometry and DLSS 5 at shipping quality. If those results hold, developers gain room to grow animated, ray-traced scene complexity on GPUs already installed in today’s machines.
What Do We Think?
AMD and NVIDIA treat the frame budget as a software problem as much as a silicon problem. The drop from 80 GB to 1.7 GB of BVH memory matters more than the triangle count, and DirectX-native neural shaders matter more than any single DLSS feature. Production tooling, shipping games, and coding-agent adoption will decide how far these gains travel.
We see an inflection point forming in graphics and applied AI. AI works on both sides of development: Neural models generate and refine pixels inside the pipeline, and coding agents help build the software that drives it. AMD’s cages show that algorithms can free memory and compute for those neural stages on existing GPUs. Developers will define visual and performance goals and hand more implementation to agents and neural stages, and that shift will reshape APIs, engines, and GPU architectures.
