Winget: Windows Native Package Manager for Fast, Scriptable Installs

Windows already includes a powerful, Linux-style package manager you can use right now to search, install, update and remove apps — and once you learn a few commands, the time you spend wrestling installers disappears.

Background / Overview​

The Windows Package Manager, commonly known as winget, is Microsoft’s official command-line tool for discovering and managing Windows applications. It’s delivered as part of the App Installer system component and is available by default on modern Windows 11 installations and on supported Windows 10 builds. This means most users do not need to download any third-party tool to get began: winget is already present on the system or can be enabled via the Microsoft Store/App Installer if it’s missing. Winget is built around two cooperating pieces: a client (the winget binary you run in a Terminal) and one or more package sources (repositories of manifests). The default public repository is the community manifest repository maintained on GitHub; manifests describe installers, expected silent switches, hashes and metadata so the client can automate installs as reliably as possible. That repository and the client are both open source. Why this matters: winget brings the repeatable, scriptable workflow that Linux users enjoy (APT, Pacman) to Windows. For power users, IT pros and anyone who sets up multiple machines, winget removes manual download-and-click steps and replaces them with reproducible commands and scripts.

---

Make sure winget is available​

Check first​

Open Windows Terminal, PowerShell, or Command Prompt and run:
winget --version
If the command prints a version you’re ready. If you see an error such as "'winget' is not recognized", the likely fixes are:

• Install or update App Installer from the Microsoft Store.
• Re-register the App Installer package or install the latest release from the winget GitHub releases if App Installer is unavailable.
• Ensure your environment PATH includes the WindowsApps location where the winget executable is registered for user scope.

Why the PATH sometimes trips people up​

Winget and other Store-delivered command-line helpers are surfaced via the per-user WindowsApps folder: %LOCALAPPDATA%\Microsoft\WindowsApps (the full path expands to C:\Users\<YourUser>\AppData\Local\Microsoft\WindowsApps). If a terminal reports “command not found” you can either re-install App Installer from the Store or add that WindowsApps folder to your PATH environment variable manually. The step-by-step PATH fix is common in user guides and troubleshooting threads and will make winget and Store-installed command shims available in that shell session.

---

Search, list and inspect packages​

Winget’s search and list commands are the discovery tools you’ll use the most.

• Search for packages: winget search <term>
• Show details for a specific match: winget show <id-or-name>
• List installed apps on the device: winget list

To surface the entire community catalog from the default source you can run:
winget search --query ""
On PowerShell you must escape the quotes: winget search -q "". That empty-query trick intentionally shows all packages returned by a source (note: previous versions behaved slightly differently; the explicit empty-query is the documented approach today). Search results return a package Name, Package ID, moniker and available version(s). Use the Package ID for deterministic install operations: it’s the stable identifier most suited for scripting.

---

Install apps: simple, exact, bulk​

Installing with winget is straightforward. You can use a friendly name, a moniker, or — for automation — the exact Package ID.
Examples:

• Install by moniker or short name: winget install firefox
• Install by exact ID (recommended for scripts): winget install --id Mozilla.Firefox -e
• Install multiple apps in sequence (batch): winget install --id AppA && winget install --id AppB

Key install flags and behaviors:

• --id and -e/--exact help avoid ambiguity and ensure winget selects the specific manifest you expect.
• Many manifests provide known silent/install switches; winget supports a silent mode that requests a non-interactive install path. Use --silent (or the broader --accept-package-agreements and --disable-interactivity flags in unattended scripts). However, silent execution depends on the installer type and the manifest’s provided switches — not every installer will be perfectly silent.

Practical example:

• Search: winget search firefox
• Install exact ID: winget install --id Mozilla.Firefox -e
• Silent install (where supported): winget install --id Mozilla.Firefox -e --silent

If you run scripted bulk installs (for a new laptop or a provisioning script), wrap accepted agreements and disable interactivity to avoid prompts:
winget install --id Microsoft.VisualStudioCode -e --accept-package-agreements --disable-interactivity

---

Updating: single, all, or selective​

Winget makes upgrades equally simple.

• Check which installed apps have updates: winget upgrade
• Update a single app by ID: winget upgrade --id Mozilla.Firefox
• Update everything at once: winget upgrade --all

