A PC game that runs smoothly can still hitch for a fraction of a second the first time a new effect appears. The cause is shader compilation, and it is a consequence of how PC graphics are distributed.
Shaders are programs that run on the graphics card
Every material in a game, from skin to water to muzzle flash, is drawn by a small program that executes on the graphics card. These programs are called shaders.
Developers write them in a high-level language, but a graphics card cannot execute that directly. The code has to be translated into instructions the specific chip understands.
A modern game contains thousands of shader variants, because each combination of lighting, material and quality setting produces a separate version that has to exist on its own.
The translation cannot be done in advance on PC
On a console the studio compiles every shader once, during the build, because there is exactly one graphics architecture and one driver to compile for.
PC has neither. The final translation depends on the card and the driver version installed on the player's machine, neither of which the developer can know while making the game.
So the work moves to the player's computer, and if nothing schedules it deliberately it happens at the moment the shader is first needed to draw a frame.
The freeze happens because the frame waits
Compiling one shader takes only milliseconds, but a frame has roughly sixteen milliseconds to be finished at sixty frames per second.
If the renderer stops to compile, that frame misses its deadline and the picture holds still. A cluster of new effects entering view at once produces a visible lurch.
This is why the stutter follows novelty. It clusters in the first hour, in a new area, or the first time a particular weapon or spell is used.
Precompilation trades one delay for another
Many games now compile the full shader set before the main menu, which is why some titles show a progress bar on first launch or after a driver update.
That removes the hitching but front-loads several minutes of waiting, and it has to run again whenever the driver changes, because the previous results are no longer valid.
Others compile quietly in the background while the player moves through menus, which hides most of the cost but can leave gaps if the player starts quickly.
Caching is what makes the second run smooth
Compiled shaders are stored on disk, so a game that stuttered badly on the first evening is usually clean on the second.
Clearing that cache, updating drivers or moving to a different card invalidates the stored results, and the pattern returns from the beginning.
The stutter is therefore not a sign of underpowered hardware. It is a scheduling problem, and it is solved by deciding when the work happens rather than by making it faster.