You can determine whether a running Windows process belongs to an MSIX-packaged app or a traditional unpackaged desktop program by checking for package identity in Task Manager's Details tab (using the Package name column) or by querying the process in PowerShell and comparing its runtime package identity against its executable path. This workflow applies to both Windows 10 and Windows 11, and it distinguishes standard MSIX/Microsoft Store apps, traditional Win32 desktop programs, and edge cases such as MSIX packages with an external location or unpackaged helper processes.

Windows 11 shows Task Manager and PowerShell alongside folders comparing the Calculator package with Edge’s desktop app files. Prerequisites and how Windows identifies packaged processes​

Windows does not classify a running process as MSIX solely by where its .exe file lives on disk. Under Microsoft's MSIX application model, a process is packaged when the operating system assigns it a package identity at launch, and unpackaged when it has no package identity.

  • Supported operating systems: Windows 10 (all supported versions) and Windows 11 (21H2 through current releases).
  • Permissions: A standard user account can inspect processes running in its own user session. To inspect elevated processes, system processes, or processes running under another user account—or to query all users' installed packages with Get-AppxPackage -AllUsers—open PowerShell or Task Manager as Administrator.
  • Why path comparison matters: Standard MSIX and Microsoft Store apps install under C:\Program Files\WindowsApps\<PackageFullName>\. Traditional desktop programs typically run from C:\Program Files\, C:\Program Files (x86)\, or %LocalAppData%. However, an app packaged with External Location can carry package identity while running from a traditional folder, and a packaged app can spawn an unpackaged child process (such as a CLI helper) that lacks package identity. Checking both package identity and executable path prevents misidentification.
Warning: Do not take ownership of or modify NTFS permissions on C:\Program Files\WindowsApps to browse its contents. Altering the access control lists on WindowsApps can break Microsoft Store and MSIX app launches, updates, and servicing. Use Task Manager or PowerShell to inspect paths and package metadata safely.

Check process package status in Task Manager​

Task Manager lets you view a process's package status and executable path side by side without running scripts. The steps differ slightly between Windows 11 and Windows 10 because of the redesigned Task Manager layout introduced in Windows 11.

Windows 11​

  1. Press Ctrl + Shift + Esc to open Task Manager.
  2. In the left-hand navigation pane, select Details (the list icon). If the window is narrow and the labels are hidden, select the menu button in the top-left corner to expand the navigation pane.
  3. Right-click any column header (such as Name or PID) and select Select columns.
  4. Scroll through the Select columns dialog, check Package name, and also check Image path name so you can compare the package status with the executable path.
  5. Select OK to apply the columns.
  6. Locate your target process in the list and inspect the Package name and Image path name columns.

Windows 10​

  1. Press Ctrl + Shift + Esc to open Task Manager.
  2. If Task Manager opens in compact mode, select More details at the bottom-left of the window.
  3. Select the Details tab along the top row of tabs.
  4. Right-click any column header (such as Name or PID) and select Select columns.
  5. Check Package name and Image path name, then select OK.
  6. Locate your target process and compare the Package name and Image path name columns.

How to read the Task Manager columns​

  • Blank Package name: The process is unpackaged (it has no package identity). If its Image path name points to C:\Program Files\, C:\Program Files (x86)\, or a user folder, it is a traditional desktop process.
  • Populated Package name: The process is packaged (MSIX/AppX/Store). Task Manager normally displays the package's localized display name (for example, Windows Calculator or Azure VPN Client). Note that display names are not guaranteed to be unique across packages.
  • ms-resource: value in Package name: The process is packaged, but Task Manager could not resolve the localized display string from the package's AppxManifest.xml resource table.
  • Populated Package name with a non-WindowsApps path: The process belongs to an MSIX package registered with an External Location, meaning it runs with package identity even though its files reside in a standard folder.

Inspect package details and process paths with PowerShell​

Task Manager only shows the friendly display name, not the full MSIX package identifier (PackageFullName), PackageFamilyName, or Application User Model ID (AUMID). PowerShell lets you inspect both the file path and the exact runtime package identity.

Method 1: Compare Get-Process paths against Get-AppxPackage​

Use this quick comparison when you want to see where a running process's executable lives and whether that folder matches an installed MSIX package on the system.

  1. Open PowerShell (or Windows Terminal with a PowerShell tab). Run it as Administrator if you need to inspect elevated processes or packages installed for other users.
  2. Run the following command to view the target process's PID, name, and executable path (replace CalculatorApp with your process name without .exe):

