Why Do Transparent Windows Lag on Integrated GPUs?

A frosted, transparent overlay window looks beautiful on a modern dedicated GPU and hitchingly slow on an older integrated GPU. The same backdrop-filter: blur(20px) that produces a clean frosted-glass effect on an NVIDIA RTX card produces visible stutter on an Intel HD Graphics 4000, and the stutter is worst exactly when the user is moving the cursor — which is when the overlay is most visible. This guide covers why transparent windows hitch on older integrated GPUs, what the bandwidth explanation is, and what to do about it without abandoning the overlay entirely.

For neighbouring topics, see always-on-top apps that fight each other and the broader troubleshooting entry at Win+V not working on Windows 11: 9 fixes.

Why transparency is expensive

A transparent window is rendered in two passes. First, the renderer composites the window's own content (the cards, the text, the thumbnails) onto an off-screen buffer. Second, the compositor blends that buffer with the desktop content behind the window, using per-pixel alpha to determine how much of the desktop shows through.

The expensive part is the second pass. For each pixel of the window, the compositor reads the desktop pixel behind it, multiplies it by the alpha value, multiplies the window's pixel by the inverse alpha, and adds them. The read from the desktop content is the bottleneck — it is a texture fetch from the desktop's composited buffer, which is a separate allocation from the window's own buffer.

For a fully opaque window, the second pass is trivial: the compositor copies the window's buffer directly to the screen, with no blending. For a fully transparent window (alpha 0), the second pass is also trivial: the compositor ignores the window entirely. The expensive case is partial transparency, where the alpha is between 0 and 1 and the blending is real work.

A frosted-glass effect (backdrop-filter: blur) adds a third pass: the compositor must first blur the desktop content behind the window, then blend the blurred content with the window. The blur is a separable convolution that reads each desktop pixel multiple times — once for each tap in the blur kernel. A 20-pixel blur reads roughly 40 desktop pixels per window pixel, which is a lot of memory bandwidth.

Why integrated GPUs are worse

Dedicated GPUs have their own VRAM, which is high-bandwidth (modern GDDR6 is 384–768 GB/s) and dedicated to the GPU. The compositor's texture fetches hit VRAM, which is fast.

Integrated GPUs share system RAM with the CPU. System RAM is lower-bandwidth than dedicated VRAM (DDR4 is 25–50 GB/s; DDR5 is 60–90 GB/s) and is shared with everything else the CPU is doing. The compositor's texture fetches hit system RAM, which is slower and which competes with CPU memory accesses.

Older integrated GPUs (Intel HD Graphics 4000 and earlier, and some lower-end Intel UHD parts) have a further problem: they lack dedicated hardware for the blur convolution, so the blur runs as a software shader on the GPU's general-purpose cores. On these parts, a 20-pixel blur can take 10–20 ms per frame, which is half of a 60 Hz frame budget and most of a 144 Hz frame budget. The result is hitching — the overlay's frame rate drops to 30 Hz or lower when the cursor is moving, because the blur cannot keep up.

The fix

Three fixes, in increasing order of effectiveness:

Reduce the blur radius

A 20-pixel blur is expensive; a 5-pixel blur is much cheaper (roughly 4× fewer texture fetches). A 0-pixel blur (no backdrop-filter) is cheapest of all. Reducing the blur radius from 20 to 5 typically eliminates the hitching on older integrated GPUs while preserving a hint of the frosted-glass effect.

Use a solid fill with high opacity

A solid fill (no transparency, no blur) eliminates the second and third passes entirely. The window is rendered as if it were opaque, and the compositor copies the buffer directly to the screen. This is the cheapest option and is the right choice for older integrated GPUs.

The aesthetic cost is that the overlay no longer feels "modern" — it looks like a Windows 7-era dialog rather than a Windows 11 acrylic surface. For users who care about performance more than aesthetics, this is the right trade.

Disable hardware acceleration

Counterintuitively, disabling hardware acceleration (running the compositor on the CPU) can be faster on older integrated GPUs, because the CPU's software rasteriser can use the L3 cache for the texture fetches, which is faster than going to system RAM. This is the same trade-off discussed in does hardware acceleration help a tiny overlay; for transparent windows on older integrated GPUs, the trade often flips in favour of software compositing.

What can go wrong

