NVIDIA RTX Mega Geometry 2.0 Adds Cluster LOD for Ray Tracing

RTX Kit 2026.3 and RTX Mega Geometry 2.0 Ship as SDKs, Not Driver Features​

RTX Kit is a set of separate libraries rather than one product. NVIDIA calls it a suite of neural rendering technologies for ray tracing games with AI, rendering scenes with very large amounts of geometry, and building photorealistic characters. Each component has its own GitHub repository and version number. The 2026.3 release groups the current versions under one label. That structure has a practical effect: hardware and toolchain requirements differ from component to component, so developers have to check each SDK they adopt.

Here is what the 2026.3 release notes list:

Most of these are incremental. According to NVIDIA's blog, Collaborative Texture Filtering is meant to improve magnification quality for stochastic texture filtering, a technique that randomly samples textures after shading instead of filtering them up front. The Streamline change is small but will be noticed by players: games that use Dynamic Multi Frame Generation can now run it with V-Sync and frame-rate limiters, a pairing developers can expose once they integrate Streamline 2.14.1.

The release sits in a steady cadence. RTX Kit 2026.2 arrived in March and brought RTX Dynamic Illumination 3.0 with the ReSTIR PT algorithm. Version 3.1 builds on that work and wires DLSS Ray Reconstruction into its sample.

Cluster LOD Gives RTX Mega Geometry 2.0 a Second Path for Nanite-Style Meshes​

Version 2.0 is the substantive change. The Mega Geometry repository describes the SDK as a DX12 and Vulkan code sample for building ray-tracing acceleration structures for very dense geometry. It ships with a reference HLSL path-tracing demo that developers can use as a starting point for integrating the technique into their own engines. It is a reference implementation and learning tool, not a drop-in feature.

Before 2.0, the SDK centred on cluster tessellation. In that approach, Catmull-Clark subdivision surfaces are tessellated and displaced on the fly, and their acceleration structure is rebuilt every frame from cluster templates. Version 2.0 adds Cluster LOD. Here, triangle clusters are baked ahead of time, selected each frame from a continuous LOD hierarchy, and streamed into VRAM as needed. Both paths share one material table, one top-level acceleration structure (TLAS) and one scene graph, and a single scene can use both.

Cluster LOD targets scenes whose source geometry is too large to fit in VRAM. The README lists the supporting features: BLAS sharing, caching and merging to keep acceleration-structure build costs flat as instance counts grow, and a hierarchical Z-buffer that cuts detail in occluded geometry. On DX12, the cluster BVH build goes through NVIDIA's NVAPI. On Vulkan, it uses the vendor extension VK_NV_cluster_acceleration_structure. Both are NVIDIA-specific interfaces today, which is why the DXR 2.0 plans discussed below carry weight.

Mega Geometry has already shipped in games. Wccftech notes that the technology has already been available in games such as Alan Wake II, and the latest 2.0 updates are coming to gamers soon with the release of Gears of War: E-Day. The new element is the streamed, continuous-LOD approach aimed at unstructured high-density meshes, the kind of content Unreal Engine 5's Nanite produces.

The Zorah glTF Sample Sets a Workstation-Class Bar for Testing Mega Geometry 2.0​

NVIDIA demonstrates Cluster LOD with a new textured glTF export of Zorah, its RTX Kit tech demo. The repository puts the export at 1.6 billion unique triangles (18.9 billion instanced), 2,034 meshes and 4,357 textures. The download is 70 GB and extracts to about 31 GB of mesh data plus 48 GB of textures.

Loading it the first time takes planning. On first load, the demo bakes the LOD hierarchy for all 2,852 geometries in parallel, and NVIDIA warns this can use up to 64 GB of system RAM at peak. The bake limits its worker threads based on available memory, and the --bake-workers <n> switch sets the count explicitly. Each geometry shard is checkpointed as it completes, so an interrupted bake picks up where it stopped on the next launch.

The README's headline figure comes from NVIDIA's own test: a Zorah courtyard view on a GeForce RTX 5090 at 4K with DLSS Quality ran at 15.5 ms per frame, with 56 million unique and 778 million instanced triangles, 1.5 GB of resident mesh and 2.3 GB of CLAS (cluster-level acceleration structure) data. That is one vendor measurement on NVIDIA's top consumer card. It shows the scale is workable but says nothing about performance on mid-range hardware.

These are the sample's stated requirements:

• The sample runs on Windows 10 with an NVIDIA RTX GPU that has at least 10 GB of VRAM, GeForce Game Ready Driver 570 or later, and DirectX Raytracing 1.1 or later.
• Building it requires CMake 3.31 or later, Windows 10 SDK 10.0.20348.0 or later, and MSVC 19.43.34810 (Visual Studio 2022 17.13) or later; the DirectX 12 Agility SDK is fetched automatically.
• The Vulkan backend requires Vulkan SDK 1.4.313 or later and is selected by passing -vk at launch.
• Only Windows builds are supported for now.

Memory behaviour is adjustable. By default, Cluster LOD reserves 2,048 MB for streamed geometry, 2,048 MB for CLAS and 4,096 MB for material textures (the last set with --texture-budget-mb). All three can be changed in the demo's VRAM Budget window. NVIDIA says lowering them trades detail for VRAM instead of making the load fail. These are the sample's defaults, not a forecast of how much memory any shipping game will use.

Building and running the RTX Mega Geometry 2.0 sample​

The repository documents this sequence:

1. Clone the repository with its submodules: git clone --recurse-submodules [GitHub - NVIDIA-RTX/RTXMG: NVIDIA RTX Mega Geometry SDK ?? GitHub](https://github.com/NVIDIA-RTX/rtxmg.git).
2. From the rtxmg folder, generate project files with cmake CMakeLists.txt -B ./build.
3. Open the generated build/rtxmg.sln in Visual Studio and build it. Binaries go to the bin folder, and assets load from assets.
4. Run rtxmg_demo.exe. For Zorah, pass the scene file with -mf <path>/zorah_textured_public.v1.scene.json. Cluster tessellation can be tried with subdivision/amy_kitchenset.scene.json, and both paths together with subdivision/amy_abeautifulgame.scene.json.

Once a scene is loaded, the left-hand UI panel exposes most SDK features, with tooltips on hover. W/S/A/D moves the camera, left-drag rotates it, and Alt plus left-drag orbits the scene centre. NVIDIA asks for bug reports through the repository's GitHub issue tracker.

DirectX 12 Linear Algebra Ties RTX Kit's Neural SDKs to Microsoft's Shader Model 6.10 Preview​

The second theme of the release is a move to Microsoft's newer shader APIs. NVIDIA's blog says RTX Neural Texture Compression 0.10 beta now supports the DirectX 12 Agility SDK preview with Linear Algebra, which lets RTX Tensor Cores accelerate neural texture decompression inside DirectX shaders. The release notes list the same support for RTX Neural Shading 1.4 and identify the API as Shader Model 6.10.

Neural Texture Compression uses a small neural network in place of traditional block-compressed textures. NVIDIA's RTX Kit page claims up to 8x better disk-memory use at visual fidelity similar to block compression. Decompression happens in the shader, so running that network on Tensor Cores through a standard DirectX path is what makes the technique practical in a game. NTC remains a beta, though, and the Linear Algebra support depends on a Microsoft preview SDK, not a shipping DirectX release.

The shift is visible in NVIDIA's own documentation. The main RTX Kit page still promotes cooperative vectors in Shader Model 6.9 as the way to access Tensor Cores from game shaders, while the 2026.3 notes target the Linear Algebra API in Shader Model 6.10. Our inference is that NVIDIA is keeping its neural SDKs on Microsoft's newest preview toolchain, so developers testing them need the matching Agility SDK preview and shader compiler, not the stable release.

Tensor Core acceleration applies to NVIDIA RTX hardware. The blog does not claim that every PC running these SDKs gets that acceleration, and the Linear Algebra change is listed only for the two neural SDKs, not for the whole kit.

Windows ARM64 Support in RTX Kit Points Toward RTX Spark​

RTX Neural Texture Compression 0.10 and RTX Texture Filtering 1.3 both add Windows ARM64 support. NVIDIA's blog doesn't say why. The likely reason is RTX Spark, which the same post describes as NVIDIA's new AI and graphics platform for slim laptops and very efficient desktops. The In-Game Inferencing SDK added a developer preview of RTX Spark support in the same announcement.

TechPowerUp reports that NVIDIA says RTX Spark PCs start shipping in October and that NTC was already running on Windows on Arm in August. The ARM64 builds let developers compile these two SDKs for Arm-based Windows systems before that hardware reaches buyers.

The scope is narrow. Only NTC and Texture Filtering gained ARM64 builds in this release. The Mega Geometry sample still lists Windows builds on x64 toolchains with a discrete RTX GPU. ARM64 support in two SDKs does not mean the full RTX Kit, or Tensor Core acceleration, is available on every Windows on Arm PC.

Gears of War: E-Day and DXR 2.0 Take Mega Geometry Beyond NVIDIA's SDK​

Most reporting has focused on Mega Geometry's first high-profile Unreal Engine 5 game. NVIDIA's blog says the technology is "coming soon" to Gears of War: E-Day from The Coalition. NVIDIA's Game Ready driver announcement promises GeForce RTX players higher frame rates, higher levels of image quality, and with even more responsive controls when Early Access begins on October 1 and the full release follows on October 6. These are NVIDIA's claims, and no independent measurements are available yet. VideoCardz, citing NVIDIA, reports that RTX Mega Geometry will work across GeForce RTX GPUs, although performance will naturally depend on the GPU and selected ray-tracing settings.

The problem it addresses is a gap between Nanite and ray tracing. As Guru3D explains, Unreal Engine 5 Nanite allows developers to use extremely detailed source geometry while dynamically determining how much of that geometry needs to be rendered. TechPowerUp reports NVIDIA's position that UE5 ray tracing with Nanite geometry currently falls back to a single low-detail static mesh, so rays hit a simplified proxy while the rasterized image shows the full asset. eTeknix describes the fix as letting the ray-tracing scene process Nanite geometry at full detail, in much more accurate shadows and reflections on complex elements such as vehicles, vegetation, rocks, and debris. It also reduces flickering and other visual problems when the camera is moving. The game is built on Unreal Engine 5.8, according to Guru3D.

Accounts differ on which game ships first. Guru3D calls E-Day the first shipping game to use the technology with Nanite. TweakTown calls it "one of the first" and notes that Mega Geometry is also set to be included in Remedy's upcoming Control Resonant.

The more lasting claim concerns Microsoft's API. Several outlets report NVIDIA's statement from its Gamescom announcement that the techniques are expected to be adopted into DirectX Raytracing 2.0. Windows Report says this could eventually allow more developers to use full-detail Nanite geometry in ray-traced scenes across Unreal Engine 5 games instead of relying on simplified representations. Every account traces back to NVIDIA, and Microsoft has not published DXR 2.0 details that confirm the scope or timing. If Microsoft does standardize it, cluster acceleration structures would move from NVAPI and a Vulkan vendor extension into a cross-vendor DirectX feature. That would matter more to engine teams than any single SDK version.

What This Means for Windows Graphics Developers​

Rendering engineers working with dense geometry or Nanite-style pipelines have good reason to build the Mega Geometry 2.0 sample now. Everyone else can wait. Players need to do nothing: SDK releases change nothing on a PC until a game ships the code, and Gears of War: E-Day is the first real-world test of NVIDIA's claims. Teams using NTC or Neural Shading should expect to work against Microsoft's Agility SDK preview, and ARM64 work is currently limited to two components.

• RTX Mega Geometry 2.0 adds Cluster LOD, which streams pre-baked triangle clusters from a continuous LOD hierarchy alongside the existing cluster tessellation path, and one scene can use both.
• The Zorah glTF sample is a 70 GB download, and its first LOD bake can use up to 64 GB of system RAM, so plan storage and memory before testing it.
• The sample requires Windows 10, an RTX GPU with 10 GB or more of VRAM, Driver 570 or later, DXR 1.1, CMake 3.31 and Visual Studio 2022 17.13 or later.
• RTX Neural Texture Compression 0.10 (still beta) and RTX Neural Shading 1.4 target the DirectX 12 Linear Algebra API in Shader Model 6.10, which is available only through the Agility SDK preview.
• Windows ARM64 support in this release covers RTX Neural Texture Compression and RTX Texture Filtering only, not the whole RTX Kit.
• Streamline 2.14.1 lets Dynamic Multi Frame Generation work with V-Sync and frame-rate limiters, a small change that players will see once games integrate it.

RTX Kit 2026.3 is mostly incremental. Mega Geometry 2.0 is the exception: it gives developers a concrete way to put Nanite-scale detail into ray-traced scenes on Windows today, using NVIDIA-specific APIs. The first test comes on October 1, when Gears of War: E-Day opens Early Access with the technology enabled. If Microsoft follows through on DXR 2.0 as NVIDIA describes, the same approach will stop depending on NVIDIA's proprietary interfaces.