Get-Process -Name "CalculatorApp" | Select-Object Id, ProcessName, Path

  1. Compare the Path output against installed MSIX packages by running:
Code:
$proc = Get-Process -Name "CalculatorApp" | Select-Object -First 1
Get-AppxPackage | Where-Object { $proc.Path -and $proc.Path.StartsWith($_.InstallLocation, [System.StringComparison]::OrdinalIgnoreCase) } | Select-Object Name, PackageFullName, PackageFamilyName, InstallLocation
  1. Review the output:
    • If Get-AppxPackage returns a match, the process executable resides inside that MSIX package's InstallLocation (usually under C:\Program Files\WindowsApps\).
    • If Get-AppxPackage returns nothing, either the process is a traditional unpackaged desktop program, or it is an External Location MSIX process whose runtime identity must be checked directly via the Windows AppModel API.

Method 2: Query runtime package identity and AUMID directly​

To determine with certainty whether a running process has MSIX package identity—regardless of where its executable is stored—query the Windows GetPackageFullName and GetApplicationUserModelId APIs from PowerShell. Microsoft's MSIX engineering team documents this pattern as the authoritative way to retrieve package and application identity from a live PID without compiling a native C++ tool.

  1. Find the PID of the running process you want to inspect:

Get-Process -Name "CalculatorApp" | Select-Object Id, ProcessName, Path

  1. Open a text editor (such as Notepad) or PowerShell ISE and save the following script as Get-ProcessPackageIdentity.ps1:
Code:
Param(
    [Parameter(Mandatory = $true)]
    [int]$ProcessId
)

Set-StrictMode -Version 3.0
$ErrorActionPreference = "Stop"

Add-Type -TypeDefinition @"
using System;
using System.Runtime.InteropServices;
using System.Text;

namespace AppModel {
    public static class PackageUtil {
        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr OpenProcess(int access, bool inherit, int processId);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
        public static extern int GetPackageFullName(IntPtr hProcess, ref int packageFullNameLength, StringBuilder packageFullName);

        [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
        public static extern int GetApplicationUserModelId(IntPtr hProcess, ref int applicationUserModelIdLength, StringBuilder applicationUserModelId);

        public const int PROCESS_QUERY_LIMITED_INFORMATION = 0x1000;
        public const int APPMODEL_ERROR_NO_PACKAGE = 15700;
        public const int APPMODEL_ERROR_NO_APPLICATION = 15703;
        public const int PACKAGE_FULL_NAME_MAX_LENGTH = 127;
        public const int APPLICATION_USER_MODEL_ID_MAX_LENGTH = 130;
    }
}
"@

$proc = Get-Process -Id $ProcessId
$handle = [AppModel.PackageUtil]::OpenProcess([AppModel.PackageUtil]::PROCESS_QUERY_LIMITED_INFORMATION, $false, $ProcessId)

if ($handle -eq [IntPtr]::Zero) {
    $err = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
    Write-Warning "Failed to open PID $ProcessId (Win32 error $err). Try running PowerShell as Administrator."
    return
}

try {
    $pkgLen = [AppModel.PackageUtil]::PACKAGE_FULL_NAME_MAX_LENGTH + 1
    $pkgSb = New-Object System.Text.StringBuilder $pkgLen
    $pkgResult = [AppModel.PackageUtil]::GetPackageFullName($handle, [ref]$pkgLen, $pkgSb)

    $packageFullName = $null
    if ($pkgResult -eq 0) {
        $packageFullName = $pkgSb.ToString()
    } elseif ($pkgResult -ne [AppModel.PackageUtil]::APPMODEL_ERROR_NO_PACKAGE) {
        Write-Warning "GetPackageFullName returned error $pkgResult for PID $ProcessId."
    }

    $aumid = $null
    if ($null -ne $packageFullName) {
        $aumidLen = [AppModel.PackageUtil]::APPLICATION_USER_MODEL_ID_MAX_LENGTH
        $aumidSb = New-Object System.Text.StringBuilder $aumidLen
        $aumidResult = [AppModel.PackageUtil]::GetApplicationUserModelId($handle, [ref]$aumidLen, $aumidSb)

        if ($aumidResult -eq 0) {
            $aumid = $aumidSb.ToString()
        } elseif ($aumidResult -ne [AppModel.PackageUtil]::APPMODEL_ERROR_NO_APPLICATION) {
            Write-Warning "GetApplicationUserModelId returned error $aumidResult for PID $ProcessId."
        }
    }

    [PSCustomObject]@{
        PID                    = $ProcessId
        ProcessName            = $proc.ProcessName
        Path                   = $proc.Path
        PackageFullName        = $packageFullName
        ApplicationUserModelId = $aumid
    }
}
finally {
    [void][AppModel.PackageUtil]::CloseHandle($handle)
}
  1. Run the script against your target PID (replace 1234 with the actual PID from step 1):

.\Get-ProcessPackageIdentity.ps1 -ProcessId 1234

