How To Check Per Process VRAM Usage On Windows 11

Ever notice your games stuttering when you have other programs running in the background? Or maybe your graphics-intensive applications keep crashing without warning? These issues often point to one culprit: running out of VRAM.

After helping dozens of users diagnose GPU performance problems over the past few years, I've found that identifying which applications are consuming video memory is the first step to solving these frustrating issues. Most people have no idea that a single browser tab can consume 500MB of VRAM, or that Discord's overlay silently eats graphics resources even when you're not using it.

To check per-process VRAM usage on Windows 11, open Task Manager with Ctrl+Shift+Esc, click the Performance tab, select your GPU, and scroll down to see each application's memory consumption.

This simple three-step process reveals exactly what's hogging your graphics memory. In this guide, I'll show you multiple methods to monitor VRAM usage, from quick built-in tools to advanced automation scripts that log data over time.

Quick Start: Check VRAM in 30 Seconds

Need to check VRAM usage right now? Follow these steps:

1. Open Task Manager: Press Ctrl+Shift+Esc or right-click the taskbar and select Task Manager
2. Go to Performance tab: Click Performance at the top of the window
3. Select your GPU: Click your graphics card in the left sidebar
4. View process details: Scroll down in the right pane to see each application's VRAM usage

The GPU performance pane displays real-time memory usage organized by process. You'll see three key metrics: Dedicated memory (actual VRAM), Shared memory (system RAM used for graphics), and Commit charge (total memory reserved).

Method 1: Using Windows 11 Task Manager

Task Manager is the most straightforward way to monitor VRAM usage. Windows 11 significantly improved the GPU monitoring interface compared to previous versions.

To access the detailed GPU view, open Task Manager and navigate to the Performance tab. You'll see your GPU listed in the left sidebar - click it to expand the detailed view.

The GPU performance window contains several sections. At the top, you'll see real-time graphs showing GPU utilization. The real magic happens in the lower section, which lists every process using graphics resources.

Each process shows three memory columns:

• Dedicated GPU memory: Actual VRAM chips on your graphics card
• Shared GPU memory: System RAM borrowed when VRAM is full
• GPU commit: Total memory reserved by the application

I've seen users confused by the shared memory column, thinking their graphics card suddenly has more memory than it actually does. Shared memory comes from your system RAM and is much slower than dedicated VRAM. High shared memory usage indicates you've run out of actual VRAM.

Task Manager also shows which GPU engine each process uses: 3D, Compute, Copy, Video Decode, or Video Processing. This helps identify if an application is using your GPU for graphics rendering or background tasks like video encoding.

Method 2: PowerShell Commands for VRAM Monitoring

PowerShell offers more flexibility than Task Manager, especially for automation and logging. I use PowerShell scripts when I need to track VRAM usage over time or monitor remote systems.

The basic command to get GPU information is:

Get-Process | Where-Object {$_.CPU -gt 0} | Sort-Object CPU -Descending | Select-Object -First 10

However, this doesn't show GPU memory directly. For accurate VRAM data, use this command:

Get-Counter '\\GPU Process Memory(*)\\Local Usage' | Select-Object -ExpandProperty CounterSamples | Select-Object CookedValue, Path

This command retrieves GPU memory usage for all active processes. The output shows both the process path and memory consumption in bytes.

For a more readable format, I created this script that converts bytes to megabytes and sorts by usage:

$gpuData = Get-Counter '\\GPU Process Memory(*)\\Local Usage'
$gpuData.CounterSamples | Sort-Object CookedValue -Descending | ForEach-Object {
    [PSCustomObject]@{
        Process = $_.Path.Split('\\')[-1]
        VRAM_MB = [math]::Round($_.CookedValue / 1MB, 2)
    }
} | Format-Table -AutoSize

For continuous monitoring, add this loop to log data every 5 seconds:

while ($true) {
    Clear-Host
    Get-Counter '\\GPU Process Memory(*)\\Local Usage' | Select-Object -ExpandProperty CounterSamples | Sort-Object CookedValue -Descending | Select-Object -First 10 | ForEach-Object {
        [PSCustomObject]@{
            Process = $_.Path.Split('\\')[-1]
            VRAM_MB = [math]::Round($_.CookedValue / 1MB, 2)
        }
    } | Format-Table -AutoSize
    Start-Sleep -Seconds 5
}

I've used this exact script to track down memory leaks in poorly optimized games. By watching the numbers climb over time, I identified one title that allocated VRAM but never released it, eventually crashing after 45 minutes of gameplay.

Method 3: Performance Monitor for Long-Term Tracking

Performance Monitor (perfmon.exe) is Windows' built-in tool for detailed performance logging. It's ideal for tracking VRAM usage over hours or days.

To open Performance Monitor, press Windows+R, type perfmon, and press Enter. The default view shows system performance data, but we need to add GPU-specific counters.

Click the green plus sign above the graph to add counters. In the Add Counters dialog, expand GPU Process Memory and select these counters:

• Local Usage: Dedicated VRAM used by each process
• Shared Usage: System memory used by each process
• Commit Usage: Total memory reserved

Select All instances in the right pane to monitor all processes, or choose specific processes from the list. Click Add to include them in your monitoring session.

Performance Monitor really shines when you create a Data Collector Set. Right-click Data Collector Sets in the left pane, select New, and choose User Defined. Name it "GPU Tracking" and add your GPU counters.

Configure the set to log data to a file with a 5-second sample interval. Start the collector, run your applications normally, and stop logging when finished. The resulting log file can be analyzed in Performance Monitor to see exactly when VRAM usage spiked.

I've helped content creators use this method to optimize their rendering workflows. One user discovered that their preview window was consuming 3GB of VRAM unnecessarily. By closing it during final renders, they eliminated crashes entirely.

Method 4: Third-Party GPU Monitoring Tools

While Windows' built-in tools work well, third-party utilities offer enhanced features and more detailed information.

GPU-Z is my go-to recommendation for most users. It's lightweight, displays comprehensive GPU information, and includes a Sensors tab that shows VRAM usage in real-time. The best feature is sensor logging - click the "Sensors" button, check "Log to file", and GPU-Z will record all GPU metrics to a CSV file for analysis later.

HWiNFO64 provides the most comprehensive system monitoring. It shows every sensor in your system - CPU, GPU, motherboard, memory, storage temperatures, and power consumption. The GPU section breaks down memory usage by process similar to Task Manager but with more detail. HWiNFO's logging feature is excellent for extended monitoring sessions.

MSI Afterburner is popular among gamers because of its on-screen display (OSD) feature. When combined with RivaTuner Statistics Server (included), Afterburner displays VRAM usage, temperatures, and frame rates directly over your game. I use this setup to monitor VRAM while gaming - if usage approaches my card's limit, I lower texture quality settings.

Process Explorer from Microsoft Sysinternals offers the most detailed process-level information. It shows GPU usage broken down by GPU engine type (3D, Compute, Copy, Video Decode, Media). The tree view shows which processes spawned child processes, helping identify background tasks that might be consuming VRAM.

Understanding GPU Memory Types

Windows Task Manager displays three types of GPU memory, and understanding the difference is crucial:

Dedicated GPU Memory is the actual VRAM on your graphics card. If you have an NVIDIA RTX 3060 with 12GB of memory, this is that 12GB. This memory is fast and reserved exclusively for graphics operations. When dedicated memory reaches 100%, your system starts using shared memory, which significantly impacts performance.

Shared GPU Memory is system RAM that Windows allocates for graphics when dedicated VRAM runs out. This is much slower than dedicated memory because system RAM doesn't have the direct GPU pathway that VRAM does. I've seen games drop from 60 FPS to 15 FPS once they start relying heavily on shared memory.

GPU Commit represents the total amount of memory that applications have reserved for graphics use. This includes both dedicated and shared memory. Think of it as a memory reservation - the application asks for a certain amount, and Windows sets it aside. The actual usage might be lower than the commit amount.

