Frame pacing is the consistency of the intervals at which a game presents finished frames to the display, measured as the variation in frame time from one frame to the next. In gaming performance, it explains why two systems with the same average frame rate can feel very different: a game running at 60 fps with perfectly even 16.7 ms intervals looks smooth, while one that alternates between 8 ms and 25 ms frames at the same average looks jerky and uneven.
Good frame pacing means each frame stays on screen for roughly the same duration and represents a matching step of simulated game time. Poor frame pacing produces judder, microstutter and visible hitches even when a frame counter reports a healthy number, which is why reviewers and engine developers now treat it as a separate quality metric alongside raw frame rate.
How frame pacing works in the rendering pipeline
Frame pacing results from how the CPU, GPU and display hand work to one another. The CPU runs game logic and records draw calls, the GPU renders the frame, and the swap chain presents it at a refresh boundary or, with VRR, at the moment it is ready. Any stage that finishes irregularly passes its irregularity downstream.
Two timelines must stay aligned. The simulation timeline decides which moment of game time a frame depicts, and the presentation timeline decides when the player actually sees it. When a frame showing 16 ms of motion is displayed for 33 ms, or the reverse, objects appear to speed up and slow down even if every frame is rendered correctly. Engines therefore try to sample game time at a predicted display moment rather than at the moment work begins.
The following table lists the main pipeline stages and how each one can disturb pacing.
| Stage | Role | Typical pacing disturbance |
|---|---|---|
| Game thread (CPU) | Simulation, input, scripting | Garbage collection, streaming, AI spikes |
| Render thread (CPU) | Draw call submission | Shader compilation, driver overhead |
| GPU | Rasterization, shading, post-processing | Load spikes from effects or scene changes |
| Render queue | Buffers frames between CPU and GPU | Uneven queue depth, added latency |
| Display | Scans out frames at refresh intervals | Missed vsync deadlines, repeated frames |
Measuring frame pacing with frame time data
Frame pacing is measured with per-frame timing logs, not with an fps average. Capture tools record the time between consecutive presents, which yields a frame time graph; a flat line indicates good pacing and a sawtooth or spiky line indicates poor pacing. Percentile metrics such as 1% lows and 0.1% lows summarize the worst frames in a run.
Different metrics answer different questions, so analysts combine several of them, as the table below shows.
| Metric | What it captures | Limitation |
|---|---|---|
| Average fps | Overall throughput | Hides uneven intervals entirely |
| 1% and 0.1% lows | Severity of the slowest frames | Ignores alternating patterns at high fps |
| Frame time variance | Spread of intervals around the mean | Sensitive to run length and scene |
| Frame-to-frame delta | Size of consecutive changes | Requires raw per-frame data |
| Displayed frame time | What the screen actually showed | Needs display-side or hardware capture |
The distinction between presented and displayed frames matters. Software tools see when the game called present, but with vsync or a compositor the screen may show the frame later. Hardware capture with a camera or an analysis card reveals dropped and runt frames that software logs miss, which was historically important for multi-GPU configurations.
Frame pacing compared with related performance concepts
Frame pacing overlaps with several neighboring terms but describes a specific property: regularity over time. Frame time is the raw measurement, stutter is a visible symptom, and input lag is a separate latency dimension that can worsen even while pacing improves.
| Concept | Definition in brief | Relation to frame pacing |
|---|---|---|
| Frame time | Duration of one frame in milliseconds | The data from which pacing is judged |
| Stutter | Visible hitch or pause in motion | A symptom of a severe pacing failure |
| Input lag | Delay from input to visible response | Deeper queues can smooth pacing yet add lag |
| VRR | Display refresh that follows the GPU | Masks small variations, cannot fix large spikes |
| Frame rate cap | Upper limit on rendered fps | Often the simplest way to even out intervals |
A frequent misconception holds that variable refresh rate solves pacing. G-SYNC and FreeSync remove tearing and the quantization of vsync, so a 50 fps frame is shown for 20 ms instead of alternating between 16.7 ms and 33.3 ms. However, if the game itself produces a 10 ms frame followed by a 40 ms frame, the display faithfully shows that unevenness in the source.
Causes of poor frame pacing and how to fix them
Poor frame pacing has identifiable causes, and each one leaves a characteristic pattern in the frame time graph. Diagnosing the pattern first prevents random changes to settings that address the wrong bottleneck.
| Symptom | Likely cause | Typical remedy |
|---|---|---|
| Single large spikes | Shader compilation, asset streaming | Precompiled shader cache, faster storage |
| Regular alternating intervals | Frame rate just below refresh with vsync | Cap at a divisor of refresh or enable VRR |
| Gradually rising frame times | Memory leak or thermal throttling | Driver or game patch, better cooling |
| Constant noisy jitter | CPU bottleneck, background processes | Lower CPU-heavy settings, close tasks |
| Judder in cutscenes or 30 fps modes | Mismatched simulation and display timing | Engine-side pacing fix, correct cap |
The most effective user-side tool is a frame rate cap set slightly below the sustainable minimum. When the GPU and CPU always finish early, every frame waits for the same deadline and intervals become nearly identical. On VRR displays, capping a few frames below the maximum refresh keeps the game inside the variable refresh window and avoids the latency penalty of vsync.
- In-engine limiters usually pace better than external ones because they control simulation timing directly.
- Latency-reduction modes such as NVIDIA Reflex shorten the render queue and can tighten pacing in GPU-bound scenes.
- Dynamic resolution scaling trades image sharpness for steadier GPU frame times under fluctuating load.
Frame pacing on consoles and fixed refresh displays
Console games commonly target 30, 40 or 60 fps on displays that refresh at 60 or 120 Hz, so correct pacing requires each frame to occupy an equal number of refresh cycles. A 30 fps game on a 60 Hz screen must show every frame for exactly two refreshes; a pattern of one, three, two, two refreshes keeps the 30 fps average but produces obvious judder.
The 40 fps mode on 120 Hz displays works because 120 divides evenly by 40, giving each frame three refreshes and a 25 ms interval. Platform holders provide pacing APIs and certification guidelines, but pacing bugs still ship, and they are often fixed in patches once players capture frame time data that exposes the irregular cadence.
Explained without jargon
Imagine a flip book. If every page is turned at exactly the same speed, the drawing moves smoothly. If some pages flip quickly and others linger, the motion looks shaky, even when the total number of pages per second stays the same. Frame pacing is that rhythm in a video game.
A game counter might proudly report 60 frames per second, but that number is only an average. What your eyes notice is whether the pictures arrive at a steady beat. A slightly lower but perfectly even frame rate often feels smoother than a higher, uneven one.
A typical use case
A player with a 144 Hz monitor without variable refresh notices that an open-world game feels rough despite an on-screen counter showing about 70 to 80 fps. A frame time capture reveals intervals jumping between 6.9 ms and 13.9 ms as vsync rounds each frame to whole refresh cycles, plus occasional spikes of 60 ms when new areas stream in.
The player sets an in-game limit of 72 fps, exactly half the refresh rate, so every frame occupies two refresh cycles and a constant 13.9 ms interval. After installing the game on an NVMe drive and letting the shader cache build during a first session, the large spikes become rare. The average frame rate is slightly lower than before, yet the frame time graph is almost flat, and traversal now looks consistently smooth.