Windows 11 Display Scaling Per App: How to Force the Right DPI

Quick fix: Open the app’s .exe properties, go to Compatibility → Change high DPI settings, tick Override high DPI scaling behavior, and set scaling to System (Enhanced) — this overrides the global Display setting for that one app.

You set Windows 11 to 150% scaling so text on your 4K monitor is readable, but one specific app — usually a legacy Win32 tool or an older Java/Qt app — renders blurry, oversized, or with cut-off buttons. The rest of the system looks fine; this one app needs a different DPI setting. Windows 11 has supported per-app DPI overrides since the Creators Update, but the controls are buried.

What causes this

Windows tells each app, at launch, what DPI to render at. Modern apps respond with vector-perfect scaling (PerMonitorV2 awareness). Older apps either ignore the request and render at 96 DPI — which Windows then upscales as a bitmap, producing blur — or they accept the DPI but lay out their UI assuming 96 DPI, producing oversized fonts on tiny buttons.

A per-app override tells Windows to either let the app handle DPI itself (the Application option), have Windows scale it as a clean bitmap (System), or have Windows scale it with extra GDI text crispness for legacy Win32 controls (System (Enhanced)).

Method 1: Set per-app DPI from the executable’s Compatibility tab

The standard route. Works for any .exe you can locate on disk.

1. Right-click the app’s desktop shortcut and choose Open file location. (For Start Menu shortcuts, this gives you the shortcut; right-click the shortcut and choose Open file location again to reach the actual .exe.)
2. Right-click the .exe file and choose Properties → Compatibility.
3. Click Change high DPI settings.
4. Tick Override high DPI scaling behavior. Scaling performed by: and choose one option:
   • Application — for apps that scale themselves but fight Windows.
   • System — for legacy apps. Produces clean scaling, slight blur on text.
   • System (Enhanced) — for GDI-only legacy apps. Crispest text, but breaks some custom controls.
5. Click OK twice. Close the app fully and relaunch it.

If System (Enhanced) makes the app look right but a particular dialog comes out wrong, switch to System. The trade-off is text crispness vs. control layout fidelity.

Method 2: Force PerMonitorV2 awareness with a manifest

For apps that look fine on your primary monitor but break the moment you drag them to a secondary monitor with different DPI, you need PerMonitorV2 behavior. The Compatibility tab can’t reach this — you need an external manifest file.

1. Open a text editor as Administrator (Notepad → Run as administrator).
2. Create a new file named YourAppName.exe.manifest in the same folder as the .exe.
3. Paste this content (replace the assembly name with the .exe filename without extension):

   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
   <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
     <application xmlns="urn:schemas-microsoft-com:asm.v3">
       <windowsSettings>
         <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2,permonitor</dpiAwareness>
       </windowsSettings>
     </application>
   </assembly>

4. Open Registry Editor (regedit) and navigate to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\SideBySide.
5. Create a new DWORD named PreferExternalManifest and set its value to 1.
6. Restart the app. Windows now reads the external manifest before checking the embedded one and applies PerMonitorV2 awareness.

This is the cleanest fix for apps that look right on the laptop’s built-in 4K screen but go blurry when docked to a 1080p external monitor.

Method 3: Use a fixed scale via the legacy DPI override (registry)

For apps that the Compatibility tab’s options don’t fix — typically very old MFC or Delphi apps — you can pin a fixed scale through the registry. This forces Windows to render the app at a specific DPI regardless of the monitor.

1. Open Registry Editor and navigate to HKEY_CURRENT_USER\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers. Create the Layers key if it doesn’t exist.
2. Create a new String Value. Set the name to the full path of the app’s .exe (e.g., C:\Program Files (x86)\OldApp\app.exe).
3. Set the value data based on what you want:
   • ~ HIGHDPIAWARE — lets the app handle DPI itself.
   • ~ DPIUNAWARE — forces 96 DPI rendering, Windows scales as bitmap.
   • ~ GDIDPISCALING DPIUNAWARE — legacy GDI scaling, equivalent to System (Enhanced).
4. Close Registry Editor. Restart the app.

This is the last resort because the registry change applies per-user and doesn’t roam with you. If the app launches under a different account or via a scheduled task, the override won’t apply.

How to verify the fix worked

• Launch the app and confirm UI elements (buttons, dialog boxes, menus) appear at the same physical size as the rest of Windows.
• Drag the app to a second monitor with different DPI. Text should re-render crisply within a second or two; it should not stay blurry.
• Run Task Manager → Details, right-click any column header, choose Select columns, and add DPI awareness. The app should now show Per monitor (V2) or System depending on which method you used.

If none of these work

If all three methods fail, the app is probably linked against an extremely old framework (pre-Windows Vista era) or uses a non-standard windowing toolkit. The two remaining options are: (1) run the app inside a Windows Sandbox or a dedicated user account with global scaling set to 100% (the app will be tiny but native-resolution sharp), or (2) check if a newer version of the app exists with proper PerMonitorV2 support — many small ISV apps released a DPI-aware version sometime between 2019 and 2023. For commercial apps that are still in development, file a bug with the vendor; for abandonware, your only path is virtualization at 100% scaling.

Bottom line: Per-app DPI overrides on Windows 11 layer in three levels — Compatibility tab options for most cases, external manifests for multi-monitor edge cases, registry overrides for the rest.