GPU FPS Looks Fine but the Game Still Stutters? Frame Time, 1% Low & Micro-Stutter Diagnosis Guide

| HK GPU Fix

GPU FPS Looks Fine but the Game Still Stutters? Frame Time, 1% Low & Micro-Stutter Diagnosis Guide

Key Takeaways

Your game can average 120 FPS and still feel jerky, because average FPS hides slow individual frames. This guide explains frame time, what 1% Low and 0.1% Low actually measure, how to read a frame time graph, and how to tell shader-compilation spikes from streaming, processor bottlenecks, and sync problems.

The symptom, narrowed down

This guide is about one very specific shape of problem. The frame-rate counter in the corner of the screen says 120 FPS, or 144, or higher. The number looks fine. Yet the game does not feel fine: it jerks when you turn a corner, it hitches when you walk into a new area, and the movement never feels as smooth as the number promises. The number and the feeling disagree, and the feeling is telling the truth.

Say that distinction out loud at the start, because it decides everything that follows. This guide is about "FPS is fine but the game stutters". It is not about "FPS has dropped". If your frame rate has fallen from 120 to 40, or it keeps falling the longer you play, that is a different symptom with a different decision tree (see article #136 for a frame rate that has dropped, and article #356 for a frame rate that gets gradually worse during a session). If the picture shows a visible horizontal line where the top and bottom halves do not match, that is tearing, not stuttering (see article #155). If the game stutters only online and the frame time graph shows nothing wrong, the cause may be network delay rather than anything in the machine (see article #229). And if the stutter appears only while a video is playing on a second monitor, that is its own branch (see article #240).

The case in this guide is the consistent one: the average frame rate is high, the number barely moves, and yet the game keeps hitching at irregular moments from the start of the session to the end. That shape points at the distribution of frame times, not at the average — and that is why the average frame rate is the wrong tool for this problem.

Why average FPS hides the problem

Frames per second is an average. It is calculated as 1000 divided by the average frame time in milliseconds. At 60 FPS, each frame takes 16.6 milliseconds on average. At 144 FPS, each frame takes about 6.9 milliseconds on average. The word "average" is doing a lot of work in those sentences, and it is exactly where the problem hides.

An average erases the slow frames. Imagine ten frames that each take 7 milliseconds, followed by one frame that takes 30 milliseconds. The average frame rate across those eleven frames is still above 100 FPS, and the counter will report a healthy number. But that one 30-millisecond frame is a visible hitch — the picture freezes for a moment, then jumps. Your eye notices the single slow frame; the average does not.

This is the first idea to carry through the whole guide: smoothness is a property of how evenly frames arrive, not of how many arrive per second. A steady 90 FPS, where every frame takes about 11 milliseconds, usually feels smoother than an average of 140 FPS where frame times jump between 4 and 30 milliseconds. The higher number can feel worse, because the feeling comes from the worst frames, not from the average.

That also explains why the usual advice for a low frame rate does not apply here. Lowering the graphics settings or buying a faster card raises the average, but if the hitches come from something that happens once in a while — a shader being compiled, an asset being loaded, a background program stealing processor time — raising the average does not remove those events. The spikes stay, and the game still feels jerky. The diagnosis has to start from the spikes, not from the average.

What 1% Low and 0.1% Low actually measure

To talk about the worst frames, reviewers and diagnostic tools use two figures: 1% Low and 0.1% Low. They are worth defining carefully, because they are easy to misunderstand.

Take all the frames recorded over a period of play. Sort them from slowest to fastest. Take the slowest 1 percent and average them, then convert that average frame time back into a frame rate. That is the 1% Low. Do the same with the slowest 0.1 percent and you get the 0.1% Low. Both figures describe how bad the worst moments are, not how fast the game usually runs. A high average FPS with a much lower 1% Low is the numerical signature of micro-stutter: most frames are fast, and a small number of frames are slow enough to be felt.

Two warnings belong with the definition. First, 1% Low is not the minimum frame rate. The minimum is a single frame — the single slowest one — and it can be an outlier caused by something as trivial as a window losing focus for a moment. The 1% Low averages the slowest hundredth of all frames, which makes it a more stable measure of the worst moments. The 0.1% Low sits closer to the worst moments still, because it averages a smaller, slower slice. Do not read any of these figures as "the lowest FPS the game reached"; they are averages of the slowest frames, and that distinction matters when comparing numbers.

Second, different tools calculate 1% Low differently. Some average the slowest 1 percent of frames; others take the 99th-percentile frame time and convert it to FPS. The same set of recorded frames can therefore produce different numbers in different tools. That means the figures can only be compared within the same tool, in the same scene, on the same machine. A 1% Low from one tool and a 1% Low from another tool are not comparable, and neither one can be judged against a universal standard — there is no single number that counts as "good" across every game, every tool, and every scene. What you can do is compare your own average FPS with your own 1% Low, measured with the same tool in the same scene, and look at the size of the gap between them. A wide gap is the evidence. The absolute numbers are not.

Reading a frame time graph

The most useful diagnostic tool for this problem is a frame time graph: a line chart where the horizontal axis is time and the vertical axis is the time each frame took, in milliseconds. Two tools that can produce one are MSI Afterburner with RTSS, which can show a live frame time readout, and CapFrameX or Intel PresentMon, which can record a stretch of play for later inspection. No previous guide on this site has taught readers how to read such a graph, so this section is the core of the article.

A healthy frame time graph is a fairly flat line with small, regular ripples. A stuttering game shows one of two shapes, and the shape decides the direction of the investigation:

Shape one: isolated spikes. The line runs flat and thin, and then, every so often, a single tall spike shoots upward and comes straight back down. The spikes are separate events. Each one is a moment when something interrupted the normal flow of frames — a shader being compiled, an asset being streamed in, a background program grabbing the processor, a driver interrupt. The flat line between the spikes says the game itself is running well; something is interrupting it from outside the frame-by-frame rendering.

Shape two: a persistently rough line. The line never settles. It is thick, noisy, and bouncing up and down the whole time, with no clear flat sections and no isolated spikes. That shape says the unevenness is continuous, not episodic: the game is struggling on every frame, and the cause is something that is wrong all the time — a processor bottleneck, a driver problem, or a sync setting that does not match the display.

Learning to tell these two shapes apart is the decisive skill in this guide. Everything after this point is a matter of following the shape to its branch.

The five common sources of isolated spikes

When the graph shows isolated spikes, one of five causes is usually behind them. Each has a characteristic fingerprint.

Shader compilation. Modern games built on DirectX 12 or Vulkan, especially those using Unreal Engine 5, compile shaders when an effect is used for the first time. The first time a particular effect appears on screen, the driver has to compile a shader program on the spot, and the frame that waits for it takes much longer than the others. The fingerprint is unmistakable: the hitch happens the first time you enter a scene or trigger an effect, and it does not happen again when you walk the same path a second time, because the compiled shader is cached. This is covered in depth by article #161, which is about the stutter at the start of a game or when entering a new area; this guide borrows only the "first time it stutters, second time it does not" test.

Asset streaming, or traversal stutter. Open-world games load new assets as you move into a new area: textures, models, sounds. If the storage device is slow, or the game's streaming cannot keep up, the frames that wait for the new data take longer. The fingerprint is that the spikes line up with movement into new territory — crossing a boundary, opening a door into a new zone, turning a corner into an area you have not visited in this session.

A single-core processor bottleneck. Game logic, physics, and AI often run on one processor core. If that core is fully loaded, the graphics card has to wait for instructions, even though the card itself is not busy. The fingerprint is a graphics card usage figure that stays well below full load while one processor core sits at or near 100 percent. The card is waiting, not working.

Video memory overflow. If the game asks for more video memory than the card has, data has to be fetched from system memory instead, which is far slower. The fingerprint is spikes that arrive together with textures visibly popping in late, and a video memory usage figure that sits at the card's full capacity. This branch is covered in depth by article #281, which separates a capacity overflow from bandwidth and compute limits; this guide borrows only the "spikes plus full video memory plus texture pop-in" pattern.

Background interference and DPC latency. Background programs, antivirus scans, Windows updates, and driver interrupts can all take processor time away from the game at irregular moments. The fingerprint is spikes that appear at random, with no connection to what is happening in the game — not tied to entering a new area, not tied to a particular effect, just scattered through the session.

The sync layer

One more layer can make frame delivery uneven: the synchronisation settings. An uncapped frame rate, VSync used without a variable refresh rate display, or a frame rate cap set above the display's refresh rate can all produce uneven frame spacing. This layer is one of the five causes above, not the whole story, and it is covered in depth by articles #155 and #225, which deal with synchronisation settings and frame rate caps. This guide notes it only as a branch to check: if the graph is persistently rough rather than spiky, and the processor and temperature figures look normal, the sync settings are the next place to look. Turning VSync on does not fix every kind of stutter, and it can add input delay, so it should not be treated as a general cure.

The measurement method, in order

Run these steps in the order given. Each one narrows the field, and the order matters: the early steps establish what shape you are dealing with, and the later steps only make sense once the shape is known.

Step 1: Turn on a frame time display

Open MSI Afterburner with RTSS and enable the frame time readout in milliseconds — not just the FPS counter. Alternatively, record a stretch of play with CapFrameX or Intel PresentMon and open the frame time graph afterwards. From this point on, judge the game by the frame time graph, not by the FPS number. If you only watch the FPS counter, you are watching the number that hides the problem.

Step 2: Walk the same scene twice

Pick a fixed route through the game — the same road, the same room, the same sequence of actions — and walk it twice. Compare the first run with the second. If the second run is smooth where the first one hitched, the cause is something that only happens the first time: shader compilation or a shader cache being built (see article #161). If both runs hitch in the same places, the cause is something that happens every time you pass through, which points at streaming or a load-related problem instead.

Step 3: Read the shape of the graph

Look at the graph and decide which of the two shapes it shows: isolated spikes on a flat line, or a persistently rough line. This is the fork in the road. Everything after this step follows the branch you have identified.

Step 4: If the graph shows spikes, find out when they happen

Match each spike to what was happening in the game at that moment. Spikes that line up with entering a new area or triggering a new effect point at shader compilation or asset streaming. Spikes that appear at random, with no connection to the game, point at background interference. Spikes that arrive together with textures popping in late and video memory usage sitting at full capacity point at video memory overflow (see articles #156 and #281).

Step 5: If the graph is persistently rough, check the load figures

Look at the graphics card usage and the processor usage together. If the card usage stays low while one processor core is fully loaded, the bottleneck is on the processor side (see article #137, which covers processor versus graphics card bottlenecks). If the card usage is high and the temperature or power figures are at their limits, the card is being held back by heat or power (see articles #134 and #279). If neither of those patterns appears, the sync settings are the next branch to check (see articles #155 and #225).

Step 6: Run the comparison tests

Two simple comparisons separate a graphics card load problem from everything else. First, lower the resolution or the graphics quality and repeat the same route. If the spikes disappear, the problem follows the graphics load. If the spikes stay exactly the same, the problem sits in the processor, the streaming, or the driver layer, and changing graphics settings will not help. Second, close background programs — including a browser with hardware acceleration — and run the same route again. If the random spikes are gone, a background program was stealing processor time.

Which branch is it? A comparison table

The checks above produce a pattern, and the pattern points at the branch. Read the row that matches your results.

Graph shapeWhat you findWhat it meansWhat to do next
Isolated spikes, second run smoothHitches on the first pass through a scene, gone on the secondShader compilation or a shader cache being builtLet the cache build; this is expected behaviour for a first pass, covered by article #161
Isolated spikes, tied to new areasSpikes when entering new territory, textures arriving lateAsset streaming from storage cannot keep upCheck storage speed and background disk activity; reduce texture streaming load
Isolated spikes, random timingSpikes with no connection to the game, scattered through the sessionBackground programs or driver interrupts stealing processor timeClose background programs and repeat the test; check for scheduled scans or updates
Isolated spikes, video memory fullSpikes with texture pop-in and video memory usage at capacityVideo memory overflow, data fetched from slower system memoryLower texture quality or resolution; see article #281 for the full distinction
Persistently rough, card usage lowOne processor core fully loaded while the card waitsSingle-core processor bottleneckSee article #137; the card is not the limiting part
Persistently rough, card usage highCard at its temperature or power limitHeat or power limit holding the card backSee articles #134 and #279; check cooling and power delivery
Persistently rough, loads look normalNo clear load or temperature patternSync settings may not match the displaySee articles #155 and #225 for VSync, variable refresh rate, and frame rate caps

Common mistakes

Four misunderstandings come up repeatedly with this symptom, and each one wastes time in its own way.

"High FPS means the game is smooth." Wrong. Average FPS says nothing about how evenly frames arrive. A game can average 140 FPS and still feel jerky if a small number of frames take far longer than the rest. Judge smoothness by the frame time graph and by the gap between average FPS and 1% Low, not by the headline number.

"A faster graphics card will fix it." Wrong, when the spikes do not follow graphics performance. If the spikes come from shader compilation, asset streaming, or a processor bottleneck, a stronger card will not remove them, because the card was never the part doing the waiting. A new card is only worth considering when a cross-check — such as the lower-resolution test in step 6 — shows the problem actually follows graphics load. This is the anti-misleading core of this guide: the card is one branch among several, not the default answer.

"1% Low figures can be compared across tools." Wrong. Different tools calculate 1% Low differently, so the same recorded frames can produce different numbers. Compare only figures from the same tool, in the same scene, on the same machine, and compare the gap between your own average FPS and your own 1% Low rather than any absolute value.

"Turning VSync on fixes all stutter." Wrong. Synchronisation settings address one layer only, and they can add input delay. If the spikes come from shader compilation or streaming, VSync changes nothing about them. See article #155 before changing sync settings as a cure-all.

Boundaries: when it is not this problem

A few neighbouring symptoms deserve a separate mention, because they are easy to confuse with this one.

If the frame rate itself is low or drops sharply, that is article #136, not this guide. If the frame rate gets gradually worse the longer you play, that is article #356, and the decisive test there is what happens immediately after a restart while the machine is still warm. If the picture shows a horizontal tear line, that is article #155. If the game stutters only online and the frame time graph shows no matching spikes, the cause is network delay, covered by article #229 — the frame time graph will not show a corresponding spike for a network problem, which is itself the distinguishing test. If frame generation is turned on and the game feels different — smoother in motion but delayed in response, with smearing on fast turns — that is article #175, and this guide does not cover frame generation. If the stutter appears only at the start of a game or when entering a new area, and the "first time it hitches, second time it does not" test is positive, article #161 covers shader compilation in depth.

One more warning that applies to every guide in this series: a restart that makes the problem go away has not fixed anything. A restart clears temporary state; it is not a repair. If the spikes return on the next session, the cause is still there, and the checks above are still the way to find it.

What to do next

Work through the six steps in order, and write down what each one showed. The pattern of results is the diagnosis: isolated spikes that vanish on a second pass, spikes tied to new areas, random spikes that disappear when background programs are closed, a persistently rough line with one processor core fully loaded — each of these points at its own branch in the table above.

If the checks point at a hardware fault — a card that overheats under any load, a card that cannot hold its rated performance after the cooling and power checks in articles #134 and #279 — or if the results are unclear after working through the decision tree, the next step is a professional inspection rather than further adjustment. The shop charges for inspection according to the published three-tier rates of HK$400–2,800, with the actual figure confirmed after inspection. The shop is at Room 1209, Dali Plaza, Shek Mun; telephone 2186 8010; WhatsApp 6558 6806. There is no home-visit service.

Frequently asked questions

My FPS counter says 140 but the game feels jerky. Is the counter wrong?

No. The counter is reporting the average correctly, and the average is hiding the problem. A small number of slow frames — one frame taking 30 milliseconds among many taking 7 — moves the average far less than the hitch feels, but your eye notices each slow frame as a hitch. Turn on a frame time display and look at the graph instead of the FPS number.

What is 1% Low, exactly?

It is the average frame rate of the slowest 1 percent of frames over a period of play. It measures how bad the worst moments are, not how fast the game usually runs. It is not the minimum frame rate: the minimum is a single frame, while 1% Low averages the slowest hundredth of all frames. The 0.1% Low averages an even smaller, slower slice, and sits closer to the very worst moments.

Can I compare my 1% Low with a figure from a review or a friend's machine?

Only with great caution. Different tools calculate 1% Low differently, so the same recorded frames can produce different numbers. Compare only figures from the same tool, in the same scene, on the same machine, and focus on the gap between your own average FPS and your own 1% Low rather than on any absolute value. There is no universal number that counts as good across every game and every tool.

The game stutters the first time I enter an area, then it is smooth. Is that a fault?

Usually not. That pattern — first pass hitches, second pass smooth — is the fingerprint of shader compilation or a shader cache being built, and it is expected behaviour for a first pass in games that compile shaders on demand. Article #161 covers it in depth. If the hitches return on every pass through the same area, the cause is something else, and the checks in this guide apply.

Will a faster graphics card fix micro-stutter?

Not necessarily, and often not at all. If the spikes come from shader compilation, asset streaming, or a processor bottleneck, the card was never the part doing the waiting, and a stronger card will not remove the spikes. Run the comparison test first: lower the resolution and repeat the same route. If the spikes disappear, the problem follows graphics load; if they stay the same, the cause sits elsewhere, and a new card will not help.

Will turning VSync on fix the stutter?

Not as a general cure. VSync and variable refresh rate settings address the synchronisation layer only, and they can add input delay. If the spikes come from shader compilation, streaming, or background interference, changing sync settings changes nothing about them. Articles #155 and #225 cover sync settings in depth.

The game only stutters when I play online. Is this the same problem?

Not necessarily. Network delay can make an online game feel jerky even when the local frame time graph is clean — the frame time graph will not show a matching spike for a network problem, which is itself the distinguishing test. See article #229 for network delay.

Related articles

Related services

If you need Chip-level GPU repair, see these service pages: