AMD just published a genuinely clever fix for one of ray tracing’s oldest headaches: animating dense, complex scenes without drowning in memory and update costs. Their new tetrahedral cage technique renders 500 million animated triangles at 60-plus fps on a single Radeon RX 9070 XT, using 47 times less acceleration-structure memory than the conventional approach. We walk through how the technique actually works, where it excels, where it falls short, and what it means for anyone building real-time rendering pipelines.
Real-time ray tracing requires the GPU to determine which surfaces a ray might intersect, and bounding volume hierarchies (BVHs) organize geometry so that search runs efficiently. Static geometry keeps this straightforward, since the renderer builds the acceleration structure once and reuses it. Animation breaks that simplicity: When thousands of objects deform independently, their vertex positions change continuously, and conventional implementations must maintain acceleration structures representing every one of those changing geometry states. Updating them consumes memory capacity, bandwidth, and GPU processing time directly.
AMD Fellow Holger Gruen published the fix on GPUOpen September 17. Instead of continuously modifying dense geometry and its associated BVH, the system encloses that geometry inside a much simpler deformable structure built from tetrahedra. The cage moves; the underlying high-resolution mesh and its acceleration structure stay static and reusable. During ray tracing, the system transforms rays back into the geometry’s original reference frame before testing them against the dense triangle set. Animation cost consequently scales with cage complexity alone, independent of the triangle count the cage encloses, a distinction that matters enormously once a scene contains thousands of independently moving objects.
Figure 1. Move the cage, reuse the geometry.
Gruen demonstrated the technique using a terrain scene containing roughly 25,000 independently animated plants, each responding to a wind-field simulation with locally varying wind directions. At maximum level of detail, the vegetation represents about 2.8 billion triangles. After level-of-detail selection, the GPU ray-traces roughly 500 million animated triangles per frame using primary and shadow rays, running at over 60 fps at 1080p on a single Radeon RX 9070 XT.
The triangle count makes an impressive demonstration on its own. The acceleration-structure numbers explain the real engineering significance:
Table 1. AMD’s independently animated foliage demonstration on the Radeon RX 9070 XT. (Source: AMD GPUOpen)
That translates into roughly 47 times less acceleration-structure memory and more than a ninetyfold reduction in BVH update time, targeting the two specific bottlenecks that keep densely populated animated environments out of reach for real-time ray tracing.
For GPU architects and game developers, BVH memory represents far more than storage capacity. Moving and updating acceleration structures consumes bandwidth and processing resources the GPU could otherwise devote to shading, geometry processing, ray traversal, and AI workloads competing for that same frame budget. A tree might contain hundreds of thousands of triangles; its deformation cage contains comparatively little geometry, letting the renderer retain the dense mesh and BVH as individual cages respond to wind fields or other animation inputs. This fits workloads such as forests, grasslands, crowds, and distant characters directly, wherever developers need large numbers of independently moving objects without precise control over every vertex.
Figure 2. 80 GB and 300 ms become 1.7 GB and 3.3 ms per frame.
That qualification matters. Tetrahedral cages sacrifice fine-grained, per-vertex animation control entirely. Characters needing detailed facial animation, complex cloth movement, or changing topology need more precise deformation techniques instead. AMD’s approach gives developers another tool, not a replacement for conventional animation and acceleration structures.
The distinction between dynamic and static data matters directly to silicon designers too. Faster ray-tracing hardware accelerates traversal and intersection operations; AMD’s technique removes work before those hardware units ever encounter it. That gives software and algorithm designers another route to higher-effective GPU performance, one that doesn’t require proportionally more compute or VRAM to reach it.
Figure 3. Independently animated dense geometry requires unique acceleration-structure state, while tetrahedral cages keep dense geometry and BVHs static and reusable. (Source: AMD)
AMD has not turned tetrahedral cages into a shipping Radeon feature yet. The work remains research: The underlying paper, Ray Tracing Massive Amounts of Animated Geometry, received third place in the Wolfgang Straßer Best Paper Award at High-Performance Graphics 2026. AMD says it is developing DXR samples and a header-only C++ library for building high-quality tetrahedral cages across skinned, keyframe-animated, and static objects alike. Those tools represent the genuinely important next step: A research demonstration proves an algorithm works under controlled conditions, and ISVs still need integrable code, production-asset testing, and real measurement of cage-construction cost, deformation quality, and ray-transformation overhead across representative scenes.
The technique’s most useful characteristic is that it attacks a software and data-structure problem instead of depending on a larger GPU. An acceleration structure requiring 80 GB sits well outside normal gaming-GPU memory capacity; reducing that to roughly 1.7 GB changes the hardware equation entirely, and AMD proved it on a consumer Radeon RX 9070 XT during a run processing 500 million animated triangles each frame. That doesn’t mean every object in a game can suddenly render through tetrahedral cages. Developers still need geometry whose animation maps naturally onto cage deformation, foliage being the obvious case since wind moves groups of leaves and branches together, not each vertex independently.
The same concept extends well beyond games. Visualization, simulation, digital twins, and other interactive 3D applications hit the identical problem whenever large numbers of objects move independently. For CIOs evaluating GPU infrastructure for those workloads specifically, the research makes one point directly—rising visual complexity does not automatically require memory capacity and bandwidth to grow at the same rate.
Graphics development has always paired faster silicon with better algorithms, and tetrahedral cages reinforce that same relationship. GPU vendors keep adding compute units, ray accelerators, cache, bandwidth, and VRAM, and software engineers can simultaneously cut the amount of work those resources need to perform. AMD’s research moves that optimization boundary by separating the complexity of visible geometry from the complexity of its animation representation, a distinction that grows more relevant as games stack ray tracing, neural rendering, frame generation, and other GPU workloads into the same frame budget. Every millisecond and gigabyte recovered from acceleration-structure management becomes available elsewhere in the pipeline.
AMD’s tetrahedral cages address a specific ray-tracing bottleneck by changing how animated geometry represents itself. Keeping dense meshes and BVHs static, and moving only lightweight cages, sharply cut memory consumption and update time in AMD’s own demonstration. The real test comes next, once developers apply the technique to production assets and engines. If those implementations reproduce the research results, developers gain a genuinely practical way to grow animated scene complexity without an equivalent jump in GPU memory and processing demand.
What do we think?
AMD found a genuinely useful way to separate geometric complexity from animation cost. The drop from up to 80 GB to 1.7 GB of BVH memory matters more than the headline triangle count. Foliage, crowds, and repeated environmental assets offer the clearest practical targets. Developer tooling and real production testing will determine how broadly game engines and visualization applications can actually exploit this.
Inflection point. Tetrahedral cages alone do not establish an inflection point in graphics; they demonstrate why one may emerge from the interaction between algorithms and increasingly capable GPUs. Ray tracing, neural rendering, and simulation keep competing for the same memory and compute budget, and cutting acceleration-structure overhead creates real room for those workloads without proportional hardware growth. If cage-based deformation reaches mainstream engines and APIs, it could meaningfully expand the animated, ray-traced complexity developers can deliver on GPU classes that already exist today.
Figure 4. Tetrahedral cages keep dense geometry and BVHs static, reducing animation overhead significantly. (Source: AMD GPUOpen)
LIKE WHAT YOU SAW HERE? SHARE THE EXPERIENCE, TELL YOUR FRIENDS.