WinGet Guides

WinGet vs Chocolatey vs Scoop (2025): What to Use and When

by Jonathan Dudamel
12 min read

Windows Package Manager has matured fast, and by 2025 you can realistically manage almost your entire Windows software estate with a single command-line tool. Microsoft’s WinGet is now shipping with Windows 10/11 via App Installer and integrates with the Microsoft Store, but long-established ecosystems like Chocolatey and Scoop still have compelling strengths. This guide explains WinGet vs Chocolatey vs Scoop (2025): what to use and when, with practical examples, ready-to-use commands, and script snippets you can drop into your automation today.

You’ll get a side-by-side comparison, step-by-step instructions, YAML examples for WinGet Configuration-as-Code, and guidance for troubleshooting and automation in personal, enterprise, and CI/CD settings.

Overview of the Use Case

What this topic is about in plain language

  • You want to automate software installation, updates, and removal on Windows using a package manager.
  • You’re deciding between three popular tools: Microsoft’s WinGet, Chocolatey, and Scoop.
  • You care about consistency (fresh installs), speed (bulk updates), and automation (DevBox, lab machines, CI/CD, Intune/Endpoint Manager).

Common scenarios where you need it

  • Fresh OS installs or new developer workstations: quickly install a curated stack (browsers, IDEs, runtimes, CLI tools).
  • Bulk updates: keep dozens or hundreds of apps patched without manually hunting download links.
  • CI/CD pipelines: reproducible environments on build runners and ephemeral VMs.
  • Enterprise device management: standardize fleets with version pinning, auditability, and Store integration.
  • Offline or restricted networks: pre-download installers, use internal feeds, or leverage manifests.

Quick Reference Table

Command Purpose Example Output
winget search vscode Find packages by name (WinGet) Name: Microsoft Visual Studio Code, Id: Microsoft.VisualStudioCode, Version: 1.93.0
winget install –id Microsoft.PowerToys –silent –scope machine Install a package silently (WinGet) Successfully installed Microsoft.PowerToys
winget upgrade –all –include-unknown Upgrade everything (WinGet) 7 packages upgraded, 1 package skipped
winget export -o devbox.json –include-versions Export installed apps (WinGet) Exported 31 packages to devbox.json
choco install git -y Install a package (Chocolatey) Chocolatey installed 1/1 packages
choco upgrade all -y Upgrade everything (Chocolatey) Upgraded 12/12 packages
choco list –local-only List installed (Chocolatey) git 2.47.0, nodejs 22.5.1
scoop install -g 7zip Install portable app globally (Scoop) Linking ~\scoop\apps\7zip\current…
scoop update * Update all (Scoop) Updated 18 apps
scoop bucket add extras Add a community bucket (Scoop) ‘extras’ bucket added

Key Concepts and Prerequisites

Tools you’ll need

  • WinGet (Windows Package Manager):
    • Ships via Microsoft Store “App Installer” on Windows 10/11. Corporate images can include it offline.
    • Check version with: winget –info
  • PowerShell:
    • Recommended for scripting across all three tools.
    • Run as Administrator when installing system-wide software (machine scope).
  • Admin rights:
    • WinGet can install per-user or machine-wide; some apps require elevation.
    • Chocolatey typically runs elevated for system installs.
    • Scoop installs to your user profile by default (no admin required), with -g for global installs.

How to verify your WinGet version and sources

  • Check version and any experimental features:
    • winget –info
  • Update the default source and MS Store source:
    • winget source update
    • winget source list

Typical constraints and their workarounds

  • Corporate networks may block public endpoints; use internal feeds or pre-downloaded installers.
  • Some packages need extra flags to avoid UI and EULAs:
    • WinGet: –silent or –accept-package-agreements –accept-source-agreements
    • Chocolatey: -y for non-interactive
    • Scoop: portable installs rarely prompt, but some apps may

Step-by-Step Guide

H3: 1) Choose the right tool for your scenario

  • Pick WinGet if you:
    • Are on Windows 10/11, want an official Microsoft-backed catalog and Store integration.
    • Need Intune/Endpoint Manager app deployment via “Microsoft Store app (new)” using WinGet Ids.
    • Prefer strong hash validation and manifests curated for MSI/EXE/MSIX.
  • Pick Chocolatey if you:
    • Need mature Windows server automation, package scripts with rich install logic.
    • Want packages.config workflows, private repos, and optional business features (central mgmt, internalization).
  • Pick Scoop if you:
    • Want developer-first, portable CLI tools without admin rights.
    • Prefer easy version switching and “buckets” for cutting-edge or niche tools.
See also  Schedule Auto-Updates for All Apps with WinGet + Task Scheduler

H3: 2) Install the package manager

WinGet

  • On Windows 10/11, ensure App Installer (Microsoft Store) is installed/updated. Then:
    • winget –info
    • winget source update

Chocolatey (run in an elevated PowerShell)

  • Set-ExecutionPolicy Bypass -Scope Process -Force; [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; iex ((New-Object System.Net.WebClient).DownloadString(‘https://community.chocolatey.org/install.ps1‘))
  • Verify:
    • choco –version

Scoop (user install in PowerShell)

  • Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
  • iwr -useb get.scoop.sh | iex
  • Optional: accelerate downloads: scoop install aria2
  • Verify:
    • scoop –version

H3: 3) Find and inspect packages

WinGet

  • winget search firefox
  • winget show –id Mozilla.Firefox –exact
  • Tip: prefer –id + –exact to avoid “multiple installers found.”

Chocolatey

  • choco search firefox
  • choco info firefox

Scoop

  • scoop bucket add extras
  • scoop search firefox
  • scoop info firefox

H3: 4) Install packages silently (per-user vs machine)

WinGet

  • Per-user (no elevation required for most apps):
    • winget install –id Microsoft.VisualStudioCode –silent –scope user
  • Machine-wide (requires elevation):
    • winget install –id Microsoft.PowerToys –silent –scope machine –accept-package-agreements
  • Add exact version or locale:
    • winget install –id Git.Git –version 2.47.0
    • winget install –id Mozilla.Firefox –locale en-US

Chocolatey

  • choco install googlechrome -y
  • Version pin:
    • choco install git –version 2.47.0 -y

Scoop

  • scoop install ripgrep
  • Global (requires elevation):
    • scoop install -g 7zip
  • Install a specific version (if available):
    • scoop install nodejs@22.5.1

H3: 5) Bulk import/export for reproducible setups

WinGet export/import (JSON)

  • Export what’s installed (with versions):
    • winget export -o devbox.json –include-versions
  • Import on a new machine:
    • winget import -i .\devbox.json –accept-package-agreements –accept-source-agreements
  • Tip: Use –ignore-unavailable to skip missing packages.

WinGet Configuration-as-Code (YAML)

  • For more than just apps (settings, DSC-like resources), use WinGet Configure.
  • Sample YAML (comments included):

yaml

Contents show

devbox.yaml – WinGet Configure (2025)

Apply with:

winget configure –file .\devbox.yaml –accept-configuration-agreements

Requires WinGet with Configure feature enabled (winget –info)

properties:
configurationVersion: 0.2
resources:

  • resource: Microsoft.WinGet.DSC/WinGetPackage
    id: vscode
    directives:
    description: Install Visual Studio Code (user scope)
    settings:
    packageIdentifier: Microsoft.VisualStudioCode
    installScope: user
    source: winget
    ensure: Present
    allowUpgrade: true
  • resource: Microsoft.WinGet.DSC/WinGetPackage
    id: powertoys
    directives:
    description: Install PowerToys machine-wide
    settings:
    packageIdentifier: Microsoft.PowerToys
    installScope: machine
    source: winget
    ensure: Present
    allowUpgrade: true