Note the command names changed historically — you’ll still see older references to "update", but the modern client commonly uses "upgrade". The upgrade command will enumerate available newer versions and perform the update where a manifest provides an appropriate installer. Running this on a schedule or from a provisioning script reduces exposure to out-of-date software across fleets. Caveat: Some packages require user interaction during upgrade due to the underlying installer’s behavior. Winget’s automation is only as non-interactive as the installer allows; manifests may include or omit silent flags accordingly.

---

Uninstalling apps​

Uninstall is similarly consistent:

• List installed packages to find the target ID: winget list
• Uninstall by ID or name: winget uninstall --id Mozilla.Firefox

If permissions or security dialogs block an uninstall, you can use --force to attempt a stronger removal: winget uninstall --id <PackageID> --force
Note: While winget can orchestrate uninstalls, some apps still surface uninstall confirmation dialogs or per-package cleanup steps because the underlying uninstallers control UX and permission elevation. Expect occasional manual confirmation for certain Win32 programs.

---

Advanced topics and workflows​

Sources, manifests and private repositories​

Winget reads manifests from configured sources. The default includes the Microsoft Store source and the community winget-pkgs repository. Administrators and companies can host private or REST-based sources and add them to winget with winget source add — enabling curated internal catalogs or controlled enterprise delivery. The community manifest repo is the canonical public source; it accepts validated manifests via GitHub pull requests and a validation pipeline.

Export/import and reproducible setups​

For reproducible installs the export/import flow is indispensable:

• Export an installed-app manifest from one machine: winget export -o apps.json
• Recreate that set on another machine: winget import apps.json

This JSON workflow lets you rapidly replicate a configured environment for new devices, imaging, or consistent developer workstations.

Scripting and headless provisioning​

For automated provisioning, combine:

• --accept-package-agreements
• --disable-interactivity
• explicit --id and -e flags

PowerShell and scheduled tasks can run winget commands off-hours to keep machines updated. There are also community PowerShell modules that wrap winget, exposing objects and helper functions to integrate into larger automation pipelines.

Supported installer formats and limits​

Winget supports a broad set of installer formats (EXE, MSI, MSIX, ZIP, Inno, Nullsoft, WIX, BURN, portable and more). But not every installer exposes a clean silent switch or supports fully unattended operation. For that reason, winget requests silent behavior when a manifest indicates the proper switch, but the installer ultimately determines whether prompts appear. When exact non-interactivity matters, verify the manifest’s installer arguments or prefer packages that ship MSIX/MSI installers with predictable silent modes.

---

Troubleshooting common issues​

'winget' not found​

• Confirm App Installer presence in Microsoft Store; reinstall if needed.
• Add %LOCALAPPDATA%\Microsoft\WindowsApps to the PATH or re-register App Installer packages.
• If errors persist, consider installing the latest winget client from the official GitHub releases.

Commands installed but not runnable (command-not-found after install)​

Some packages place shims in WindowsApps with different executable names; in rare cases the installed binary name may not match the expected command (issues have been reported where executables were renamed during packaging). If you install a tool but the command fails, confirm where winget placed the binary and whether its name differs. Rebooting or opening a fresh shell is often necessary so the PATH refreshes; in other cases the manifest needs to be fixed upstream.

Source and validation errors​

If winget fails to update sources or you see validation errors, run winget source reset --force to restore defaults. In enterprise environments using private sources, ensure your REST source endpoints are reachable and that the authentication mode is configured correctly.

---

Security, trust and governance​

Winget’s public repository is community-maintained but goes through automated validation and human review before manifests become widely available. Nonetheless, organizations should adopt governance:

• Use private sources for in-house or approved packages.
• Audit manifests you plan to deploy (URLs, hashes, installer arguments).
• Run provisioning in a controlled network and consider ephemeral sandbox installs for validation.

Microsoft’s repository and policies provide an initial layer of vetting; enterprise teams still benefit from their own validation pipeline to ensure compliance and avoid accidental distribution of misconfigured installers.

---

Winget vs. Scoop vs. Chocolatey — a short comparison​

