Causes of DirectX Screen Tearing Without V-Sync

Screen tearing in DirectX applications occurs when the graphics processing unit (GPU) pushes new video frames to the monitor out of sync with the display's physical refresh rate. When Vertical Synchronization (V-Sync) is disabled, the GPU updates the active display buffer mid-scan, causing the monitor to draw portions of two or more different frames within a single refresh cycle. This results in a visible horizontal misalignment across the image, commonly known as a screen tear.

The Mechanics of DirectX Swap Chains

DirectX handles rendering through a mechanism called a swap chain, which typically consists of at least two frame buffers: a front buffer and a back buffer. The front buffer holds the completed frame currently being scanned and projected onto the physical display. Meanwhile, the GPU renders the next upcoming frame into the back buffer.

Once the GPU finishes rendering the back buffer, a presentation call (such as IDXGISwapChain::Present) is issued. This call dictates how and when the back buffer becomes the new front buffer.

Display Refresh Cycles and Scanouts

A standard monitor refreshes its screen by updating pixels sequentially from top to bottom, row by row, at a fixed frequency (such as 60Hz, 144Hz, or 240Hz). Between the completion of drawing the bottom-right pixel of the screen and the start of drawing the top-left pixel of the next cycle, there is a tiny pause known as the Vertical Blanking Interval (VBLANK).

Why Disabling V-Sync Causes Tearing

When V-Sync is enabled, the DirectX runtime forces the swap chain to wait for the VBLANK interval before swapping the back and front buffers. This ensures that a buffer swap only happens while the monitor is temporarily not drawing pixels, guaranteeing that every refresh cycle displays a single, cohesive frame.

When V-Sync is turned off (typically configured by setting the sync interval parameter to 0 in DirectX), this safety mechanism is removed. The swap chain operates in an immediate presentation mode. The moment the GPU finishes rendering a back buffer, it instantly swaps it with the front buffer—or overwrites memory—regardless of what the monitor is currently doing.

If the monitor is midway through reading the front buffer to scan out pixels onto the screen when this swap occurs, the remaining portion of that scanout cycle will draw pixel data from the newly presented frame. Consequently, the upper part of the display shows the older frame, while the lower part shows the newer frame. Because movement or camera rotation likely occurred between those two frames, the geometry fails to line up along the scanline where the swap happened, producing a visible horizontal tear.

The Effect of Frame Rate Variations

Tearing is not limited to scenarios where the GPU produces more frames than the monitor can display (such as 120 FPS on a 60Hz monitor). It also occurs when the frame rate is lower than the refresh rate. Unless the presentation of a new frame is explicitly aligned to the display’s VBLANK interval via synchronization mechanisms like V-Sync, G-Sync, or FreeSync, buffer flips will inevitably collide with active display scanouts, causing tearing regardless of performance levels.