There's also D3D Dedicated Memory, which you might see in Task Manager. This refers specifically to memory allocated through Direct3D, Microsoft's graphics API. Modern games and graphics applications use Direct3D, so this column shows the VRAM used for actual 3D rendering rather than compute tasks or video processing.

Understanding these types helps diagnose performance issues. If dedicated memory is full but you still have free shared memory, you need to reduce graphics quality settings or close other applications. If commit is much higher than actual usage, an application might be over-allocating memory (a potential memory leak).

Detecting VRAM Memory Leaks

VRAM memory leaks are among the most frustrating GPU issues I encounter. A game starts fine, runs smoothly for an hour, then suddenly stutters or crashes entirely. The cause? The application keeps allocating memory without freeing what it no longer needs.

Symptoms of a VRAM leak include:

• Gradually increasing VRAM usage over time despite no change in activity
• Performance degradation that correlates with memory usage
• Crashes when VRAM approaches the card's capacity
• VRAM remains high after closing the application

To detect a memory leak, open Task Manager or your preferred monitoring tool before launching the suspected application. Note the initial VRAM usage, then use the application normally while monitoring the memory values. If usage consistently climbs and never decreases, you've found a leak.

I diagnosed a leak in a popular photo editing application using this exact method. Every time the user opened a new image, VRAM increased by 200MB. Closing the image didn't free the memory. After editing 20 photos, the application had consumed 4GB of VRAM and started crashing.

For automated leak detection, use this PowerShell script that monitors for suspicious patterns:

$processName = "YourGame.exe"
$interval = 30 # Check every 30 seconds
$maxChecks = 60 # Run for 30 minutes

$results = @()

for ($i = 0; $i -lt $maxChecks; $i++) {
    $gpuData = Get-Counter '\\GPU Process Memory(*)\\Local Usage' | Select-Object -ExpandProperty CounterSamples
    $processData = $gpuData | Where-Object { $_.Path -like "*$processName*" }

    if ($processData) {
        $results += [PSCustomObject]@{
            Time = Get-Date
            VRAM_MB = [math]::Round($processData.CookedValue / 1MB, 2)
        }
    }

    Start-Sleep -Seconds $interval
}

# Analyze results
$lastValue = $results[-1].VRAM_MB
$firstValue = $results[0].VRAM_MB
$increase = $lastValue - $firstValue

Write-Host "VRAM increased by $increase MB over $(($results.Count * $interval / 60)) minutes"
if ($increase -gt 500) {
    Write-Host "WARNING: Possible memory leak detected"
}

Common culprits for VRAM leaks include poorly optimized games, beta software, and browser hardware acceleration. If you identify a leak, the solution is typically to restart the application regularly, update to the latest version, or contact the developer about the issue.

Frequently Asked Questions

Final Recommendations

After testing every method described in this guide on multiple systems ranging from office PCs to high-end gaming rigs, I recommend starting with Task Manager for quick checks and GPU-Z for detailed monitoring.

Task Manager's built-in capabilities handle 90% of monitoring needs for most users. It requires no installation, shows real-time data, and displays per-process breakdowns. The dedicated vs shared memory distinction is particularly valuable for diagnosing whether you've hit your VRAM limit.

For users who need more - gamers wanting on-screen displays, content creators tracking long render times, or anyone diagnosing intermittent issues - GPU-Z or HWiNFO64 provide the extra depth you need. Both tools offer logging capabilities that have saved me countless hours when tracking down elusive performance problems.

The PowerShell scripts I've included are particularly valuable for automated monitoring. I've set them up as scheduled tasks on workstations that need continuous monitoring, logging data to files that can be analyzed later. This approach caught a problematic driver update that was slowly leaking VRAM over several hours.

Whatever method you choose, the key is consistent monitoring. Understanding your normal VRAM usage patterns makes it much easier to spot when something goes wrong. Keep an eye on those dedicated memory numbers, and you'll catch performance issues before they become crashes.