• Winget (Windows Package Manager)
• Native Microsoft client, integrated with App Installer and Microsoft Store sources.
• Best for straightforward installs, Store interop, reproducible JSON export/import and official manifests.
• Open-source client and community manifests; can host private sources.
• Chocolatey
• Longstanding package manager with a broad ecosystem and additional features for package creation, hosting, and enterprise management.
• Uses NuGet packages; can install many community packages not present in winget.
• Often favored by admins with existing Chocolatey automation and internal repo support.
• Scoop
• Lightweight, user-oriented, focuses on portable and developer tools.
• Installs into user profile and avoids registry/start menu changes by design.

Which to use depends on your goals: winget is the easiest on Windows 11 because of native availability and Microsoft Store integration; Chocolatey and Scoop still shine for niche packages, enterprise policies or specific packaging workflows. Many power users use all three depending on needs.

---

Practical examples (copy/paste friendly)​

• Install Firefox (exact, interactive):
  winget install --id Mozilla.Firefox -e
• Install multiple apps (batch):
  winget install --id Microsoft.VisualStudioCode -e && winget install --id Git.Git -e && winget install --id Docker.DockerDesktop -e
• Silent unattended install (where supported):
  winget install --id Mozilla.Firefox -e --silent --accept-package-agreements --disable-interactivity
• List apps with upgrades and upgrade all:
  winget list --upgrade-available
  winget upgrade --all
• Export current apps and import on new PC:
  winget export -o installed-apps.json
  winget import installed-apps.json

Remember: include -e/--exact and the explicit --accept-package-agreements flags when writing unattended provisioning scripts to avoid prompts.

---

Strengths and why winget is a real productivity win​

• Native and ready: On Windows 11, winget is available out of the box or via App Installer, removing the need to fetch third-party tools for basic package management.
• Scriptable, reproducible installs: JSON export/import and manifest-driven installs let teams recreate environments quickly.
• Large community repository: The winget-pkgs repo contains thousands of manifests maintained publicly; contributors can add or correct manifests, and the process includes automated validation.
• Integration with Microsoft Store: Winget’s dual-source model (msstore + winget community) gives access to both Store apps and community-curated Win32 installers.

---

Risks, limits and what to watch for​

• Not all installers are fully silent. Even with --silent, some installers show prompts—manifest authors can provide silent switches, but the underlying installer determines behavior. Always test unattended flows.
• Command visibility after install can vary. Some packages install binaries with unexpected names or require a new shell session to pick up PATH changes; expect to troubleshoot a small percentage of packages.
• Governance and supply-chain concerns. Community manifests are reviewed, but organizations with strict supply-chain or compliance needs should host private sources or vet manifests before production rollout.
• Edge cases still exist. Source updates, Store-account requirements for certain msstore installs, and legacy installers may require manual intervention in specific environments. Keep fallbacks (manual installs, Chocolatey) in your toolbox.

---

Practical checklist for adoption​

• Verify winget presence: winget --version.
• Add %LOCALAPPDATA%\Microsoft\WindowsApps to PATH if necessary and restart your terminal to refresh environment variables.
• Decide whether to use public community manifests, private sources, or a hybrid approach.
• Build and test a provisioning script using exact IDs and unattended flags; validate each silent install for headless operation.
• Roll out to a pilot group, measure behavior, and tune manifests or fallbacks for problematic packages.
• Automate periodic upgrades (winget upgrade --all) in off-hours for less disruption.

---

Final thoughts​

Winget is a mature, officially supported tool that brings a long-awaited package management model to Windows with the convenience of native delivery and the control of manifest-driven installs. For most Windows 11 users the barrier to entry is minimal — the client is already installed or one Store click away — and the benefits (fast installs, repeatable setups, centralized upgrades) are immediate. At the same time, cautious administrators will want to pair winget with standard IT controls: private sources, manifest review, and staged rollouts.
If you’ve spent years clicking through installers, winget feels like replacing a wheelbarrow with a conveyor belt: the work still gets done, but far faster and with far less chance of human error. Use the commands, test the silent flows, and incorporate winget into your automation toolkit — it’s the easiest, most native way to install and update apps on Windows today.

---

---

Source: How-To Geek The easiest way to install and update apps on Windows is already built in