Skip to content

How to Get the Current DPI Scaling Setting in Batch Script

Learn how to retrieve Windows DPI scaling percentage in Batch scripts by querying the registry (AppliedDPI or LogPixels) and calculating the scaling factor using (DPI / 96) × 100.

DPI (Dots Per Inch) scaling determines how large text, icons, and UI elements appear on the screen. On high-resolution displays (4K, QHD), Windows automatically increases the DPI scaling percentage so that everything remains readable. While this is great for daily use, it can cause issues for Batch scripts that launch legacy applications, screen capture tools, or automated GUI testing frameworks that assume a 100% scaling baseline.

In this guide, we will explore how to retrieve the current DPI scaling percentage using Batch Script by querying the Windows Registry.

Understanding DPI Scaling in Windows

Windows represents DPI scaling as a logarithmic DPI value in the registry, not as a direct percentage. The mapping between the stored DPI value and the user-facing percentage is:

Registry DPI Value Display Scaling Common Name
96 100% Standard
120 125% Medium
144 150% Larger
168 175% –
192 200% Extra Large
240 250% –
288 300% –

The formula is: Scaling % = (DPI Value / 96) × 100

Method 1: Reading from the Registry

The current user's DPI setting is stored at: HKCU\Control Panel\Desktop Value Name: LogPixels Type: REG_DWORD

However, on modern Windows 10/11 systems with per-monitor DPI awareness, the primary scaling factor may also be found at: HKCU\Control Panel\Desktop\WindowMetrics Value Name: AppliedDPI

@echo off
setlocal enabledelayedexpansion

echo Reading DPI Scaling Setting...
echo ==============================

:: Try AppliedDPI first (Windows 10/11 preferred)
set "dpi="
for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop\WindowMetrics" /v AppliedDPI 2^>nul ^| findstr /i "REG_DWORD"') do set "dpi=%%B"

:: Fallback to LogPixels if AppliedDPI not found
if not defined dpi (
    for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop" /v LogPixels 2^>nul ^| findstr /i "REG_DWORD"') do set "dpi=%%B"
)

if not defined dpi (
    echo [INFO] No DPI override found. System is likely at default 100%% ^(96 DPI^).
    set "dpi=0x60"
)

:: Convert hex to decimal using set /a (handles 0x prefix natively)
set /a "dpi_dec=!dpi!"

:: Calculate the scaling percentage
set /a "scale_pct=(!dpi_dec! * 100) / 96"

echo Raw DPI Value:      !dpi! ^(!dpi_dec! decimal^)
echo Scaling Percentage: !scale_pct!%%

pause

Why We Check Two Locations

  • AppliedDPI: This key is written by Windows 10/11 when the user changes the scaling slider in Settings > Display. It reflects the actively applied DPI for the primary display.
  • LogPixels: This is the legacy key used by older Windows versions and some applications. On a fresh Windows 10 install at 100%, this key may not exist at all.

Method 2: Using PowerShell for System DPI

The registry approach reads the primary display's setting. For a programmatic query of the system-level DPI via the Windows API, we can use PowerShell to call GetDeviceCaps.

@echo off
setlocal enabledelayedexpansion

echo Retrieving System DPI via Windows API...
echo =========================================
echo.

set "dpi_x="
set "dpi_y="
set "scale="

:: Write the PowerShell script to a temp file to avoid cmd escaping issues
set "ps_script=%TEMP%\get_dpi_%RANDOM%.ps1"

> "!ps_script!" (
    echo Add-Type -TypeDefinition @'
    echo using System;
    echo using System.Runtime.InteropServices;
    echo public class DPIHelper {
    echo     [DllImport^("user32.dll"^)]
    echo     public static extern IntPtr GetDC^(IntPtr hwnd^);
    echo     [DllImport^("gdi32.dll"^)]
    echo     public static extern int GetDeviceCaps^(IntPtr hdc, int nIndex^);
    echo     [DllImport^("user32.dll"^)]
    echo     public static extern int ReleaseDC^(IntPtr hwnd, IntPtr hdc^);
    echo }
    echo '@
    echo $hdc = [DPIHelper]::GetDC^([IntPtr]::Zero^)
    echo $dpiX = [DPIHelper]::GetDeviceCaps^($hdc, 88^)
    echo $dpiY = [DPIHelper]::GetDeviceCaps^($hdc, 90^)
    echo [void][DPIHelper]::ReleaseDC^([IntPtr]::Zero, $hdc^)
    echo $scale = [math]::Round^(^($dpiX / 96^) * 100^)
    echo Write-Output "DpiX=$dpiX"
    echo Write-Output "DpiY=$dpiY"
    echo Write-Output "Scale=$scale"
)

for /f "tokens=1* delims==" %%A in ('powershell -NoProfile -ExecutionPolicy Bypass -File "!ps_script!" 2^>nul') do (
    if "%%A"=="DpiX" set "dpi_x=%%B"
    if "%%A"=="DpiY" set "dpi_y=%%B"
    if "%%A"=="Scale" set "scale=%%B"
)

