Stutter: 60 causes and who fixes them

Also called: choppy, hitching, feels like frame drops

Movement isn’t smooth: it keeps pausing briefly and moving again.

Other characters or your whole screen keep hitching. The trail dots bunch up and spread apart.

If ping looks normal, the likely cause is frame timing on your PC (client or OS); if ping jumps around, jitter on Wi-Fi or the connection is more likely. Keep in mind that most in-game ping readouts are measured inside the game loop, which runs once per frame, so a frame spike can make the ping number spike too.

Causes of this symptom

L1 Client game process

Frame time spike: One frame takes several times longer than usual to compute, so the screen freezes for a moment. (Game team (Client development))
Client garbage collection: The whole game freezes while it reclaims memory that was used and thrown away (garbage). The telltale sign is stutter at regular intervals. (Game team (Client development))
Synchronous loading and shader compilation on the main thread: The game freezes to read files and build shaders right before it draws an area, monster, or effect for the first time. (Game team (Client development))
Slow storage delays asset streaming: On slow storage such as an HDD, reading open-world textures and models can’t keep up with movement, so objects appear late or the game stutters while it waits for reads. (Game team (Client development))
Rendering load from large crowds: When hundreds of players fill one screen, as in a siege or a world boss fight, the cost of drawing them is more than the device can handle. (Game team (Client development))
Missing or too-short interpolation buffer: If the client draws server packets the moment they arrive, jitter (variation in packet arrival times) shows up directly on screen. (Game team (Client development))
Excessive extrapolation (dead reckoning): While no packets arrive, the client keeps showing characters moving at their last velocity, then snaps them back when it turns out to be wrong. (Game team (Client development))
Fixed-timestep catch-up spiral: After one stall, the game runs its backlog of calculations all at once, and that extra work puts it behind again. (Game team (Client development))
Clock sync error: If the client’s estimate of the server time is wrong, interpolation timing and cooldown checks drift out of step with the server. (Game team (Client development))
Float time precision loss: If the game keeps its clock in a low-precision floating-point type (float), the longer it runs, the worse its time resolution (the smallest time difference it can tell apart) becomes, and movement and effects start to shake. (Game team (Client development))
V-Sync and the render queue: Input is delayed while several finished frames wait in a queue to be sent out in step with the monitor’s refresh. (Game team (Client development))
Client memory leak: The longer the game stays open, the more memory it uses; it gets slower and slower until the game is eventually force-closed. (Game team (Client development))
Anti-cheat scans: The anti-cheat module that runs alongside the game to block cheats scans the system periodically. If a scan is heavy, or the heartbeat (a periodic keepalive signal) to the anti-cheat server is late, the game stutters or disconnects. (Game team (Client development))

L2 Client OS and device

Background processes taking up CPU: When an antivirus scan, Windows Update, streaming software, or a browser video takes over CPU cores, the game thread has to wait for CPU time. (External (External))
Power saving and thermal throttling: Laptop battery mode, phone power-saving mode, and device heat slow down the CPU and GPU. With heat, the telltale sign is that the game runs fine at first and slows down only after a while. (External (External))
Timer resolution: Windows’ default timer ticks every 15.6 ms, so “sleep for just 1 ms” actually lasts until the next timer tick, up to 15.6 ms. (Game team (Client development))
Packet inspection by security software: When antivirus software or a firewall inspects every packet, latency goes up, and in bad cases it mistakes the game for an attack and blocks it. (External (External))
Client low on memory and swapping: With dozens of browser tabs open alongside the game, the OS moves part of the game’s memory out to disk. (External (External))
Out of graphics memory (VRAM): When the graphics settings need more memory than the graphics card has, the OS moves textures out to system memory and brings them back, and the game stutters. (Game team (Client development))
Wi-Fi background scanning: Communication pauses briefly while the OS periodically hops across channels to look for nearby Wi-Fi networks. (External (External))
NIC power saving and driver issues: When a network card or Wi-Fi chip enters a power-saving state between packets, it takes time to wake back up. (External (External))
Throttling when the window is minimized or unfocused: When you switch to another window or minimize the game, the game and Windows slow it down to save power. When you come back, the backlog of packets floods in, or you’ve already been disconnected. (Game team (Client development))
Overlay software interference: Chat apps, launchers, recording tools, and FPS counters hook into the game’s rendering to draw their own UI on top of the game screen (hooking). That adds work to every frame and sometimes clashes with the game, causing hitches or crashes. (External (External))

L3 Home network

Wi-Fi interference and weak signal: With a weak signal or interference, packets get resent several times over the wireless link, so they arrive unevenly. (External (External))
Congested Wi-Fi channel: Where there are dozens of routers, as in an apartment building, they share the same channel and have to wait for a chance to transmit. (External (External))
Underpowered or overheating router: When dozens of devices and thousands of connections pile onto a cheap router, the router itself can’t keep up. (External (External))
Weak mobile signal and dead zones: In elevators, basements, and deep inside buildings, retransmissions increase, speed drops, and eventually the connection drops. (External (External))
Frequent 5G↔LTE switching (at 5G coverage edges): Inside buildings with weak 5G signal or at the edge of 5G coverage, the phone switches between 5G and LTE often, and each switch causes a ping spike or a brief dropout. (External (External))

L4 Internet path

