Developer BlueHeisenberg has released SCSKiller, a free, open-source tool that reduces the stutter in PC games caused by shader compilation. Before you launch a game, it compiles the shaders and rendering pipelines the game will need for your PC's GPU and saves them to the GPU driver's cache.
Because it can fill in the parts that a game's own precompilation does not fully cover, it may reduce the momentary freezes that occur when an effect is displayed for the first time. However, how much of the required rendering work can be reproduced in advance depends on the GPU, the game, and the graphics API. The "0" results the developer presents do not mean that every kind of stutter in a game has disappeared.
Finishing the first shader compilation before you launch the game
SCSKiller reads shaders from the installed game's files and, from a separate process, creates in advance the rendering pipelines the game is expected to build.
It supports 64-bit Windows 10 version 2004 or later and Windows 11. As of October 6, 2026, the latest stable version is 1.2.2. It can detect games installed through not only Steam and the Epic Games Store but also the Xbox PC app, EA app, GOG, Ubisoft Connect, Battle.net, and others. However, being able to find a game in a library is not the same as being able to precompile it.
Shaders are GPU programs that calculate how objects are drawn, along with color, lighting, and more. Games usually contain shader code in an intermediate format rather than the final machine code the GPU runs directly. So when the game actually runs, the GPU driver still has to compile that code into a form the PC's GPU can execute.
If a shader is compiled for the first time during gameplay and the game waits for that to finish, frame display halts for a moment. This is one cause of what is commonly called shader-compilation stutter.
In DirectX 12, the system builds not only shaders but also "pipeline state objects" (PSOs), which bundle rendering settings such as vertex data formats and blend methods. The "root signature," which defines the layout of the resources a shader uses, is also involved in creating a PSO.
For that reason, finding all the shader code in a game does not necessarily let you fully reproduce the PSOs the game actually creates.
SCSKiller uses analysis routines specific to each game engine to work out which shaders are included, how they are combined, and what settings they need. It then runs a dedicated compilation program under the same name as the game's executable and creates the PSOs through DirectX.
According to the published design documents, the tool takes advantage of the way GPU drivers manage their shader caches by tying them to things like the executable name, so that a game launched later can reuse what SCSKiller created beforehand. It also includes dedicated handling for cases that cannot be processed by executable name alone, such as AMD application profiles and packaged games.
Precompilation is done with the game closed. SCSKiller first has the GPU driver run the work through DirectX and saves the result in the driver cache. When the game starts and needs the same work, the driver can reuse the cached result.
In other words, it moves compilation that would have happened during play to before you start. The CPU work required for compilation itself, and the storage space needed for the cache, do not go away.
"0" does not mean all stutter is gone
The developer compares about five minutes of play with the driver cache emptied against play after precompiling with SCSKiller.
Measurements use SCSKiller's own recorder, and a "stutter" is counted whenever the game waited 20 ms or more for a shader or pipeline compilation to finish.
| Game / GPU | Compile waits of 20 ms or more (before → after preparation) | Longest compile wait (before → after) |
|---|---|---|
| FINAL FANTASY VII REBIRTH / RTX 5090 | 19 → 0 | 76 ms → 5 ms |
| FINAL FANTASY VII REBIRTH / Ryzen AI Max+ 395 | 162 → 0 | 291 ms → 7 ms |
| Hogwarts Legacy / RTX 5090 | 1,014 → 87 | 2,400 ms → 100 ms |
The source is the developer's README "Results" section, checked on October 6, 2026. The results come from about five minutes of play in each game and are not measurements meant for comparing performance across different GPUs.
In Hogwarts Legacy, measured on an RTX 5090, compile waits of 20 ms or more dropped sharply from 1,014 to 87. They were not eliminated entirely, though.
The table also shows only the number of compile waits that exceeded a certain length and the longest wait among them. It does not show total time spent compiling or how many percent the average frame rate improved.
The "0" for FINAL FANTASY VII REBIRTH likewise means that no compile wait of 20 ms or more occurred during the measurement. Compilation of up to 5 ms or 7 ms was still recorded after precompilation.
In addition, stutter in games does not come only from shader compilation. Stalls from other causes, such as data loading during map transitions, asset streaming, and CPU processing, fall outside what SCSKiller addresses.
To judge how much smoother a game became overall, you would also need to check actual frame times separately.
The results in the README do not list the GPU driver version, detailed graphics settings, or how many times the same test was repeated. The figures therefore cannot be applied as-is to every environment.
Wccftech also tried FINAL FANTASY VII REBIRTH on its own, reporting that after generating about 3 GB of NVIDIA PSO binaries, stutter tied to things like weapon effects displayed for the first time nearly disappeared. There are improvement reports from people other than the developer, but this trial alone does not prove the same effect in every game.
NVIDIA and AMD need different information for precompilation
NVIDIA and AMD differ in the conditions under which their GPU drivers reuse compiled data. SCSKiller's developer investigated driver-cache behavior using custom tests and real games, and changes the precompilation method depending on the GPU vendor and graphics API.
Support is therefore not determined by the GPU model name alone. Whether the game uses DirectX 11 or DirectX 12, and how far the rendering settings the game actually uses can be reproduced, also matter.
| GPU / graphics API | Support per published documents | Conditions needed for precompilation |
|---|---|---|
| NVIDIA / DirectX 12 | Supported | If PSOs can be rebuilt from the engine's rules, preparation is possible without a play recording. Games with insufficient information require a recording |
| AMD / DirectX 12 | Supported | A recording that includes actual rendering content may be needed to determine that a game is supported. If a shared record is available, you do not need to collect one yourself |
| NVIDIA / DirectX 11 | Supported | Runs rendering and compute work from a separate process so that driver-side compilation happens first |
| AMD / DirectX 11 | Not currently supported | Recompilation is triggered by things like vertex input layouts, making it hard to reproduce the same state as the game |
| Intel | Not supported | The developer says they do not own a GPU for testing |
This table organizes, by GPU and graphics API, the README's support conditions and the design document's "Driver caches" and "Readiness rules" as of October 6, 2026. It is not a guarantee that every game will work.
According to the developer's testing, NVIDIA's DirectX 12 driver can reuse compilation results centered on shaders and root signatures, and the cache remains valid even if some rendering state, such as blending, changes.
On AMD, by contrast, there are cases where more state, such as vertex data layout and combinations of shaders, becomes a condition for recompilation.
In other words, the difficulty of precompilation changes depending on whether creating similar PSOs in advance is enough, or whether the settings the game actually used must be reproduced exactly.
In the current SCSKiller, judging whether a game is supported on AMD may require a record of the rendering pipelines created during actual play. If a usable shared record exists, though, you can skip the effort of playing and collecting one yourself.
The driver-cache behavior described here is what SCSKiller's developer observed on real hardware. It is not a public specification in which GPU vendors guarantee behavior for all future drivers.
Games that use Vulkan are also not supported at present. Even if the GPU itself is supported, you need to check the graphics API in use and the per-game support status.
Shared records and anti-cheat change where it can be used
When analyzing game files alone cannot identify the necessary PSOs well enough, SCSKiller records the rendering pipelines the game creates during actual play and uses that information for later precompilation.
It works by gathering data over a few minutes of play, but it cannot record places or effects you never displayed during that time.
With the community database for Patreon supporters, you can precompile using records shared by other players. What is shared is mainly hash values for identifying shaders, not the GPU-compiled code itself.
Using the shared hashes as clues, SCSKiller reads the corresponding shaders from the game installed on your PC and compiles them for your own GPU.
Because of this, shared records can reduce the effort of playing first to gather data. On the other hand, shaders generated dynamically at runtime, and processing added or changed by mods, may require a new recording on your own machine.
The basic features of SCSKiller itself, which runs on your PC, are free. The community database for general games is for Patreon supporters, but the design documents also describe a mechanism for freely sharing some middleware-related data. Not all sharing features are paid.
When you record play yourself, you need to temporarily place files such as a recorder DLL in the game's folder.
As a rule, SCSKiller does not launch games on which it detects anti-cheat, nor does it install the recorder. It limits itself to reading the game files.
However, if the precompilation content can be assembled from game files, past records, and community-shared records alone, it may be possible to prepare the cache without launching the game, even for games with anti-cheat. Having anti-cheat does not make all precompilation impossible.
For ELDEN RING and ARMORED CORE VI, an exception is provided for recording in offline sessions that do not use Easy Anti-Cheat. The user permits it for each game and it is confirmed at every launch.
In this method, SCSKiller places the recorder files in the game folder and then launches the game directly without Easy Anti-Cheat.
The developer warns that launching the game online with these files left in place risks outcomes such as an account ban. The exceptional offline recording method must be kept clearly separate from normal online play.
Fixes have continued since the release. v1.2.1 fixed a bug where, from v1.2.0 onward, the recorder was not enabled correctly and nothing could be recorded during play.
Support was also added for cases where HDR mods such as RenoDX change the root signature, though constraints remain depending on how and what kind of mod is installed. v1.2.2 also fixed issues such as carrying over recorded data and handling of anti-cheat games.
For that reason, it is wise to check the changelog for the version you use, not just whether a game is listed as supported.
The distributed build is not currently code-signed. The official README says that unsigned apps are blocked in environments where Windows 11's Smart App Control is enabled, and advises waiting for a signed release.
Local precompilation, unlike Microsoft's delivery approach
Microsoft's Advanced Shader Delivery (ASD) is a mechanism that delivers precompiled shaders together with the game when it is downloaded.
Game developers collect the data on needed rendering work and submit it to Microsoft, and shaders for compatible PCs are prepared on the delivery infrastructure side. On October 1, Microsoft announced an expansion of supported devices and said rollout to Intel and NVIDIA is planned for later that month.
With ASD, game developers and distribution platforms handle the advance preparation.
SCSKiller, by contrast, analyzes the game installed on the user's PC and builds the driver cache in advance using that PC's own GPU.
That leaves room for it to be used with existing titles that developers have not specifically adapted, and with games sold through multiple stores. In exchange, the user bears the compilation time and cache size, and some games also require actually playing to record rendering pipelines.
After a GPU driver update, the cache may need to be rebuilt. SCSKiller can detect driver updates and recompile, and can do so automatically if the user allows it.
In other words, it is not a system where you precompile once and are done forever.
What determines SCSKiller's practicality is how much of the precompiled result the actual game can reuse from the driver cache.
Some titles allow the necessary rendering work to be identified well enough from game files alone, while others require records of actual play. Game or GPU driver updates can also invalidate a cache that was previously usable.
Still, for games whose own precompilation is insufficient, SCSKiller can be one way to reduce shader-compilation stutter, if it can move compilation that would first occur during play to before the game starts.