del "!ps_script!" 2>nul

if not defined dpi_x (
    echo [ERROR] Could not retrieve DPI information via Windows API.
    pause
    exit /b 1
)

echo Primary Display DPI: !dpi_x! x !dpi_y!
echo Scaling Percentage:  !scale!%%

pause

Understanding GetDeviceCaps

  • Index 88 (LOGPIXELSX): Returns the horizontal DPI of the screen.
  • Index 90 (LOGPIXELSY): Returns the vertical DPI of the screen.

On standard displays, both values are identical (e.g., 96×96 at 100%, 144×144 at 150%).

Method 3: Quick One-Liner Check

If you just need a fast check for conditional logic in a deployment script:

@echo off
setlocal

:: Quick DPI check: try AppliedDPI, fallback to LogPixels, default to 96
set "dpi=96"
for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop\WindowMetrics" /v AppliedDPI 2^>nul ^| findstr /i "REG_DWORD"') do set /a "dpi=%%B"
if %dpi% equ 96 (
    for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop" /v LogPixels 2^>nul ^| findstr /i "REG_DWORD"') do set /a "dpi=%%B"
)

set /a "scale=(%dpi% * 100) / 96"

if %scale% gtr 100 (
    echo [WARNING] Display scaling is at %scale%%%. Some legacy applications may not render correctly.
) else (
    echo [OK] Display scaling is at standard 100%%.
)

pause

Practical Use Case: Adjusting Application Launch Parameters

Some legacy applications do not handle high-DPI displays properly and need to be launched with DPI compatibility flags.

@echo off
setlocal

set "app_path=C:\LegacyApp\app.exe"

:: Check scaling
set "dpi=96"
for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop\WindowMetrics" /v AppliedDPI 2^>nul ^| findstr /i "REG_DWORD"') do set /a "dpi=%%A"
if %dpi% equ 96 (
    for /f "tokens=2*" %%A in ('reg query "HKCU\Control Panel\Desktop" /v LogPixels 2^>nul ^| findstr /i "REG_DWORD"') do set /a "dpi=%%B"
)
set /a "scale=(%dpi% * 100) / 96"

if %scale% gtr 100 (
    echo High-DPI detected ^(%scale%%%^). Setting compatibility mode...

    :: Set the application to use "System (Enhanced)" DPI awareness
    set "compat_key=HKCU\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers"
    REG ADD "%compat_key%" /v "%app_path%" /t REG_SZ /d "~ HIGHDPIAWARE" /f >nul

    echo [OK] DPI compatibility override applied for %scale%%% scaling.
)

if not exist "%app_path%" (
    echo [ERROR] Application not found: %app_path%
    pause
    exit /b 1
)

echo Launching application...
start "" "%app_path%"

Common Mistakes

The Wrong Way: Assuming 96 DPI on Modern Hardware

:: WRONG - Hardcoding 100% scaling assumption
echo Setting window size to 1920x1080 for full HD...

The Wrong Way: Reading the Wrong Registry Key

:: WRONG - DpiScalingVer is an internal version flag, not the DPI value
reg query "HKCU\Control Panel\Desktop" /v DpiScalingVer

This key tracks the DPI scaling feature version, not the actual DPI setting. Always use AppliedDPI or LogPixels.

The Wrong Way: Parsing Registry Values by Value Name Instead of Type

:: WRONG - findstr /i "AppliedDPI" can match path lines or headers
for /f "tokens=3" %%A in ('reg query "HKCU\...\WindowMetrics" /v AppliedDPI 2^>nul ^| findstr /i "AppliedDPI"') do set "dpi=%%A"

Best Practices

  1. Check AppliedDPI first: On Windows 10/11, this is the most accurate and up-to-date value.
  2. Fall back to LogPixels: For compatibility with Windows 7/8 or edge cases where AppliedDPI does not exist.
  3. Default to 96: If neither key exists, assume 96 DPI (100% scaling), which is the Windows default.
  4. Use the formula: Always calculate the percentage as (DPI / 96) * 100 rather than maintaining a hardcoded lookup table, since Windows supports arbitrary scaling values (e.g., 125%, 150%, 175%, 225%).
  5. Use tokens=2* with findstr /i "REG_DWORD": This parsing pattern reliably extracts DWORD values from reg query output regardless of column spacing or value name content.
  6. Use set /a for hex conversion: The set /a command natively handles 0x-prefixed hexadecimal values, converting them to decimal automatically without needing a manual conversion step.

Conclusion

Retrieving the current DPI scaling setting in Batch Script boils down to reading the AppliedDPI or LogPixels registry value and applying a simple formula to convert it into a user-friendly percentage. This information is essential for scripts that launch legacy applications, configure display-dependent settings, or perform pre-deployment checks on high-resolution displays. By detecting non-standard scaling early, your automation scripts can apply appropriate compatibility fixes before users encounter blurry or incorrectly sized interfaces.

Navigation