Chocolatey packages.config (XML)

  • Export installed packages:
    • choco export –output packages.config
  • Reinstall from packages.config:
    • choco install packages.config -y
  • Note: You can also script choco list –local-only to build a package list if export is unavailable.

Scoop export/import

  • Export list:
    • scoop export > scoopfile.json
  • Import on a new machine:
    • scoop import .\scoopfile.json
  • Pre-download installers for offline:
    • scoop download git 7zip nodejs

H3: 6) Upgrading, pinning, and uninstalling

WinGet

  • Upgrade all:
    • winget upgrade –all –include-unknown
  • Pin a version to avoid unintended upgrades:
    • winget pin add –id Microsoft.VisualStudioCode –version 1.92.0
    • List pins: winget pin list
    • Remove pin: winget pin remove –id Microsoft.VisualStudioCode
  • Uninstall:
    • winget uninstall –id Mozilla.Firefox

Chocolatey

  • Upgrade all:
    • choco upgrade all -y
  • Pin and unpin:
    • choco pin add -n=git
    • choco pin remove -n=git
  • Uninstall:
    • choco uninstall googlechrome -y

Scoop

  • Update all:
    • scoop update *
  • Hold and unhold:
    • scoop hold nodejs
    • scoop unhold nodejs
  • Uninstall:
    • scoop uninstall ripgrep

H3: 7) Advanced installer parameters

WinGet

  • Many MSI/EXE installers expose silent switches; WinGet handles most automatically via manifests.
  • To pass custom parameters, use –override (for MSI/EXE):
    • winget install –id Git.Git –silent –override “/COMPONENTS=icons,ext\reg”
  • Common flags:
    • –silent (or –interactive, –silent-with-progress)
    • –accept-package-agreements –accept-source-agreements
    • –scope user|machine
    • –exact (match exact Id)
    • –source winget|msstore

Chocolatey

  • choco install vscode -y –params “‘/NoDesktopIcon /SuppressRefresh'”
  • choco has package maintainers’ scripts; read choco info for switches.

Scoop

  • Mostly portable archives; no installer switches needed.
  • For apps with installers, the manifest controls silent args; advanced users can override via custom manifests or buckets.
See also  The Ultimate WinGet Provisioning Script: From Bare Metal to Ready in 15 Minutes

Troubleshooting

Common WinGet issues and fixes

  • Hash mismatch or installer changed upstream:
    • Try again after source update:
      • winget source update
    • Use a specific version if the latest is inconsistent:
      • winget install –id App.Id –version x.y.z
    • If urgent, and you trust the source, install from official vendor manually and report the issue to the WinGet repo.
  • Multiple installers found:
    • Specify architecture/scope/locale:
      • winget install –id App.Id –exact –scope machine –architecture x64 –locale en-US
  • Source index errors or missing results:
  • Upgrades not detected:
    • Use:
      • winget list
      • winget upgrade –all –include-unknown
    • Some apps don’t expose version info consistently; pin or manage manually if required.

Common Chocolatey issues and fixes

  • Checksum errors:
    • Wait for package maintainer to update; to proceed at your own risk:
      • choco install -y –ignore-checksums
  • Source problems or throttling:
    • choco source list
    • choco source disable -n chocolatey
    • choco source add -n internal -s http://yourrepo/nuget
  • Broken package state:
    • choco uninstall -y
    • choco clean -y
    • choco install -y

Common Scoop issues and fixes

  • Stale bucket manifests:
    • scoop update
    • git -C “$(scoop prefix)/buckets/main” pull
  • Cache or download failures:
  • App misbehaving after update:
    • scoop reset
  • Health check:
    • scoop checkup

Logging and diagnostics

  • WinGet logs:
    • %LOCALAPPDATA%\Packages\Microsoft.DesktopAppInstaller_8wekyb3d8bbwe\LocalState\DiagOutputDir
  • Chocolatey logs:
    • C:\ProgramData\chocolatey\logs
  • Scoop logs:
    • Check the PowerShell console output and the ~/.config/scoop directory

