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.
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 September 17. 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.
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.
Nvidia took a slightly different path (no pun)
Nvidia does path-tracing forests at 60 frames.
Figure 3. Four detail zones let a path tracer handle 60 million plants.
Open-world games need dense, wind-blown vegetation, and ray tracing has struggled to deliver it. A new research paper describes a pipeline that path-traces a 25-square-kilometer forest of 60 million animated plants at 60 fps on a single RTX 4090. The system uses DirectX Raytracing and Vulkan features that ship today, so ISVs and silicon teams can study it without waiting for new hardware.
Why foliage breaks ray tracing
Rasterization handles wind cheaply. A vertex shader bends each instanced plant as the GPU draws it, and the deformed triangles live briefly in on-chip storage before they land in the frame buffer. Nobody stores the deformed geometry, so the working set stays small no matter how many vertices move.
Figure 4. Per-plant structures versus clustered detail levels in foliage path tracing.
Ray tracing has no such shortcut. Every bottom-level acceleration structure (BLAS) must sit in device memory and stay valid before a ray launches. Giving each plant its own deformed geometry and rebuilding its BLAS every frame costs too much memory and build time at forest scale. Alan Wake 2, a published example, fully skins its foliage and shares a handful of animated variants per plant model, so plants repeat their motion. Unreal’s Nanite traces simplified fallback proxies, and no hardware-accelerated equivalent of Nanite Foliage exists for ray tracing.
Three hardware features carry the design
The researchers build on features that DirectX Raytracing and Vulkan already expose.
Simplify the skeleton first
The test set holds 230 production plants. Each plant is a skeleton with rigid meshes attached, and every leaf and needle is real geometry. A simulated wind field drives each plant’s motion uniquely.
The first LOD step merges bones and their meshes, which cuts instance count. The team bounds the error from each merge by estimating how far the merged geometry could stray under strong wind. A merged skeleton cannot match the original motion exactly, so the team tunes the simplified bones to match the average sway and variation of the original. A distant viewer sees a natural wave and not a pose-perfect copy. Crossfading the motion settings hides each LOD switch.
Simplify the mesh without thinning the tree
Standard edge contraction collapses small leaves and twigs into lines and points, and the canopy thins out. The team modifies the algorithm. It runs an unconstrained pass first to learn the scale of each local feature, then reapplies only the contractions that stay a safe margin below the point where a feature would vanish. Isolated leaves and thin needles survive, and shallow bumps smooth away.
That approach limits how much geometry contraction can remove. For dense fine detail such as twigs and leaf clusters, the pipeline swaps the triangles for OMMs. It fits an oriented box around a chunk of geometry and places three perpendicular proxy triangles through the center, each carrying an OMM. The system picks OMMs only when they cost less memory than the triangles they replace. Nanite foliage follows a different rule: It switches to voxels when simplification error grows too large. This pipeline optimizes for memory.
Dithering marks each micro-triangle fully opaque or fully transparent, which approximates partial coverage without any-hit shaders and keeps the tree from looking too dense. Baked shading data stores a normal, texture coordinates, and a material reference for each opaque micro-triangle, with separate front and back samples. A small correction at shading time nudges normals away from grazing angles and fixes the dimming that the projection causes.
Far-field tricks
An offline step picks a small set of LODs per plant to minimize total memory. It takes about 70 seconds on a CPU for all 230 models. Transition distances use screen-space error limits of one pixel for edge contraction and four pixels for OMMs and instance merging. The final LOD collapses a whole plant into three OMM planes.
Beyond an animation cutoff distance, plants stop moving and become single rigid instances. Small distant plants get stamped into the terrain geometry. Large distant plants bake into one aggregate mesh per group. At runtime, a quadtree rebuilt each frame, divides the active instances into partitions of up to 1,024, and the GPU assigns and frees instance slots.
What it delivers
The team tested a 5 × 5 kilometer forest with 60 million plants on a Core i9-14900K and an RTX 4090. The scene renders at 2560 × 1440 and upscales to 3840 × 2160 with DLSS, at 60 fps. The path tracer takes one sample per pixel, two indirect bounces, and one shadow ray per hit, and a denoiser cleans up the image. The denoiser also hides LOD transitions, so the team could pick LODs more aggressively.
Table 2. The numbers show where the savings come from.
The pipeline minimizes memory and does not stream progressively smaller assets. Distant LODs reuse fine geometry over fewer pixels, which pushes more noise onto the denoiser. The system animates rigid meshes, a fit for midrange and far range. Close-range hero trees still need skinned animation, tessellation, and per-leaf motion. Translucent foliage, baked appearance for very distant vegetation, and OMM impostors for fences and lattices remain future work.
Silicon teams should watch how efficiently hardware handles cluster structures, OMMs, and partitioned updates, because this design leans on all three. ISVs building engines get a blueprint: Bake LODs offline, share geometry across levels, and let the denoiser absorb the transitions. For CIOs and IT leaders sizing GPU fleets, the result shows a single consumer GPU can path-trace a forest at interactive rates, and memory shaped the design.
What do we think?
AMD and Nvidia attack the same constraint from two directions: acceleration-structure memory and rebuild cost for animated vegetation. AMD’s tetrahedral cages cut BVH memory 47 times and update time ninetyfold in a research demo. Nvidia’s pipeline path traces 60 million plants at 60 fps with clusters, opacity micromaps, and a partitioned TLAS. Neither technique ships as a product feature. ISVs should prototype both and measure cage-construction cost, denoiser load, and LOD transitions. Silicon teams should weigh cluster and micromap support in RT units. CIOs should plan fleets around algorithmic gains.
Inflection point. This story signals an inflection point in real-time graphics. Both vendors remove work before it reaches the RT units, so algorithms now deliver gains that once required new silicon. Animated forests that overflowed GPU memory under conventional BVHs now fit a consumer card. The inflection point arrives when engines ship these techniques and APIs standardize clusters and cages. Until then, ISVs that prototype early gain a lead in open-world rendering.
LIKE IT? THINK YOUR FRIENDS AND ASSOCIATES MIGHT? PLEASE SEND IT TO THEM WITH OUR BEST WISHES.