  1. Interpret the returned object:
    • PackageFullName and ApplicationUserModelId populated: The process is an MSIX-packaged application process with full package and application identity.
    • PackageFullName populated, ApplicationUserModelId blank: The process is packaged (for example, a packaged background task or out-of-process server), but it does not have an application identity (APPMODEL_ERROR_NO_APPLICATION, code 15703).
    • Both PackageFullName and ApplicationUserModelId blank: The process is unpackaged (APPMODEL_ERROR_NO_PACKAGE, code 15700), regardless of where its .exe is located.

Alternate method: Quick command-line check with TASKLIST​

If you do not want to create a PowerShell script and only need the PackageFullName (not the AUMID), Windows includes tasklist.exe with the /APPS switch.

  1. Open Command Prompt or PowerShell.
  2. To list all currently running packaged processes, run:

tasklist /apps

  1. To check a specific process by PID or executable name, add the /FI filter:

tasklist /apps /fi "PID eq 1234"

or:

tasklist /apps /fi "IMAGENAME eq CalculatorApp.exe"

  1. If the process is packaged, tasklist /apps prints its Image Name, PID, Mem Usage, and Package Name (which is the PackageFullName). If the process is unpackaged, tasklist /apps returns INFO: No tasks are running which match the specified criteria.

Verify your results​

You have successfully classified the process when your Task Manager, PowerShell, and path checks agree on one of these three states:

  • Standard MSIX-packaged app: Task Manager's Package name column is populated, GetPackageFullName (or tasklist /apps) returns a PackageFullName, and the executable path sits inside C:\Program Files\WindowsApps\<PackageFullName>\.
  • External Location MSIX-packaged app: Task Manager's Package name column is populated and GetPackageFullName returns a PackageFullName, while the executable path points to a standard desktop folder outside WindowsApps.
  • Traditional unpackaged desktop app (or unpackaged child process): Task Manager's Package name column is blank, tasklist /apps omits the PID, and GetPackageFullName returns no package (15700).

Troubleshooting​

  • Package name shows an ms-resource: string in Task Manager: Task Manager could not resolve the localized display name resource for that package. This still confirms the process is packaged. Run tasklist /apps /fi "PID eq <PID>" or the PowerShell script above to retrieve the exact PackageFullName.
  • Get-Process shows a blank Path or OpenProcess returns Win32 error 5 (Access is denied): The target process is running elevated, under another user account, or as a system/protected process. Reopen PowerShell as Administrator and run the command again. For Protected Process Light (PPL) system processes, user-mode OpenProcess calls may still be restricted by Windows; use Get-CimInstance Win32_Process -Filter "ProcessId = <PID>" | Select-Object ProcessId, Name, ExecutablePath in an elevated PowerShell window to read the executable path.
  • Process shows no package identity (15700) even though it was launched by an MSIX app: Packaged apps can spawn external helper executables, CLI tools, or scripts that run without inheriting package identity. Check the Path in PowerShell or Image path name in Task Manager—you will typically see the helper running from %LocalAppData%, %AppData%, or C:\Program Files\ rather than inside the package's WindowsApps directory.
  • PowerShell blocks Get-ProcessPackageIdentity.ps1 with an execution policy error: If your system blocks local .ps1 scripts, you can allow scripts for the current PowerShell session only without changing persistent system policy by running Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass before executing the script. Closing the terminal window automatically restores the previous policy.
  • Process exits before you can query its PID: Short-lived background tasks or launchers may close between running Get-Process and running the script. Use Task Manager's Details tab or Get-AppxPackage to inspect the installed package first, or monitor process creation with Sysinternals Process Monitor if you need to capture transient launches.