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 fromC:\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 onC:\Program Files\WindowsAppsto browse its contents. Altering the access control lists onWindowsAppscan 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
- Press
Ctrl+Shift+Escto open Task Manager. - 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.
- Right-click any column header (such as Name or PID) and select Select columns.
- 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.
- Select OK to apply the columns.
- Locate your target process in the list and inspect the Package name and Image path name columns.
Windows 10
- Press
Ctrl+Shift+Escto open Task Manager. - If Task Manager opens in compact mode, select More details at the bottom-left of the window.
- Select the Details tab along the top row of tabs.
- Right-click any column header (such as Name or PID) and select Select columns.
- Check Package name and Image path name, then select OK.
- 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 toC:\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 CalculatororAzure VPN Client). Note that display names are not guaranteed to be unique across packages. ms-resource:value inPackage name: The process is packaged, but Task Manager could not resolve the localized display string from the package'sAppxManifest.xmlresource table.- Populated
Package namewith a non-WindowsAppspath: 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.
- 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.
- Run the following command to view the target process's PID, name, and executable path (replace
CalculatorAppwith your process name without.exe):
Get-Process -Name "CalculatorApp" | Select-Object Id, ProcessName, Path
- Compare the
Pathoutput against installed MSIX packages by running:
$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
- Review the output:
- If
Get-AppxPackagereturns a match, the process executable resides inside that MSIX package'sInstallLocation(usually underC:\Program Files\WindowsApps\). - If
Get-AppxPackagereturns 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.
- If
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.
- Find the PID of the running process you want to inspect:
Get-Process -Name "CalculatorApp" | Select-Object Id, ProcessName, Path
- Open a text editor (such as Notepad) or PowerShell ISE and save the following script as
Get-ProcessPackageIdentity.ps1:
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)
}
- Run the script against your target PID (replace
1234with the actual PID from step 1):
.\Get-ProcessPackageIdentity.ps1 -ProcessId 1234
- Interpret the returned object:
PackageFullNameandApplicationUserModelIdpopulated: The process is an MSIX-packaged application process with full package and application identity.PackageFullNamepopulated,ApplicationUserModelIdblank: 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, code15703).- Both
PackageFullNameandApplicationUserModelIdblank: The process is unpackaged (APPMODEL_ERROR_NO_PACKAGE, code15700), regardless of where its.exeis 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.
- Open Command Prompt or PowerShell.
- To list all currently running packaged processes, run:
tasklist /apps
- To check a specific process by PID or executable name, add the
/FIfilter:
tasklist /apps /fi "PID eq 1234"
or:
tasklist /apps /fi "IMAGENAME eq CalculatorApp.exe"
- If the process is packaged,
tasklist /appsprints its Image Name, PID, Mem Usage, and Package Name (which is thePackageFullName). If the process is unpackaged,tasklist /appsreturnsINFO: 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(ortasklist /apps) returns aPackageFullName, and the executable path sits insideC:\Program Files\WindowsApps\<PackageFullName>\. - External Location MSIX-packaged app: Task Manager's Package name column is populated and
GetPackageFullNamereturns aPackageFullName, while the executable path points to a standard desktop folder outsideWindowsApps. - Traditional unpackaged desktop app (or unpackaged child process): Task Manager's Package name column is blank,
tasklist /appsomits the PID, andGetPackageFullNamereturns no package (15700).
Troubleshooting
Package nameshows anms-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. Runtasklist /apps /fi "PID eq <PID>"or the PowerShell script above to retrieve the exactPackageFullName.Get-Processshows a blankPathorOpenProcessreturns 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-modeOpenProcesscalls may still be restricted by Windows; useGet-CimInstance Win32_Process -Filter "ProcessId = <PID>" | Select-Object ProcessId, Name, ExecutablePathin 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 thePathin PowerShell or Image path name in Task Manager—you will typically see the helper running from%LocalAppData%,%AppData%, orC:\Program Files\rather than inside the package'sWindowsAppsdirectory. - PowerShell blocks
Get-ProcessPackageIdentity.ps1with an execution policy error: If your system blocks local.ps1scripts, you can allow scripts for the current PowerShell session only without changing persistent system policy by runningSet-ExecutionPolicy -Scope Process -ExecutionPolicy Bypassbefore 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-Processand running the script. Use Task Manager's Details tab orGet-AppxPackageto inspect the installed package first, or monitor process creation with Sysinternals Process Monitor if you need to capture transient launches.