Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Nvidia demonstrated a major texture-memory reduction at GTC 2026, but it is not a 6.7× upgrade for every graphics card. In a Tuscan-wheel scene shown in the March 2026 session “Introduction to Neural Rendering”, conventional BCn textures used approximately 6.5 GB of VRAM, while Nvidia’s Neural Texture Compression (NTC) configuration used about 970 MB.
That is roughly 85% less texture memory, or about 6.7 times less in this particular demonstration. The result depends on the scene, asset format, runtime mode, quality settings, and hardware. NTC is currently a public beta developer SDK—not a driver feature that automatically reduces VRAM use in existing games.
| # | Preview | Product | Price | |
|---|---|---|---|---|
| 1 |
|
ASUS TUF Gaming GeForce RTX™ 5080 16GB GDDR7 OC Edition Graphics Card | $1,770.00 | Buy on Amazon |
| 2 |
|
maxsun AMD Radeon RX 550 4GB GDDR5 ITX Computer PC Gaming Video Graphics Card GPU 128-Bit DirectX 12... | $112.99 | Buy on Amazon |
| 3 |
|
Graphic Processing Unit | $1.29 | Buy on Amazon |
What Nvidia actually demonstrated
The GTC presentation compared the same Tuscan-wheel material scene using two different approaches:
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute- Conventional BCn compression: approximately 6.5 GB of VRAM.
- NTC: approximately 970 MB of VRAM.
Using those figures, the reduction is approximately 85.1%, and the BCn version uses about 6.7 times as much texture memory as the NTC version.
#1 Best Overall
- Powered by the NVIDIA Blackwell architecture and DLSS 4. System Requirements: Minimum 850W PSU with 16-pin 12V-2x6 (12VHPWR) connector required. Verify before purchasing.
- Military-grade components deliver rock-solid power and longer lifespan for ultimate durability. Compatibility: 348mm (13.7") length, 3.6 slots, 4.3 lbs. Confirm case clearance and slot spacing. GPU bracket included.
- Protective PCB coating helps protect against short circuits caused by moisture, dust, or debris
- 3.6-slot design with massive fin array optimized for airflow from three Axial-tech fans
- Phase-change GPU thermal pad helps ensure optimal thermal performance and longevity, outlasting traditional thermal paste for graphics cards under heavy loads
Nvidia also showed both approaches under an equal 970 MB texture-memory budget. In that comparison, the BCn version displayed more visible compression artifacts, while NTC retained more texture detail. That is an impressive result, but it remains Nvidia’s comparison for the demonstrated scene—not a universal guarantee that every game can achieve the same quality or memory reduction.
The figures refer to texture memory in the demonstration. They should not be interpreted as total GPU-memory usage. Frame buffers, geometry, ray-tracing acceleration structures, shader resources, streaming caches, operating-system allocations, and other engine data still consume VRAM.
What neural texture compression does
Traditional formats such as BCn compress texture data into fixed-size blocks that modern GPUs can sample and filter directly. NTC takes a different approach. It compresses a material’s texture set into learned latent feature maps, a small material-specific neural decoder—generally an MLP—and the metadata required to reconstruct the material at runtime.
Recommended Free Tools
When the renderer needs a texture value, the decoder reconstructs it from the latent data and network weights. This is deterministic neural reconstruction, not generative AI: the same inputs produce the same result, and the system is not inventing new artistic content.
A key difference is that NTC can treat the PBR textures belonging to one material as a related group. A material may combine albedo, normal, roughness, metalness, ambient occlusion, and opacity data. The current SDK supports up to 16 total channels in one neural representation.
Joint compression can be efficient when channels are correlated—for example, when a surface feature appears in both the albedo and normal maps. It also creates trade-offs. Adding more channels at the same bits-per-pixel budget generally reduces quality, and compression errors in one channel can affect another.
The crucial distinction: NTC on-load versus NTC on-sample
“NTC uses less VRAM” is incomplete without identifying the runtime mode. Nvidia’s SDK documents two substantially different approaches.
NTC on-load
With inference on load, the game stores compact NTC data on disk, loads it, decompresses it, and transcodes it into ordinary BCn textures. Rendering then uses conventional texture sampling.
- Store the NTC representation in the game package.
- Load and decompress the material.
- Transcode it into BCn textures.
- Render using the GPU’s ordinary texture hardware.
This mode can reduce installation size and PCIe transfer traffic, and it is easier to integrate into an existing renderer. It also preserves ordinary hardware filtering. However, after transcoding, the resulting BCn textures occupy roughly normal BCn VRAM. It is not the mode responsible for the largest VRAM savings.
NTC on-sample
With inference on sample, the renderer keeps latent texture data and neural weights in memory. A pixel or ray-tracing shader invokes the decoder when it samples the material, reconstructing the requested material channels at that point.
This can avoid storing full-resolution BCn textures and can decode only the texels needed for the current view. It is the mode with the largest potential VRAM reduction—but it replaces a conventional texture lookup with substantially more shader work.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Nvidia’s SDK README gives this illustrative 2K material example, excluding mip chains:
| Representation | Disk size | PCIe traffic | VRAM |
|---|---|---|---|
| Raw image data | 32.00 MB | 32.00 MB | 32.00 MB |
| BCn compressed | 12.00 MB | 12.00 MB | 12.00 MB |
| NTC on-load | 2.50 MB | 2.50 MB | 12.00 MB |
| NTC on-sample | 2.50 MB | 2.50 MB | 2.50 MB |
The table explains why the runtime distinction matters. NTC on-load mainly reduces package size and transfer cost. NTC on-sample is what allows the compressed neural representation to remain resident instead of expanding into conventional BCn textures.
Why the technique can save so much memory
NTC combines several advantages:
- Material-wide compression: correlated PBR channels can share information instead of being compressed independently.
- Compact latent data: the representation can be much smaller than the corresponding full-resolution texture set.
- Random-access reconstruction: the method is designed to reconstruct individual texture regions rather than requiring the entire material to be expanded first.
- On-demand decoding: inference-on-sample can reconstruct texels needed by the current shading work while avoiding resident BCn copies.
- Lower transfer volume: both NTC modes can reduce the amount of data stored on disk and moved over PCIe before rendering.
These benefits are most relevant to large, high-resolution, multi-channel PBR materials. They are less obviously valuable for tiny textures, UI assets, decals, simple masks, or data textures where neural inference and integration overhead may outweigh storage savings.
Rank #2
- AMD Radeon RX 550 Chipset, Silver plated PCB & all solid capacitors provide lower temperature, higher efficiency & stability
- 9CM unique fan provide low noise and huge airflow for your GPU
- GPU Boost Clock / Memory Speed : up to 1183 MHz / 4GB GDDR5 / 6000 MHz Memory, Stream Processors 512, Perfect for 3D CAD/CAM working, video and photo editing, Video Games @1080p
- Support: DirectX 12, Shader Model 5.0, OpenGL 4.6/4.5, 4K Video Decode
The performance bill is shifted, not removed
NTC exchanges some texture-storage and bandwidth pressure for neural-decoder computation. On-sample inference can be considerably more expensive than a normal hardware texture lookup, especially when a material is sampled many times per pixel.
Free tools Windows power users keep installed
One-click scans. No signup required.
Filtering is one of the largest technical complications. The inference-on-sample path returns one unfiltered texel with all material channels at a time. Reproducing ordinary trilinear and anisotropic filtering directly would be prohibitively expensive. Nvidia recommends combining inference-on-sample with Stochastic Texture Filtering and subsequent denoising or DLSS-style reconstruction.
That means a renderer cannot necessarily replace every Texture.Sample call with an NTC decoder and expect identical image stability or performance. The engine must account for sampling frequency, mip selection, temporal behavior, denoising, and the workload already competing for shader time.
Cooperative Vectors
Cooperative Vector extensions allow shader code to use hardware-accelerated matrix and vector operations for neural inference. Nvidia says Ada- and Blackwell-class GPUs can deliver a 2×–4× inference-throughput improvement over competing optimal implementations without those extensions.
The practical implication is important: a GPU may be technically capable of running NTC while still being too slow for attractive on-sample performance. The SDK describes fallback DP4a implementations primarily as a way to validate functionality, not as the preferred path for high-performance shipping use.
Hardware, operating systems, and APIs
The current public repository identifies the technology as the RTX Neural Texture Compression SDK v0.9.2 BETA. According to Nvidia’s SDK documentation, it supports:
- Operating systems: Windows 10/11 x64 and Linux x64.
- Graphics APIs: DirectX 12 and Vulkan 1.3.
- On-load decompression: Shader Model 6-compatible hardware is the minimum; Nvidia recommends Turing or newer.
- On-sample inference: Shader Model 6 hardware is the minimum, but Nvidia recommends Ada or newer for practical performance.
- Compression: Nvidia lists Turing as the minimum and Ada or newer as the recommendation.
The repository lists validated examples including Nvidia GTX 1000-series, AMD Radeon RX 6000-series, and Intel Arc A-series hardware. Validation does not mean equivalent performance, identical feature support, or the same useful on-sample frame-time budget across those GPU families.
DirectX 12 preview caveats
The DX12 Cooperative Vector path currently depends on a preview DirectX 12 Agility SDK, experimental shader-model and Cooperative Vector features, Windows Developer Mode, and Nvidia preview driver 590.26 or later for Shader Model 6.9 functionality.
Nvidia explicitly warns that this DX12 Cooperative Vector path is intended for testing and should not be used to ship products. The README describes non-Cooperative-Vector DX12 decompression and Vulkan versions as suitable for shipping, subject to their own integration and performance testing.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteThe documented Windows build path is:
git clone --recursive https://github.com/NVIDIA-RTX/RTXNTC.git
cd RTXNTC
mkdir build
cd build
cmake ..
cmake --build .Nvidia lists Visual Studio 2022, CMake, and CUDA among the required Windows build components. The README also warns that CUDA 13 is incompatible with the 590.26 Developer Preview driver required for the DX12 Cooperative Vector configuration and recommends CUDA 12.9 for that setup.
NTC is lossy, and image quality depends on the material
NTC does not eliminate compression artifacts. Nvidia’s quality documentation states that compression error is almost always present, except in special cases such as a channel containing a constant value.
Quality depends primarily on:
- Bits per pixel.
- The number of channels grouped into one representation.
- The latent representation and network configuration.
- The texture’s visual content.
- The mip level being examined.
- How strongly the material channels are correlated.
- Whether the content is SDR, HDR, opacity, or another special data type.
The command-line compressor exposes bits per pixel as a central quality control:
ntc-cli -b <bpp>The equivalent long option is:
ntc-cli --bitsPerPixel <bpp>The SDK evaluates compression results using PSNR in decibels, but PSNR is not a complete substitute for visual testing. A material can achieve a strong numerical score while producing an objectionable normal-map, roughness, foliage, or specular highlight artifact.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
HDR, opacity, and mipmaps
Nvidia says HDR content does not work well when passed directly through the neural decoder. The documented workflow converts HDR data through HLG before compression and linearizes it after decompression.
Rank #3
Alpha and opacity masks may be better stored separately, for example in BC4, rather than forcing them into a shared neural representation. Different mip levels can also have different compression quality, so testing only the highest-resolution image is not enough.
Developers should inspect materials in motion and at multiple distances, paying particular attention to:
- Normal-map stability under changing lighting.
- Roughness and metalness behavior in specular highlights.
- Alpha-tested foliage and particles.
- Thin geometry and decals.
- Texture transitions between mip levels.
- Temporal shimmer caused by stochastic filtering and reconstruction.
How large is the improvement beyond the GTC scene?
The 6.5 GB-to-970 MB result is the most striking current demonstration, but it should not be treated as an average game-wide benchmark.
Nvidia’s original NTC research describes an illustrated texture comparison with up to 16 times more texels than a high-quality BC comparison while using approximately 30% less memory. That result applies to the specific assets and settings in the research evaluation.
The SDK’s 2K example gives a different perspective: on-sample NTC is shown at 2.5 MB of VRAM versus 12 MB for BCn, while on-load NTC is also 12 MB in VRAM. These examples are useful for understanding the mechanisms, not for predicting the exact savings in a commercial game.
Real games contain mixed workloads and materials with very different compression characteristics. A carefully selected showcase scene may compress unusually well compared with an entire asset library containing animation textures, masks, HDR data, decals, UI elements, and poorly correlated channels.
What NTC means for PC gamers
Existing games do not automatically benefit from NTC. A game must package assets in an NTC-compatible representation and integrate the SDK or equivalent engine support. There is no driver switch that retroactively turns an 8 GB graphics card into a 50 GB card.
Future games could use NTC to reduce texture-related VRAM pressure, improve installation and streaming efficiency, or retain higher-resolution material data within a fixed memory budget. But the benefit will depend on the developer’s asset pipeline, target hardware, filtering strategy, and frame-time budget.
NTC also does not solve every memory problem. Geometry, render targets, ray-tracing structures, shader memory, post-processing buffers, and streaming systems continue to require their own allocations. A game that runs out of VRAM because of geometry or ray tracing will not necessarily be rescued by compressing textures.
For consumers buying hardware today, physical VRAM remains the predictable solution. It is not sensible to purchase a GPU solely on the assumption that NTC will soon provide an immediate 6.7× memory multiplier in ordinary games.
What NTC means for engine developers
NTC is worth evaluating when an engine has large PBR materials and texture memory or download size is a major constraint. The most useful evaluation should compare the two runtime modes separately rather than treating “NTC” as one result.
- Measure on-load first. Quantify package size, PCIe traffic, loading time, decompression time, and resulting BCn VRAM.
- Measure on-sample independently. Track latent-data VRAM, neural weights, shader occupancy, texture-sampling cost, and frame time.
- Test representative materials. Include albedo, normal, roughness, metallic, opacity, foliage, decals, HDR content, animated textures, and masks.
- Test multiple GPU tiers. Shader Model 6 compatibility does not guarantee acceptable inference performance.
- Inspect motion and mip transitions. Still screenshots can hide filtering, shimmer, leakage, and temporal artifacts.
- Account for the complete memory budget. Report texture VRAM separately from total VRAM, and include the resources that compete with it.
- Decide where the technique belongs. Some materials may benefit from on-sample inference while UI assets, masks, or small textures remain better served by conventional formats.
Conventional BCn compression remains attractive because it is mature, widely supported, predictably fast, and natively filtered. Virtual texturing and conventional streaming also reduce resident memory by loading only the tiles or mip levels needed at a given time, without requiring neural inference for every texture sample.
Verdict: a credible breakthrough, not a universal VRAM multiplier
Nvidia’s GTC 2026 NTC demonstration is technically meaningful. A reduction from approximately 6.5 GB to 970 MB in the shown Tuscan-wheel scene, together with better apparent detail at the same 970 MB budget, demonstrates that neural texture representations can be far more memory-efficient than conventional BCn assets in suitable conditions.
But the headline requires three qualifications. The result is from one Nvidia demonstration; the largest savings depend on inference-on-sample rather than the more conservative on-load path; and the trade-off includes neural shader cost, filtering complexity, lossy reconstruction, hardware requirements, and substantial engine integration work.
With the public SDK still labeled v0.9.2 BETA and parts of the fastest DX12 path dependent on preview technology, NTC is currently best understood as a promising developer technology for future engines—not an automatic upgrade for today’s games or graphics cards.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
