The Windows latency bible: every millisecond from click to photon (2026)

The chain: click to photon in eight stages

End-to-end latency on a stock 240Hz esports setup typically lands between 25 and 45ms. It breaks down roughly like this: device polling and debounce (0.1–2ms), USB transfer and interrupt handling (0.1–1ms), OS input processing (0.5–2ms), game simulation pickup (0–1 frame), render queue (0–3 frames — the big one), GPU render time (2–8ms), present and scanout (0.5–1 frame), and finally pixel response (0.5–4ms).

Notice where the fat is: the render queue and scanout stages, measured in whole frames, dwarf everything else. That's why a mouse upgrade feels like nothing while a frame cap changes your life — people optimize the milliseconds they can buy instead of the frames they can configure.

Stage 1–2: polling, debounce and the 8000Hz question

At 1000Hz your input is sampled every 1ms, so the average sampling delay is 0.5ms and the worst case is 1ms. 8000Hz cuts that to 0.06ms average — a real but small win, and it comes with a CPU cost: every poll is an interrupt, and in CPU-bound games on mid-range chips, 8k polling can cost more frame time than its sampling gain is worth.

The honest advice: 1000Hz is the floor for everyone. Go 8000Hz on a strong CPU (or in GPU-bound titles) and drop to 2000–4000Hz if frame times get noisier after the switch. Every device also has a hardware maximum — no software setting pushes a 1000Hz-max controller or keyboard past its silicon.

• 1000Hz minimum, always — the 125Hz default costs up to 8ms of sampling delay
• 8000Hz: worth it on strong CPUs; test frame times before and after
• Debounce: optical switches skip it entirely (~0.5–5ms saved vs mechanical)

Stage 3: interrupts, MSI mode and timer resolution

When a USB packet lands, the controller raises an interrupt and Windows decides which core services it. Two failure modes cost latency here: legacy line-based interrupts that share vectors (fixed by MSI/MSI-X mode, which most modern drivers support but some don't enable), and interrupt storms landing on the same core the game's main thread occupies.

Timer resolution is the other lever. Windows coalesces timers to save power; a game asking to sleep 1ms can oversleep by several. Modern titles request high resolution themselves, but background power settings can veto them — the High Performance power plan exists precisely to stop that veto.

• MSI mode on GPU + NIC + USB controllers
• High/Ultimate Performance power plan — not for the clocks, for the timers
• Park background load away from the game: close per-frame overlays first

Stage 4–5: the render queue is where games hide frames

When the GPU runs at 99–100% load, the CPU races ahead and queues finished frames — one to three of them. At 240fps, every queued frame is 4.2ms of latency you chose by leaving FPS uncapped. This queue is the single largest tunable latency source on most systems.

Three tools drain it: a frame cap a few frames under your refresh (or under your GPU's sustainable output), NVIDIA Reflex / AMD Anti-Lag+ which dynamically pace the CPU to keep the queue near zero, and — bluntly — lower settings so the GPU never saturates. Reflex plus a sane cap routinely removes 10–20ms on a loaded system.

• GPU at 99% = queued frames = latency. Cap below the saturation point
• Reflex / Anti-Lag+ on in every title that offers it — it's free latency
• Driver low-latency modes are the fallback for games without Reflex

Stage 6–7: present mode, VRR and scanout

How the finished frame reaches the screen matters as much as how fast it rendered. Exclusive fullscreen (or Windows 11's optimized fullscreen with hardware flip) hands the frame straight to the display; borderless windowed through the compositor can add a full frame of delay when it falls off the fast path.

V-Sync alone is a latency disaster (up to two full frames). The modern recipe is VRR (G-Sync/FreeSync) + a frame cap 3–5 below max refresh + V-Sync only as VRR's companion toggle — tear-free without the queue penalty.

Stage 8: the panel itself

Scanout takes one refresh interval top-to-bottom (4.17ms at 240Hz), then pixels still have to change state. A slow VA panel can smear 4ms+ onto every input; a 360Hz OLED effectively deletes this stage. Overdrive settings trade response speed against overshoot ghosting — tune with a UFO test, not marketing numbers.

Measure or it didn't happen

PresentMon (or CapFrameX on top of it) exposes ready-to-present latency and frame-time percentiles; NVIDIA's FrameView adds PC latency for Reflex titles. For true click-to-photon you need hardware — LDAT or a high-speed camera on a muzzle-flash test — but the software metrics track the same direction and are free.

Method matters: same scene, same server, one variable at a time, and judge by the 1% lows and latency percentiles, never the average. If a tweak doesn't move a measured number, it's a placebo — revert it and keep your system simple. The whole chain above is what our bundles automate, fully reversibly.