• The overlay uses a 20-pixel blur on an Intel HD Graphics 4000. Symptom: the overlay hitches when the cursor is moving. Fix: reduce the blur to 5 pixels or eliminate it.
• The overlay uses a fully transparent background with a thin border. Symptom: the overlay is invisible against most backgrounds. Fix: use a semi-transparent solid fill (alpha 0.8) instead of full transparency.
• The overlay's open animation uses a scale transform. Symptom: the animation hitches on integrated GPUs because the scale requires re-rasterising the window's content. Fix: use a fade or translate animation instead.
• The overlay's hardware acceleration is on, but the integrated GPU is older than the hardware acceleration's expected baseline. Symptom: the overlay is slow even with no blur and no transparency. Fix: disable hardware acceleration and use software compositing.

Detecting the integrated GPU

The overlay can detect the GPU via the DXGI API (IDXGIFactory::EnumAdapters), which returns the adapter's vendor ID and device ID. Intel vendor ID is 0x8086; AMD is 0x1002; NVIDIA is 0x10DE. The overlay can use the vendor ID to make a default decision: Intel integrated GPUs get the solid fill; AMD and NVIDIA dedicated GPUs get the frosted glass.

The detection is not perfect. Modern Intel integrated GPUs (Iris Xe and later) handle blur fine; some older AMD APU parts struggle. The right pattern is to detect, default, and let the user override.

For the related discussion of measuring the cost, see measuring clipboard app idle cost yourself.

The battery-powered laptop case

The same integrated GPU that hitches on blur is also running off battery, and blur is one of the most power-hungry operations the compositor performs. Each blur tap is a memory fetch, and the memory fetches keep the GPU's memory controller out of its low-power state. On a laptop unplugged with a frosted-glass overlay open, the overlay can measurably shorten battery life by keeping the GPU in an intermediate power state between idle and active.

The honest fix is to switch to a solid fill when on battery power, and reserve the frosted glass for plugged-in operation. The overlay can detect the power state via GetSystemPowerStatus and adjust automatically. This is the same kind of contextual default that already governs fullscreen suppression — the overlay should not need to be told; it should infer.

Honest positioning

Edge-Drop, the Windows hover-activated clipboard shelf, uses a transparent window with a small blur for its open state. The shelf does not currently detect the GPU and adjust the blur accordingly; the assumption is that modern integrated GPUs (Intel Iris Xe, AMD Radeon Vega, and later) handle the blur fine, and that users on older hardware can disable the blur or the transparency in the shelf's appearance settings. The shelf's appearance settings allow the user to switch to a solid fill, which is the right choice for older integrated GPUs. The shelf does not compete with native tray tools on raw performance on older hardware; native tools are lighter and do not have the Electron compositing overhead. For users on older hardware, the honest recommendation is a native tool — Ditto or Win+V — which avoids the question entirely.

What to check

If your overlay is hitching on an older integrated GPU, work through these:

1. Identify the GPU. (Task Manager → Performance → GPU 0; or dxdiag.)
2. If it is an older Intel integrated GPU (HD Graphics 4000 or earlier, or a low-end UHD part), the blur is likely the cause.
3. Reduce the blur radius to 5 pixels or disable it. If the hitching disappears, the blur was the cause.
4. If the hitching persists, switch to a solid fill (no transparency). If the hitching disappears, transparency was the cause.
5. If the hitching still persists, disable hardware acceleration. If the hitching disappears, the GPU's hardware path is the cause.

The right answer for older integrated GPUs is usually "solid fill, no blur, hardware acceleration optional." The right answer for modern dedicated GPUs is "frosted glass, hardware acceleration on." The overlay should default based on detection and let the user override.

Related reading

• Clipboard Tools on Multi-Monitor Windows Setups
• Win+V Not Working on Windows 11: 9 Fixes
• How to Enable Clipboard History in Windows 11
• Best Clipboard Managers for Windows in 2026

Sources

• Microsoft Learn — DirectComposition — Windows reference for the composition API that backs transparent windows and blur effects
• Microsoft Learn — DXGI EnumAdapters — Win32 reference for the API applications use to detect the GPU vendor and device
• Microsoft Learn — Layered windows — Win32 reference for the WS_EX_LAYERED flag and the per-pixel alpha blending that backs transparent overlays
• Intel — HD Graphics documentation — Intel's documentation for its integrated GPU line, including the architecture of older parts
• Chromium — GPU compositing — Chromium project documentation explaining how the GPU process composites transparent windows, including the cost of backdrop blur

Copy. Stack. Drop.

Transform your clipboard into an interactive edge shelf. Stack, pin, and drag assets into any app with zero friction.

Download for Windows Get from Microsoft Store

How to Install Guide · First 10 Minutes Guide · Drag & Drop Guide · Edge-Drop vs Win+V · Support