RTXNTC: one neural texture set for a whole PBR material

Compressing a material as one bundle, not one file

RTXNTC attacks a specific cost in a 3D pipeline: the memory a single surface consumes. The README describes Neural Texture Compression as an algorithm that compresses all PBR textures used for a single material together, instead of compressing each map in isolation. That only pays off when the channels are correlated, so the README names the case where the approach works best as detail in the albedo texture corresponding to detail in the normal texture. A typical PBR material carries 9 to 10 channels: 3 for albedo, 3 for normal, plus metalness, roughness, ambient occlusion and opacity. Up to 16 texture channels can be compressed into one NTC texture set. The audience is an engine or tool programmer who owns the asset pipeline and can change how textures reach the GPU.

Latents and a decoder MLP in place of fixed block formats

During compression the original texture data is transformed into two things: weights for a small neural network that acts as a decoder, and a tensor of latents, also called features, that are sampled and passed through that decoder to reconstruct the texture colours. The decoder is a Multi-Layer Perceptron whose weights are determined during compression and stored as part of the compressed bundle. At runtime the path is a read of the latent data for a given texture coordinate followed by an inference pass through the MLP. The README says the sampling and decoding are fast enough to use directly in the shaders that normally sample these textures, such as base pass pixel shaders or ray tracing hit shaders, and the pipeline diagram in the repository is titled the NTC Decoding Pipeline.

Latent shape is the bitrate dial, not a quality slider

NTC is described as an adjustable quality, constant bitrate lossy compression scheme: the compressor tries to reconstruct the inputs with minimal error while using a fixed amount of data specified as a compression time target. The bitrate is not picked by naming a quality setting, though. It is picked by naming a latent shape, which is the composite of the number of high and low resolution latent channels, the bit depth of those channels, and the scale factor between them. Each latent shape corresponds to a given per-texel bitrate, so for a desired compression level you choose the shape whose bitrate lands closest to what you want. A constant quality, variable bitrate approach is only approximated, by pre-analysing the bundle to work out which formats are required for a target quality, which the README links under Adaptive Compression in the Settings and Quality Guide.

Three decode paths: on-sample, on-load, on-feedback

Three decode strategies are offered, and the choice matters more than the compression ratio. In the on-sample mode the decoder runs inside the shader. In the on-load mode, which the README suggests for renderers targeting lower-end hardware, the textures are decompressed when the game or map is loaded and transcoded at the same time into one of the block compressed formats, BCn. A third mode, Inference on Feedback, uses Sampler Feedback to find the set of texture tiles needed to render the current view, decompresses only those tiles, and stores them in a sparse tiled texture as BCn. One constraint applies to all three: the decoder produces unfiltered data for only one texel, so for filtered textures the README suggests combining NTC with Stochastic Texture Filtering, which lives in the separate RTXTF repository.

Cooperative Vector, and the DP4a fallback that runs anywhere

Decoding is an inference operation, and the README is direct that it carries a significant computational cost relative to the average pixel shader found in 3D rendering, even though the network is modest next to the large networks used in other deep learning work. The SDK lowers that cost with hardware support: Cooperative Vector extensions for Vulkan and Direct3D 12 let pixel shaders use the same acceleration used in large network inference, and on Ada and Blackwell class GPUs this provides a 2x to 4x improvement in inference throughput over competing optimal implementations that do not use those extensions. For platforms without them, fallback inference code built on DP4a instructions or regular integer math is provided, so decompression can run reliably anywhere that supports at least Direct3D 12 Shader Model 6, without the performance gain.

What a 2k bundle costs on disk, over PCI-E and in VRAM

The README works through a concrete example so the trade can be judged in bytes rather than adjectives. The bundle is albedo RGB, normal XY, roughness, metalness and ambient occlusion, an example taken from AmbientCG. At 8 bits per channel with optimal packing that is 64 bits per texel. A contemporary pipeline would block compress it into one BC7 texture for albedo, one BC5 for normals and a third BC7 packing roughness, metalness and ambient occlusion, so 24 bits per texel in total. The project reports that many real world bundles of that format can be compressed to results comparable to BCn, a PSNR of 40 to 50 dB, with a latent shape needing about 5 bits per texel. For a 2k by 2k texture with mip chains ignored, the listed footprint is 32.00 MB on disk, over PCI-E and in VRAM for raw images, 12.00 MB in all three for BCn, 2.50 MB on disk and over PCI-E but 12.00 MB in VRAM for NTC on-load after transcoding, and 2.50 MB in all three for NTC on-sample.

Where to get it, and what the Quick Start Guide leaves out

The README contains no installation command, so the honest version of this section describes what the tree holds and where the project points next. The repository is NVIDIA-RTX/RTXNTC, the default branch is main, the primary language is C++, and the top level contains CMakeLists.txt, ChangeLog.md, LICENSE.txt, ThirdPartyLicenses.txt, a .gitmodules file and the directories assets, docs, external, libraries, samples, support and tools. A sample renderer lives under samples/renderer. For first steps the README points at its Quick Start Guide section, and for tuning it points at the Settings and Quality Guide, which covers how various NTC settings affect compression ratios and image quality. The background document it links is the Random-Access Neural Compression of Material Textures page on the NVIDIA Research website. No binary download, installer or package registry entry is documented, so a first real use means getting the source tree, working with the CMake project definition at its root, and following the Quick Start Guide.

The preview Agility SDK requirement and the beta line

Two things argue for caution before you build a production path on this. First, the Direct3D 12 route depends on a preview component: the README warns that NTC texture decompression for DX12 applications, in both the on-load and the on-sample modes, relies on a preview version of the Microsoft DirectX 12 Agility SDK, specifically 1.721.0-preview, and that the LinAlg extensions, formerly Cooperative Vector, need that preview to work. Second, the versioning is a beta line. The README title is v0.10.0 BETA, the recent tags are v0.10.0-beta on 2026-08-04, v0.9.2-beta on 2026-01-22 and v0.9.1-beta on 2025-12-18, and the last push was on 2026-08-05, with the repository not archived. Licensing is a custom one that GitHub cannot classify, with terms in LICENSE.txt and third party terms in ThirdPartyLicenses.txt, so read both before shipping. The README documents no stable release channel or compatibility promise.

Editorial conclusion

RTXNTC fits teams that own the whole asset path, whose PBR channels correlate strongly, and that can live with a beta SDK plus a preview Direct3D 12 dependency. It does not fit teams that need a stable vendor-neutral format, that ship on hardware below Direct3D 12 Shader Model 6, or that must keep conventional BCn assets readable by tools other than their own runtime. Before committing, check the latent shape you can afford against the reported figure of about 5 bits per texel for BCn-equivalent quality, confirm your target Vulkan or Direct3D 12 version can use the Cooperative Vector or LinAlg extensions, and read LICENSE.txt, since the licence is a custom one that GitHub cannot classify.

Frequently asked questions

Official sources

1. Issues
2. NVIDIA-RTX/RTXNTC on GitHub
3. README
4. Releases