VSync — what it is, how it works and configuration

What is VSync

VSync (Vertical Synchronization) is a hardware-software mechanism that forces the GPU to wait for the vertical blanking signal (VBlank) before outputting a new frame. Without VSync, the GPU can send frames at any time, even when the display is in the middle of drawing the current frame, causing image tearing along a horizontal line.

On mobile devices, VSync is implemented at the graphics driver and operating system level. iOS uses VBlank synchronization through Metal, Android through SurfaceFlinger and BufferQueue. When vertical synchronization is enabled, the application FPS cannot exceed the display refresh rate — 60, 90, or 120 Hz depending on the device model.

The term vertical synchronization originates from the working principle of CRT monitors, where an electron beam drew the image line by line from top to bottom. After completing a frame, the beam returned to the top-left corner — this moment was called vertical blanking. Modern LCD and OLED displays have retained this term, although they work physically differently.

How Vertical Synchronization Works

The GPU renders frames into the back buffer, while the display reads from the front buffer. VSync ensures that buffer swapping occurs only during VBlank — when the display has finished showing the current frame and is ready for the next one. This mechanism is called double buffering with VBlank synchronization.

Double Buffering Mechanism

Double buffering uses two buffers: a front buffer displayed on the screen and a back buffer into which the GPU writes the current frame. When the frame is ready, the buffers are swapped. With VSync enabled, this swap is deferred until the nearest VBlank. The GPU idles if the frame is ready before VBlank, reducing performance but eliminating tearing.

// OpenGL — enabling VSync via WGL_EXT_swap_control
HDC hdc = wglGetCurrentDC();
PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT =
    reinterpret_cast<PFNWGLSWAPINTERVALEXTPROC>(
        wglGetProcAddress("wglSwapIntervalEXT"));
wglSwapIntervalEXT(1); // 1 = VSync enabled, 0 = disabled

VBlank Wait Time

VBlank is a short interval between the last line of the current frame and the first line of the next frame. During this moment, the display does not update pixels, and buffer swapping occurs without artifacts. The VBlank duration depends on the refresh rate: at 60 Hz on a 1080p display, VBlank lasts approximately 1.4 ms. If the GPU fails to complete rendering before VBlank, the frame is skipped, and the display shows the previous frame for another cycle — this is perceived as stutter.

Triple buffering solves the GPU idle problem by adding a third buffer. The GPU can start rendering the next frame immediately even if one of the back buffers is waiting for VBlank. This increases FPS with VSync but adds an extra frame of latency. On mobile devices, triple buffering is used in some game engines and in Vulkan through Mailbox mode.

Main Problems Without VSync

Disabled VSync provides maximum FPS and minimal input lag, but at the cost of visual artifacts. For mobile games and applications with smooth animation, the choice between VSync and disabling it is a trade-off between image clarity and control responsiveness.

Screen Tearing

Screen tearing is a horizontal split where the top part of the screen shows the previous frame and the bottom part already shows the next one. This occurs when the GPU swaps buffers mid-scanout. On mobile devices, tearing is especially noticeable during fast scrolling or in dynamic scenes with high frame rates. OLED displays with their instant response make tearing more contrasty compared to LCD.

Tearing intensity depends on the FPS-to-refresh-rate ratio. At 60 FPS on a 60 Hz display, tearing appears as a single static line, while at 300 FPS on 60 Hz, it appears as multiple wavy tears moving from top to bottom. The higher the FPS relative to the refresh rate, the more tears and the more noticeable they become.

Input Lag

Input lag with VSync is the delay between pressing a button and seeing the result on screen. Vertical synchronization adds on average one frame of latency (16.7 ms at 60 Hz), and with triple buffering — up to two frames. For casual applications, this delay is imperceptible, but for shooters, fighting games, and rhythm games, it is critical: professionals notice delays even as small as 8 ms.

According to NVIDIA (2024) research, the average input lag in CS:GO at 60 FPS without VSync is 22 ms, and with VSync — 39 ms. At 144 FPS, the difference narrows to 14 vs 18 ms respectively. On mobile platforms, VSync input lag is less critical due to touch input, where the hardware touchscreen latency (10–30 ms) masks the additional synchronization delay.

Configuring VSync in Mobile Development

In mobile development, VSync is controlled through graphics APIs, game engines, and OS system settings. iOS provides less control, Android provides more through Vulkan and OpenGL ES. The choice of mode depends on the application type: games, UI, or video.

VSync in Unity and Unreal Engine

Unity uses the QualitySettings.vSyncCount setting: 0 — disabled, 1 — VSync every VBlank, 2 — every second VBlank (FPS halved). In Unreal Engine, VSync is controlled through the r.VSync console command and DefaultEngine.ini. For mobile builds, it is recommended to disable VSync in Unity and use a custom FPS limiter, since the built-in VSync in Android SurfaceFlinger can create unpredictable delays.

// Unity — controlling VSync and FPS
void Awake()
{
    // 0 = VSync disabled, 1 = VSync enabled
    QualitySettings.vSyncCount = 0;
    // Custom FPS limiter instead of VSync
    Application.targetFrameRate = 60;
}

VSync in Vulkan and Metal

Vulkan provides full control through VkSwapchainPresentInfo and presentMode: VK_PRESENT_MODE_FIFO_KHR — classic VSync, VK_PRESENT_MODE_MAILBOX_KHR — triple buffering without waiting, VK_PRESENT_MODE_IMMEDIATE_KHR — no synchronization. Metal in iOS controls VSync through CAMetalLayer.displaySyncEnabled. Starting with iOS 14, Apple recommends using displaySyncEnabled = true by default for all applications except arcade-style games.

FPS Limiting Without VSync

FPS limiter is an alternative to VSync where the application limits the frame rate programmatically without waiting for VBlank. This approach provides predictable latency and does not depend on the display refresh rate. On Android, FPS limiting is implemented through Choreographer, on iOS — through CADisplayLink with manual output timing control.

VSync and Modern Synchronization Technologies

Traditional VSync has a fundamental drawback: it is tied to a fixed display refresh rate. If the GPU outputs 45 FPS on a 60 Hz display, VSync cannot show 45 frames — it shows 30 (skipping every second VBlank) or alternates between 60 and 30 with uneven intervals. This creates stutter, which spoils the gaming experience more than tearing.

Adaptive Sync (FreeSync, G-Sync, Apple ProMotion) solves this problem by dynamically changing the display refresh rate according to the application FPS. If the application outputs 47 FPS, the display switches to 47 Hz — each frame is displayed exactly once, without tearing or stutter. ProMotion on iOS automatically selects a frequency from 24 to 120 Hz, balancing smoothness and power consumption.

On mobile devices, Adaptive Sync is becoming the standard: iPad Pro (2017+) with ProMotion, Android flagships with LTPO displays (Samsung Galaxy S23 Ultra, Google Pixel 8 Pro) support dynamic refresh rates from 1 to 120 Hz. For developers, this means that VSync in the traditional sense is replaced by system management — it is enough to set targetFrameRate, and the OS itself adjusts the refresh rate for the optimal balance of smoothness and battery life.