Cycles Texture Cache

In Blender 5.2 LTS, rendering scenes with many image textures will become much more memory efficient. The new Cycles texture cache loads only the image tiles and resolutions needed.

How to Use

Enable Performance > Texture Cache and Auto Generate in the Render properties.

For every image, a corresponding tx file will be generated in the blender_tx/ folder next to the image file. This tx file is optimized for loading just the tiles and resolutions needed for rendering.

The system was designed to be easy to use for individual users. Tx files are automatically regenerated on changes, and color spaces and filtering are based on usage of image textures in shader nodes.

For render farms and production pipelines there is additional control, see the release notes for details.

Performance

Memory savings and performance are highly scene dependent. Especially how much image texture memory was used compared to geometry.

The following numbers are from benchmark scenes that use many image textures.

Generating Tx Files

The Texture Cache panel has a button to manually generate tx files. The default location can be changed in the preferences, with either a path relative to the image file, or an absolute path.

Standard tx files generated by other renderers and OpenImageIO’s maketx are recognized as well, but may be less efficient to load.

To generate Cycles native tx files from the command line, the following commands as provided:

# Generate tx files for all images in a blend file.
blender scene.blend --command maketx

# Generate tx file for a specific image file.
blender --command maketx image.png --colorspace sRGB

Viewport

In the Simplify panel, the Texture Limit option has been replaced by a Texture Resolution percentage. This is a single setting that works both with and without the texture cache.

This is particularly useful for viewport rendering of complex scenes. Textures at e.g. 50% or 25% resolution will reduce load times and can help ensure textures fit fully in memory for interactive rendering.

Unused images are periodically cleared, after a viewport render completes and Blender is idle.

Technical Details

GPU

We needed a design that works across CPU and all GPU backends, which have varying capabilities and APIs.

In traditional CPU based texture cache systems, threads cooperatively maintain a least recently used cache of tiles with a memory budget. Each thread typically does a blocking wait when a tile is missing, and locks a tile while using it to avoid it being evicted.

The same mechanism is not practical on GPU, especially across different GPU backends and hardware capabilities. Many thousands of threads are in flight at the same time, and GPUs do not generally have direct disk access while executing a kernel.

The mechanism we decided on was to accumulate texture cache misses from all threads, batch load the missing tiles, and then relaunch kernels. This is somewhat similar to systems used for games, however the difference is that we need accurate results and can’t use a lower resolution stand-in until the actual texture is loaded.

For this, kernel scheduling was changed so that kernels can be re-executed without side effects. Cycles uses wavefront path tracing with potentially millions of paths in flight, which helps hide latency from tile loading.

Tile Map

Image tiles are packed into textures as they are loaded, with a virtual texture mapping from each image tile to an offset in the texture that stores the pixels.

Tiles have 2 pixels of padding, adapted to the repeat mode. With this we can take advantage of hardware filtering on the GPUs, and make texture lookups read from only a single tile on both the CPU and GPU.

Ray Differentials

Ray differentials were added to the native SVM shading system, as they are required to find the appropriate mipmap level. The implementation is based on dual numbers for automatic differentiation. Open Shading Language supports them, however that is only available for CPU and OptiX.

For indirect bounces, ray differentials are widened as less detail is needed. This helps reduce texture cache memory by around 30% in various scenes.

Cache Eviction

CPU based texture cache systems usually have fixed texture cache budget that can be tuned to trade performance and memory usage. For GPU rendering, fine grained control is more difficult, as thousands of threads and millions of paths are in flight at the same time. While traditional CPU texture caches can keep a tight budget, in practice performance drops steeply when the working set does not fit.

Instead the cache eviction strategy is to rely on the existing tiled rendering. Cycles uses large 2048 pixel tiles by default, which save render pass memory by writing to disk. Now this same control also helps to reduce texture cache memory.

The system works by evicting unused images that were not used by the last two render tiles. The first render tile loads images, the second render tile loads more images, and then before the third render tile unused image tiles are evicted. Most image textures for indirect bounces remain in memory, as they are shared between render tiles.

For large 4K, 8K or 16K renders where tiled rendering kicks in, we have found texture cache memory usage to remain roughly constant regardless of render resolution. On memory constrained systems, a lower render tile size of 1024 or 512 pixels helps further reduce memory at the cost of some performance.