Satellite internet (LEO/GEO): Satellite signals have to travel to space and back. With geostationary satellites the round trip alone exceeds 0.5 seconds. Low Earth orbit satellites such as Starlink are usually fast, but latency fluctuates and the link can drop briefly at the moment routes are reassigned. (External (External))
Peak-hour congestion at peering links: Around 9–11 PM, video traffic surges and the links between ISPs (peering) tend to get congested. (Infra team (Network infrastructure))
One faulty ECMP path: ISPs and data centers keep several paths to the same destination and send each connection down one of them. If a single path fails, only the players assigned to it keep lagging. (Infra team (Network infrastructure))

L6 Server network card

Virtualization overhead and noisy neighbors: When other virtual machines on the same physical server use a lot of network or CPU, your server’s processing gets delayed at irregular times. (Infra team (Server infrastructure))

L7 Server OS (kernel)

Too many threads and context switching: Running far more threads than there are cores makes the OS spend CPU just switching between them. (Game team (Server development))
CPU steal (virtual machines): While the physical server (hypervisor) briefly gives a virtual machine’s CPU time to another VM (CPU steal), the game server stalls. (Infra team (Server infrastructure))
Container CPU throttling (CFS quota): With a CPU limit on a container, the moment it uses up its quota within a set period (usually 100 ms), it is forced to stop for the rest of that period (throttling). (Infra team (Server infrastructure))
Stalls from memory reclaim and compaction: The process stalls while the OS compacts memory to build huge pages or reclaims memory to free it up. (Infra team (Server infrastructure))
Scheduled jobs: Log compression, backups, and security scans that run at the same time every day take up CPU and disk. (Infra team (Server infrastructure))
Performance changes after OS, kernel, driver, or firmware updates: The game code hasn’t changed, but the server has been slower since an OS, kernel, driver, or firmware update. Updates can change defaults, the scheduler, CPU vulnerability mitigations, and driver behavior. (Infra team (Server infrastructure))

L9 Server game process

Tick overrun: When one tick has more work than its budget, the server’s tick interval stretches, and the whole area slows down or stutters. (Game team (Server development))
AOI calculation blowup (N²): If you compare everyone against everyone to work out who can see whom, 10 times the players means 100 times the computation. (Game team (Server development))
Blocking calls on the game thread: If the server waits for a DB response or a file write in the middle of a tick, all game progress on the server stops for that long. (Game team (Server development))
Timers firing all at once: When every monster respawn, every buff expiry, and the on-the-hour reward all land on the same tick, that one tick becomes tens of times heavier. (Game team (Server development))
Entity buildup (items and summons never cleaned up): When ground items that should have disappeared, summons, and finished timers pile up without being cleaned up, every tick has more work to do the longer the server stays up. (Game team (Server development))

L10 Memory

Script engine GC pause: Even on a C++ server, if quests, AI, and skills run in a scripting language such as Lua, the zone stops while the script engine’s GC runs. (Game team (Server development))
Allocation surge: Creating large numbers of temporary objects during an event makes GC run far more often than usual. (Game team (Server development))

L11 Disk

Synchronous log writes: If the game thread waits for the disk to finish every log line, the game stalls too whenever the disk is busy. (Game team (Server development))
fsync surge: Asking for data to be written to disk “for sure” takes 0.1 ms to tens of ms per request depending on the disk, and when requests pile up, the queue grows. (Game team (Server development))
Cloud disk out of burst credits: Some cloud disks and small server sizes have burst credits that let them run faster than baseline for a while, so when a busy period drags on and the credits run out, speed drops suddenly. (Infra team (Server infrastructure))
Backup / compression / scan jobs: When early-morning backups, log compression, or security scans monopolize the disk, the game server’s reads and writes get held up. (Infra team (Server infrastructure))

L12 Database

Checkpoint / log flush: Queries slow down at the moments the DB periodically writes its accumulated in-memory changes to disk in bulk. (Infra team (DB infrastructure))

L13 Server architecture and operations

Logging and monitoring overload: During an outage, log volume explodes, and servers that ship logs synchronously get even slower because of the logging. (Game team (Server development))

Netcode design

Lockstep waiting on the slowest player: When everyone computes the same turn together, one player’s late input makes everyone wait. (Game team (Server development))
Events played on arrival without timestamps: If server events carry no timestamp and play as soon as they arrive, network jitter carries straight through into uneven animation timing. (Game team (Client development))
Player-hosted server (host): When one player’s PC acts as the server, that player’s connection and PC performance decide how the game feels for everyone. (Game team (Server development))
Low snapshot send rate: If the server sends position updates (snapshots) only a few times a second, the interpolation buffer has to be that much longer, and you see other characters further in the past. (Game team (Server development))

Problems only some players hit

Per-player input buffer size: If the server holds a few inputs per player and takes out one per tick, others see smooth motion, but your own actions are confirmed on the server that much later. (Game team (Server development))
A lagging client controls the monster: Some games hand monster movement to one nearby player’s client to reduce server load. If that player’s connection is bad, the monster moves strangely on everyone’s screen. (Game team (Server development))
Streaming failure from memory or VRAM shortage: When two clients share graphics memory, there’s no room to load newly needed models and textures, and some of them don’t get drawn. (Game team (Client development))
Entities held back by clock estimate error: If the client’s estimate of the server time is wrong, it holds back freshly arrived entity data as “still in the future” or discards it as “too old.” (Game team (Client development))

Root causes of TCP retransmission

Spurious fast retransmit from reordering: When packets get out of order crossing multiple paths or bundled links, the receiver signals “a packet is missing” with duplicate ACKs, and the sender resends a packet that arrived fine. (Infra team (Network infrastructure))

View the illustrated symptom guide