Every Linux gamer has seen it: a game finishes downloading, then Steam asks for more patience while it processes Vulkan shaders, and a folder quietly grows by gigabytes. That is shader pre-caching, Valve’s system for moving shader compilation out of your gameplay and into a download. This article explains how the system works: the compile problem it solves, the Fossilize model underneath it, first-launch behaviour without a cache, the storage cost, and which settings are worth touching.
One boundary up front. This site already covers fixing shader stutter, symptom by symptom. This article is not that. It is about the pre-caching system itself — how caches are built, shared, stored and invalidated — so you can choose settings deliberately.
As an Amazon Associate, we earn from qualifying purchases.
Quick answer
Shader pre-caching is Steam downloading ready-made Vulkan pipeline caches for your games so your graphics driver does not have to compile every shader while you play. On Linux it matters most for Proton titles, where translation layers produce huge pipeline counts. Leave it enabled unless storage is tight, and turn on background processing so caches finish building before you launch.
Why shaders have to be compiled at all
A shader is a small program that runs on the GPU: it decides how vertices are transformed and how surfaces are lit. Developers ship shaders in an intermediate form, not in the machine code your graphics card executes. Before a shader can run, the driver must compile it for your exact GPU architecture and driver version — at least once for every distinct shader and pipeline state a game uses.
The problem is timing. A Vulkan application creates graphics pipelines that bundle shaders with fixed rendering state, and a modern game can need thousands of them. If the driver compiles a pipeline the first time the game asks for it, the frame that triggered the request waits. The result is hitching in the first minutes of a level, settling down as more pipelines get compiled and cached.
Proton makes this heavier on Linux. A Windows game running through Proton has its DirectX shaders translated to SPIR-V, the intermediate form Vulkan drivers consume, by layers such as DXVK and VKD3D-Proton. The translation is fast, but driver-side compilation of the resulting pipelines still has to happen, a cost the DirectX driver model largely hides. Pre-caching absorbs that compilation before you press play.
How the distribution model works: Fossilize
Valve’s answer is to compile once, centrally, and share the result. The technology underneath is Fossilize, an open-source library Valve built to serialize Vulkan pipeline state: it records the full description of every pipeline an application creates, in a format that can be stored, shipped and replayed. With pre-caching enabled, Steam can capture pipeline data from play sessions, and Valve’s systems use it to build ready-made caches for each game, GPU family and driver combination.
Those finished caches are what Steam downloads alongside, and after, a game install. At launch, instead of compiling each pipeline from scratch, the driver replays the prebuilt cache and only compiles anything genuinely new. The cache is keyed to your hardware and driver, so a driver update can trigger fresh downloads and another round of processing for long-owned games.
The same mechanism powers the familiar “processing Vulkan shaders” step. When a cache arrives, Steam still has local work to do, converting the distributed data into your driver’s native cache format, and that work is CPU-bound. Whether it happens in the background or in a blocking dialog at launch is a settings choice covered below.
Vulkan pipeline caches versus the old OpenGL cache model
Long-time Linux users may remember an earlier era of Steam shader downloads, and it worked differently. OpenGL drivers compiled individual shader programs rather than monolithic pipelines, the state space was narrower, and Steam’s earlier cache-sharing targeted that model.
Vulkan changed the shape of the problem. A Vulkan pipeline fuses shaders with a large amount of fixed state, so combinations explode — but each can be described completely and serialized exactly, which is what Fossilize exploits. The modern system is built around pipeline caches, driver-version keying and replay, rather than the lighter program caches of the OpenGL era.
What happens on a first launch without a cache
Disable pre-caching, or play a game and hardware combination Valve has no distributed cache for, and the old behaviour returns in full. The game launches quickly — there is nothing to process — but the driver compiles pipelines on demand, and early play is punctuated by hitches whenever a new effect, area or enemy type appears. Over a session the driver builds its own local cache, so the same content runs smoothly the second time. You have deferred the compilation into your gameplay.
Proton titles lean on their translation layers’ own caching as a fallback, and while modern DXVK and VKD3D-Proton versions handle it far better than their predecessors, they still react to pipelines as the game presents them. The distributed Steam cache is the only piece of the stack that knows the pipelines before the game does.
The storage cost, stated honestly
Pre-caching is not free, and its cost is disk space. Every game’s cache lives in Steam’s shadercache directory, one folder per game, and large open-world titles can hold multi-gigabyte caches. Across a big library, the total can reach into the tens of gigabytes. Game updates can invalidate part of a cache and driver updates all of it, and Steam downloads replacements.
On a desktop with a large drive, this is background noise. On a Steam Deck with the smallest internal storage tier, or a laptop sharing a modest SSD, it is a real budget item competing with the games themselves. Deleting a game’s cache frees the space immediately, but the cost returns at the next launch, as a fresh download or as first-run stutter. No setting makes the compilation work disappear; there is only a choice about when it happens.
The two settings that actually matter
Steam’s Shader Pre-Caching page in Settings holds the controls. The first is the master toggle: enable or disable pre-caching entirely. The second, and the one most worth changing, allows background processing of Vulkan shaders. With it on, Steam uses spare CPU time to convert downloaded caches for games you are not playing, so launching is instant. With it off, that conversion waits until you click play.
A practical detail follows from how caches are keyed. Because a new driver version invalidates existing caches, a Mesa or NVIDIA driver update is often followed by a burst of downloads and background processing across your library. That is by design: the old caches cannot be trusted against a changed compiler. Background processing lets this housekeeping finish quietly instead of ambushing your next launch.
When turning it off helps, and when it hurts
Disabling pre-caching is rational in a narrow set of cases. If storage is critically tight and you play a small, fixed rotation of games, the local driver cache those games build may be enough, and reclaiming the shadercache folder is real space. It can also make sense for native Linux games with small pipeline counts, where first-run compilation is a one-time cost of seconds.
Everywhere else, disabling it hurts. For Proton games — the majority of a Linux library — it reintroduces first-session stutter across every new title and every driver update. It also removes the benefit of the shared dataset: the distributed cache reflects pipelines gathered from many players’ sessions, including content you have not reached yet. The toggle trades disk space for smoothness, and on most machines smoothness is the better buy.
Storage picks for cache-heavy libraries
With pre-caching on and a large library, the practical upgrade is simply room: fast NVMe storage absorbs games and caches without forcing deletions. These maker-rated options suit that job, plus one portable drive for moving a library between machines.
Samsung 990 PRO 2TB NVMe SSD (MZ-V9P2T0B/AM)
- Capacity: 2TB
- Interface: PCIe 4.0 x4, M.2 2280
- Maker-rated sequential read: up to 7,450 MB/s
WD Black SN850X 2TB NVMe SSD (WDS200T2X0E)
- Capacity: 2TB
- Interface: PCIe Gen4 x4, M.2 2280
- Maker-rated sequential read: up to 7,300 MB/s
Samsung 990 PRO 4TB NVMe SSD (MZ-V9P4T0B/AM)
- Capacity: 4TB
- Interface: PCIe 4.0 x4, M.2 2280
- Maker-rated sequential read: up to 7,450 MB/s
Crucial T500 2TB NVMe SSD (CT2000T500SSD8)
- Capacity: 2TB
- Interface: PCIe Gen4 x4, M.2 2280, TLC NAND
- Maker-rated sequential read: up to 7,400 MB/s
Samsung T9 Portable SSD 2TB (MU-PG2T0B/AM)
- Capacity: 2TB
- Interface: USB 3.2 Gen 2×2 external
- Maker-rated sequential read: up to 2,000 MB/s
How to choose
Match the settings to the machine. On a desktop with a large SSD and a multi-core CPU, enable pre-caching and background processing and forget the system exists. On a Steam Deck or a storage-tight laptop, keep pre-caching on but be deliberate about which games stay installed, since each carries its cache with it. On a slow connection, remember that driver updates trigger cache re-downloads across the library. Only on a genuinely cramped drive with a tiny, stable game rotation does disabling pre-caching come out ahead, and even then you pay with first-session stutter.
Who should skip this
Skip the deep dive if you play only a handful of native Linux games and have never noticed launch delays or a growing shadercache folder. Skip it, too, if you are chasing a specific game’s stutter problem right now — that is a troubleshooting task with its own article on this site. And on an immutable handheld image, the platform already makes these choices for you.
FAQ
Does shader pre-caching improve frame rates?
No. It does not make a game render faster once running. It moves pipeline compilation out of gameplay and into downloads and background processing, which removes compilation stutter. Average frame rates are unchanged; the smoothness of the first sessions is what improves.
Why did Steam start processing shaders again after a driver update?
Because caches are keyed to your GPU and driver version. A new Mesa or proprietary driver contains a changed shader compiler, so previously built caches cannot be reused safely. Steam downloads or rebuilds matching caches, and the processing step converts them for the new driver.
Can I delete the shadercache folder safely?
Yes, with a caveat. Deleting a game’s cache folder frees disk space and breaks nothing permanently, but the cost returns: Steam will download and process a fresh cache, or the game rebuilds one during play with the usual first-run stutter.
Is background shader processing using my CPU all the time?
It runs when Steam is open and caches are waiting to be converted, using spare capacity on games you are not playing. Turning it off simply defers the same work to launch time.
Final verdict
Shader pre-caching is one of the least glamorous and most consequential systems in Linux gaming: a Fossilize-based network that turns the Steam user base’s play sessions into ready-made pipeline caches for your GPU and driver. Its costs are real — disk space, re-downloads after driver updates, background CPU time — and its benefit is equally real: the near-elimination of compilation stutter as a first-run experience for Proton games. Leave it on, enable background processing, give it storage to breathe, and save the off switch for machines where disk space matters more than smooth first sessions.











