When the display and the GPU disagree
A display refreshes on a fixed clock. A GPU finishes frames on its own schedule. When those two events fall out of phase, the display reads from a buffer mid-update — part of the old frame, part of the new one, divided by a horizontal tear line that tracks across the screen with each mismatch.
Vsync eliminates the tear by forcing the GPU to wait. The frame is held until the display signals the start of a new refresh cycle — the vertical blanking interval, a legacy of CRT electron guns that still sets the rhythm of modern panels. The GPU then presents the completed frame in one clean swap. No torn edge, no partial image.
How presentation modes map
FROM THIS ENTRY| VK_PRESENT_MODE_FIFO_KHR | strict vsync; frame waits for next blanking interval |
|---|---|
| VK_PRESENT_MODE_FIFO_RELAXED_KHR | vsync, but if a frame is late it presents immediately (may tear once) |
| VK_PRESENT_MODE_MAILBOX_KHR | low-latency vsync; queue of one, new frame replaces waiting one, GPU never stalls |
| VK_PRESENT_MODE_IMMEDIATE_KHR | no wait, no sync; tears freely |
The cost is latency and, depending on framing, throughput. If a frame completes slightly after the blanking interval, it waits an entire refresh period to be shown. At 60 Hz that means up to 16.7 ms of additional delay on top of whatever the GPU already took. A frame that costs 17 ms to render effectively takes 33 ms to appear. The one-percent low figures collapse; where the milliseconds go becomes partly a story about waiting for a clock the game does not control.
Inside a compatibility layer the situation adds a wrinkle. The layer may run a translation path — DirectX calls becoming Vulkan or Metal or whatever the host system offers — and present timing is negotiated at the translated API's level, not the original one. The program signals its intent to present; the layer decides how and when that reaches the compositor. On a Wayland desktop the layer cannot write directly to the display at all; presentation goes through a compositor that imposes its own vsync logic, and the game's own synchronisation setting becomes advisory at best.
Adaptive sync changes the maths by letting the display stretch or compress its refresh interval to meet the GPU. Tear-free without the wait. Frames arrive; the display moves to catch them. The original protocol, developed under the FreeSync name by AMD and standardised as DisplayPort Adaptive-Sync, works at the hardware and driver level. A compatibility layer that does not surface the right presentation hints to the host driver may bypass adaptive sync entirely, falling back to fixed vsync even when the hardware could do better. The flag exists in Vulkan's swap chain creation — VK_PRESENT_MODE_MAILBOX_KHR for low-latency vsync, VK_PRESENT_MODE_FIFO_RELAXED_KHR for adaptive-sync-style behaviour — and a layer that hardcodes FIFO is quietly leaving performance on the table.
Triple buffering keeps the GPU rendering continuously rather than stalling on the wait, reducing the throughput loss, though it adds a frame of pipeline depth and does nothing about the latency spike at the refresh boundary. It is a mitigation, not a fix.
Shimwork is an independent publication about compatibility layers. It is not a software vendor, distributor, or support service.