Automation Tips

H3: Use PowerShell to orchestrate all three

Scheduled weekly update script (run elevated if you manage machine-wide apps)
powershell

Update-WindowsPackages.ps1

Write-Host “Updating WinGet sources and apps…”
winget source update
winget upgrade –all –include-unknown –silent –accept-package-agreements

Write-Host “Updating Chocolatey apps…”
choco upgrade all -y

Write-Host “Updating Scoop apps…”
scoop update
scoop cleanup # remove old versions to free space

Schedule it via Task Scheduler under an admin account.

H3: DevBox bootstrap script (fresh install)
powershell

Bootstrap.ps1 – run as admin

Ensure managers exist or install them

if (-not (Get-Command winget -ErrorAction SilentlyContinue)) {
Write-Host “Please install App Installer from Microsoft Store for WinGet.”
}

if (-not (Get-Command choco -ErrorAction SilentlyContinue)) {
Set-ExecutionPolicy Bypass -Scope Process -Force

iex ((New-Object Net.WebClient).DownloadString(‘https://community.chocolatey.org/install.ps1‘))
}

if (-not (Get-Command scoop -ErrorAction SilentlyContinue)) {
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
iwr -useb get.scoop.sh | iex
}

WinGet installs

winget install –id Microsoft.PowerToys –silent –scope machine –accept-package-agreements
winget install –id Microsoft.VisualStudioCode –silent –scope user –accept-package-agreements

Chocolatey installs

choco install git 7zip -y

Scoop installs (user scope)

scoop bucket add extras
scoop install ripgrep fd

H3: WinGet in Intune/Endpoint Manager

  • Use “Microsoft Store app (new)” and search by WinGet Id, e.g., Microsoft.PowerToys.
  • Assign as Required to device groups for machine-wide installs, or Available for self-service.
  • Version pinning can be achieved by specifying a particular version in your deployment or by using rings with pilot groups.

H3: CI/CD pipelines

  • GitHub Actions (windows-latest runners include WinGet and often Chocolatey):
    • steps:
      • run: winget source update
      • run: winget install –id Git.Git –silent –accept-package-agreements
      • run: choco install nodejs -y
      • run: scoop install jq
  • Azure DevOps Windows agents: similar commands in a Powershell task.

H3: Offline/restricted networks

  • WinGet:
    • Pre-fetch installers:
      • winget download –id Microsoft.VisualStudioCode –output C:\OfflineCache
    • Install with a local manifest that points to cached installer:
      • winget install –manifest .\vscode.yaml
  • Chocolatey:
    • Use an internal NuGet-compatible feed (e.g., Nexus/Artifactory). Business features support internalization of package resources.
  • Scoop:
    • Pre-download:
      • scoop download
    • Host your own bucket Git repo with manifests pointing at internal mirrors.

Best Practices

  • Prefer exact identifiers and versions
    • WinGet: winget install –id Vendor.App –exact –version x.y.z
    • Chocolatey: choco install app –version x.y.z -y
    • Scoop: scoop install app@x.y.z
  • Use pins to control drift
    • WinGet: winget pin add –id App –version x.y.z
    • Chocolatey: choco pin add -n=App
    • Scoop: scoop hold App
  • Standardize scope
    • Use –scope machine for apps needed by all users; otherwise default to user installs for least privilege.
  • Create reusable, readable manifests
    • WinGet: adopt winget configure with clear YAML resources and comments.
    • Chocolatey: keep packages.config or scripts in source control; document parameters.
    • Scoop: maintain a custom bucket for internal apps or custom versions; review manifests for hash and URLs.
  • Favor silent, unattended installs
    • WinGet: –silent, –accept-package-agreements
    • Chocolatey: -y, read package notes for additional params
    • Scoop: typically silent by design
  • Keep sources healthy
    • winget source update; winget source reset if needed
    • choco source list and prefer internal mirrors where possible
    • scoop update; git pull buckets; audit third-party buckets
  • Audit and log
    • Capture logs per tool for compliance and troubleshooting.
  • Test changes in a staging ring
    • Especially for enterprise or shared images; validate major version bumps before production rollout.
See also  WinGet in CI/CD: Provision Windows Build Agents the Right Way

Conclusion

WinGet vs Chocolatey vs Scoop (2025) isn’t about picking one “winner”—it’s about using the right tool in the right context:

  • Use WinGet when you want Microsoft-backed manifests, Store integration, excellent enterprise alignment, and straightforward installs/upgrades with strong hashing.
  • Use Chocolatey when you want rich scripted installs, server automation patterns, packages.config workflows, and optional business features for internalization and central management.
  • Use Scoop when you want fast, portable, developer-centric tooling without admin rights, plus easy version switching via buckets.

With the commands and scripts above, you can install, export/import, upgrade, pin, and automate confidently. Try the examples on a test machine, keep versions pinned for critical apps, and you’ll find these package managers are safe, powerful, and a huge time-saver.

FAQ

H4: Is WinGet safe to use compared to Chocolatey and Scoop?

  • Yes, WinGet is maintained by Microsoft and uses manifests with SHA256 hashes for verification. Chocolatey and Scoop are also broadly safe when using official sources, but always review manifests and trust only reputable buckets/sources. In enterprises, prefer internal mirrors and signed binaries.

H4: Can I use WinGet, Chocolatey, and Scoop together on the same machine?

  • Yes. Many power users do. Keep in mind:
    • Avoid installing the same app via multiple managers to reduce conflicts.
    • Standardize scope (user vs machine).
    • Document which manager “owns” which apps.

H4: Which manager is best for CI/CD pipelines?

  • All three work. WinGet is excellent on Windows runners and aligns with Store apps; Chocolatey has a long server automation history; Scoop is fast for portable developer tooling. Choose based on your toolchain (e.g., node/python via Scoop; enterprise apps via WinGet/Chocolatey).

H4: How do I pin versions to prevent surprise upgrades?

  • WinGet: winget pin add –id App –version x.y.z
  • Chocolatey: choco pin add -n=App
  • Scoop: scoop hold App or install a specific version (app@x.y.z)

H4: I’m behind a proxy or in an offline environment. What are my options?

  • WinGet: pre-download with winget download; install from local manifests; consider internal repositories.
  • Chocolatey: configure choco source to an internal NuGet feed; business editions support internalization.
  • Scoop: scoop config proxy and scoop download; host your own bucket with internal URLs.

When to use which: a short cheat sheet

  • WinGet:
    • Windows 10/11 and Intune/Endpoint Manager integration
    • Strong hashing, Store support, simple silent installs
  • Chocolatey:
    • Server/enterprise automation with rich scripting
    • packages.config workflows, internal repos, optional business features
  • Scoop:
    • Developer workstations, portable CLI tools, no admin rights
    • Buckets for multiple versions and niche tools

Appendix: Additional helpful commands

WinGet

  • winget list –source winget
  • winget show –id App.Id –exact –versions
  • winget settings export > winget-settings.json

Chocolatey

  • choco outdated
  • choco feature list
  • choco config list

Scoop

  • scoop list
  • scoop cleanup *
  • scoop bucket known

Use these building blocks to assemble a package management strategy that matches your environment’s needs today and scales smoothly into tomorrow.

About the author

Jonathan Dudamel

Jonathan Dudamel

I'm Jonathan Dudamel, an experienced IT specialist and network engineer passionate about all things Windows. I have deep expertise in Microsoft project management, virtualization (VMware ESXi and Hyper-V), and Microsoft’s hybrid platform. I'm also skilled with Microsoft O365, Azure ADDS, and Windows Server environments from 2003 through 2022.

My strengths include Microsoft network infrastructure, VMware platforms, CMMS, ERP systems, and server administration (2016/2022).

View all posts

You may also like