Skip to main content

​
Experimental Features

WinGet includes experimental features that are in development and not yet ready for general release. These features allow early adopters to test new functionality and provide feedback.

​
Overview

Experimental features are:
  • Disabled by default to avoid disrupting users
  • Configured via settings.json to enable/disable
  • Work in progress and may have incomplete functionality
  • Subject to change before official release
Experimental features may be unstable and are not recommended for production environments.

​
Viewing Available Features

To see all available experimental features and their current status: 
winget features
This displays:
  • Feature name
  • Current status (Enabled/Disabled)
  • Link to related issue or specification
Features may be managed by group policy. Use winget --info to view any policies in effect on your system.

​
Enabling Experimental Features

Enable features by editing your settings.json file:
  1. Open settings: 
    winget settings
  2. Add the experimentalFeatures section: 
    {
  "$schema": "https://aka.ms/winget-settings.schema.json",
  "experimentalFeatures": {
    "directMSI": true,
    "fonts": false,
    "sourcePriority": true
  }
}
  3. Save the file and restart your terminal

​
Available Experimental Features

​
Direct MSI Installation

​
experimentalFeatures.directMSI
boolean
default:"false"
Enable direct MSI installation using MSI APIs instead of msiexec.
When enabled, WinGet installs MSI packages directly using Windows Installer APIs rather than calling msiexec.exe. This is already used for silent installations that require elevation. 
{
  "experimentalFeatures": {
    "directMSI": true
  }
}
Benefits:
  • Improved performance for MSI installations
  • Better error handling and logging
  • More control over the installation process
Use cases:
  • Users who frequently install MSI packages
  • Automation scenarios requiring precise control
  • Troubleshooting MSI installation issues

​
Font Management

​
experimentalFeatures.fonts
boolean
default:"false"
Enable font installation and management capabilities.
Allows WinGet to manage system fonts through the winget font command. 
{
  "experimentalFeatures": {
    "fonts": true
  }
}
Available commands: 
# List installed fonts
winget font list

# Install a font
winget font install "Font Name"

# Uninstall a font
winget font uninstall "Font Name"
Output:
  • Lists installed font families
  • Shows number of installed font faces per family
  • Supports standard WinGet search and filter operations
Font packages must be properly formatted in the package repository with installerType: font.

​
Source Priority

​
experimentalFeatures.sourcePriority
boolean
default:"false"
Enable priority-based source ordering.
Assigns priority values to package sources, affecting search results and package selection. 
{
  "experimentalFeatures": {
    "sourcePriority": true
  }
}
How it works:
  • Sources with higher priority appear earlier in search results
  • Higher priority sources are selected first when multiple sources have the same package
  • Priority is the lowest factor in search ordering (after match quality and field)
Example usage: 
# Add source with priority
winget source add --name CustomRepo --arg https://example.com/packages --priority 10

# List sources with priorities
winget source list
Use cases:
  • Corporate environments with internal package repositories
  • Preferring specific sources for certain packages
  • Managing multiple package sources efficiently
When adding sources with priority enabled:
# High priority (checked first)
winget source add --name Corporate --arg https://corp.example.com --priority 100

# Default priority
winget source add --name Public --arg https://packages.example.com --priority 50

# Low priority (fallback)
winget source add --name Archive --arg https://archive.example.com --priority 10
Search results will prioritize packages from higher-priority sources.

​
Resume (Command Resume)

​
experimentalFeatures.resume
boolean
default:"false"
Enable automatic command resumption after interruption.
Allows certain WinGet commands to resume automatically after interruption (e.g., system reboot). 
{
  "experimentalFeatures": {
    "resume": true
  }
}
Related setting: 
{
  "installBehavior": {
    "maxResumes": 3
  }
}
Behavior:
  • Commands can resume up to maxResumes times
  • Prevents infinite reboot loops
  • Tracks resume state in WinGet’s data store
This feature is designed to handle cases where installers require system reboots. Set maxResumes appropriately to prevent issues.

​
Reference Implementation Features

These features exist as reference implementations and examples:

​
Experimental CMD

​
experimentalFeatures.experimentalCMD
boolean
default:"false"
Reference implementation for an experimental command.
{
  "experimentalFeatures": {
    "experimentalCMD": true
  }
}

​
Experimental ARG

​
experimentalFeatures.experimentalARG
boolean
default:"false"
Reference implementation for an experimental argument.
{
  "experimentalFeatures": {
    "experimentalARG": true
  }
}
These reference features demonstrate how experimental features are implemented in WinGet’s codebase.

​
Feature Lifecycle

​
Development Phase

  1. Feature flagged - Added to codebase behind experimental flag
  2. Settings added - Configuration option added to settings schema
  3. Testing - Early adopters test and provide feedback
  4. Refinement - Feature improved based on feedback

​
Release Phase

  1. Stabilization - Feature considered stable
  2. Documentation - Full documentation written
  3. Default enabled - Feature enabled by default
  4. Flag removal - Experimental flag removed from codebase

​
Deprecation Phase

If a feature is not released:
  1. Announcement - Deprecation announced
  2. Removal - Code and settings removed
  3. Setting ignored - Old setting name preserved (ignored) to prevent reuse

​
Using Experimental Features Safely

  1. Test in non-production - Try features in development environments first
  2. Monitor behavior - Watch for unexpected behavior or errors
  3. Report issues - File bugs on the WinGet GitHub repository
  4. Stay updated - Check release notes for feature changes
  5. Disable if needed - Turn off features that cause problems

​
Error Handling

If you attempt to use an experimental command or option that isn’t enabled: 
$ winget experimentalcmd
Error: This feature is experimental and must be enabled via settings.
Run 'winget settings' to modify your configuration.
To fix:
  1. Run winget settings
  2. Enable the required feature
  3. Save and retry the command

​
Checking Feature Status

Programmatically check if features are enabled: 
# View all settings including experimental features
winget settings --export

# Check feature status
winget features

# View policies affecting features
winget --info

​
Complete Example

Enable multiple experimental features: 
{
  "$schema": "https://aka.ms/winget-settings.schema.json",
  "experimentalFeatures": {
    "directMSI": true,
    "fonts": true,
    "sourcePriority": true,
    "resume": true
  },
  "installBehavior": {
    "maxResumes": 3
  }
}
Verify features are enabled: 
winget features
Expected output: 
Feature         Status   
--------------------------------
directMSI       Enabled  
fonts           Enabled  
sourcePriority  Enabled  
resume          Enabled

​
Troubleshooting

  1. Verify JSON syntax is correct in settings.json
  2. Ensure feature name matches exactly (case-sensitive)
  3. Restart your terminal/command prompt
  4. Run winget features to confirm feature is enabled
  5. Check winget --info for group policies that may override settings
If you get schema validation errors:
  1. Ensure the schema line is present: 
    "$schema": "https://aka.ms/winget-settings.schema.json"
  2. Validate JSON syntax using a linter
  3. Check for typos in feature names
  4. Ensure boolean values are true or false (not strings)

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us