Basis Universal v2.6 update

basisu_pack: a new command line tool is being added to the Basis Universal open source library, shipping in Jan. 2027. Real-time, high quality GPU texture format encoders for any platform, for virtually any GPU texture format: LDR, HDR, BC1-7, ASTC (all 14 block sizes for LDR, 2 block sizes for HDR), ETC1/2, PVRTC1 etc. - all using our own encoding tech. It writes .DDS, .KTX, .KTX2, and .ASTC.

We have the real-time analytical encoders (for transcoding purposes), so now we're going to expose them via API's and tooling. They don't need SIMD, yet many of them are faster than other older search-based SIMD encoder designs.

Also coming: Official Python wheels for several platforms, transcoding performance increases, and large XUASTC compression ratio improvements.

Our CLI's are shipped as both native or as secure WASM WASI executables.

neural_upsampler: neural 2x upsampling as a tiny drop-in C++ library

On GitHub here:

https://github.com/richgel999/neural_upsampler

Neural JPEG artifact reduction in C++

Designed to be trivial to drop into any program, it filters an already decoded 32bpp RGBA JPEG image. A little helper is provided to extract the DCT quality factor, which is also fed into the MLP:

https://github.com/richgel999/jpegc_deblock

The model's ~2.2k weights are in a single header. It was trained on an RTX 5090, using libjpeg with a custom training engine.

"A 7x7-window MLP (52 inputs: the luma window as differences from the centre, the centre's luma, the 8x8 block phase, the quality factor; hidden 32 and 16, leaky ReLU; one linear output) that predicts a luma correction added to R, G and B, equivalent to a Y-only correction in YCbCr. Trained by finite differences on 514 PNGs round-tripped through baseline JPEG at qualities 30..95. On held-out images it gains about +0.95 dB luma PSNR at quality 30, +0.9 at 40, +0.7 at 80. About 20 Mpx/s on 32 threads, 1.6 Mpx/s on one."

A heavily perceptual LRDO XUASTC LDR encoder is coming soon

I've posted an example here:

 https://x.com/richgel999/status/2114046689581596751?s=20

NNTC PBR material set compressor: now supports CPU encoding

The NNTC (Non-Neural Texture Compression) PBR material set compressor now supports CPU encoding, as well as supporting CUDA. Encoding/viewing has also been tested on Windows ARM. 

https://github.com/richgel999/nntc

One major thing left: D3D12 Linear Algebra. It already supports VK_NV_cooperative_vector.

There is also an updated Prior Art disclosure, dated Sept. 19, 2026:

https://github.com/richgel999/nntc/blob/main/PRIOR_ART_DISCLOSURE.md

Latent-based GPU texture public Prior Art from 2012

Experiments in Luma-Optimized and Mipmapped DXT1 Compression:

https://web.archive.org/web/20140915122940/https://sites.google.com/site/richgel99/luma_chroma_texture_compression

The sample app's archive (with shader source code) is still available here.

Major concepts:

• It splits information by spatial frequency: full-resolution luma/detail plus lower-resolution chroma/color state. The page puts luma in mip 0 and the color/chroma image at half resolution and below.
• It reconstructs the final texel in the pixel shader from separately hardware-filtered components. The page explicitly says bilinear/trilinear/anisotropic filtering works normally because the reconstruction is linear.
• It deliberately makes the encoder aware of the runtime reconstruction. There is even an optional feedback pass that modifies the high-resolution luma to compensate for errors introduced by the compressed, upsampled low-resolution chroma.
• It treats the lower-resolution representation as something that gets interpolated by ordinary texture hardware and then combined with the high-resolution signal—not decompressed into a conventional texture first.
• It even says a preferable version would use DXT5A/BC4 for the high-resolution scalar field instead of abusing DXT1 for luma.

NNTC viewing example which uses VK_NV_cooperative_vector

The NNTC Vulkan sample is working (3000+ lines of .cpp later). It supports VK_NV_cooperative_vector for decoding.

So the same inference hardware the neural guys are using benefits NNTC, too. I'll have this checked into GitHub after testing on more hardware.