Merge pull request #6644 from MicrosoftDocs/main

Auto Publish – main to live - 2026-04-16 17:16 UTC

Author: learn-build-service-prod[bot]

hub/apps/publish/contact-us.md

@@ -10,4 +10,4 @@ ms.localizationpriority: medium
 
 If you need any assistance for account creation/management, app submission, app certification or app analytics, a support ticket can be raised from [here.](https://aka.ms/windowsdevelopersupport)
 
-For help with the new account onboarding flow for individual developers (zero registration fees), you can email us directly at [[email protected]](mailto:[email protected]).
+For help with the new account onboarding flow for company developers (zero registration fees), you can email us directly at [[email protected]](mailto:[email protected]).

hub/apps/windows-app-sdk/applifecycle/focus-session.md

@@ -9,7 +9,7 @@ ms.localizationpriority: medium
 
 # Detect and react to focus session state
 
-Windows 11 introduced the Focus feature which helps users minimize distractions by turning on Do Not Disturb and silencing icon flashing and badge notifications for apps in the taskbar. This article shows you how to use the [FocusSessionManager](/uwp/api/windows.ui.shell.focussessionmanager) API to detect whether a Focus session is currently active or receive updates when the Focus session state changes, allowing you to customize your app's behavior to minimize distractions when a Focus session is active. For more information on the Focus feature, see [How to use focus in Windows 11](https://support.microsoft.com/en-us/windows/how-to-use-focus-in-windows-11-cbcc9ddb-8164-43fa-8919-b9a2af072382).
+Windows 11 introduced the Focus feature which helps users minimize distractions by turning on Do Not Disturb and silencing icon flashing and badge notifications for apps in the taskbar. This article shows you how to use the [FocusSessionManager](/uwp/api/windows.ui.shell.focussessionmanager) API to detect whether a Focus session is currently active or receive updates when the Focus session state changes, allowing you to customize your app's behavior to minimize distractions when a Focus session is active. For more information on the Focus feature, see [How to use focus in Windows 11](https://support.microsoft.com/en-us/windows/how-to-use-focus-in-windows-11-aaaabbbb-0000-cccc-1111-dddd2222eeee).
 
 ## Get the current Focus session state
 

hub/powertoys/administrator.md

@@ -1,7 +1,7 @@
 ---
 title: Run PowerToys in Administrator Mode on Windows
 description: Learn how to run PowerToys in administrator mode to ensure compatibility with elevated apps on Windows. Fix FancyZones and other utilities when they don't work with admin applications.
-ms.date: 11/19/2024
+ms.date: 04/15/2026
 ms.topic: concept-article
 ms.localizationpriority: medium
 no-loc: [PowerToys, Windows, FancyZones, Fancy, Zone, Zones]
@@ -55,7 +55,6 @@ Admin mode permissions may be required in the following scenarios:
   - Write keys to the registry
 - Shortcut guide
   - Display shortcut
-- Video Conference Mute
 
 > [!NOTE]
 > Each PowerToys utility has information in its Settings page about whether it requires admin mode and when it's required.

hub/powertoys/command-palette/adding-extension-settings.md

@@ -0,0 +1,138 @@
+---
+title: Add settings to your Command Palette extension
+description: Learn how to add a settings page to your Command Palette extension so users can configure its behavior with toggles, text fields, and choice sets.
+ms.date: 04/12/2026
+ms.topic: how-to
+no-loc: [PowerToys, Windows, Insider]
+# Customer intent: As a Windows developer, I want to learn how to add configurable settings to my Command Palette extension, so that users can customize the extension's behavior.
+---
+
+# Add settings to your extension
+
+**Previous**: [Adding Dock support](adding-dock-support.md)
+
+Extensions can provide their own settings page, letting users configure extension behavior directly within the Command Palette. The settings helpers in the toolkit make it easy to define toggles, text fields, and choice sets without writing UI code.
+
+## How extension settings work
+
+The toolkit provides a [Settings](./microsoft-commandpalette-extensions-toolkit/settings.md) class that manages a collection of typed settings. You define the settings you need, convert them to content for display, and react to changes through an event. Command Palette renders the settings form automatically.
+
+## Add a settings page
+
+1. In the `Pages` directory, add a new class
+1. Name the class `MySettingsPage.cs`
+1. Update the file to:
+
+```csharp
+using Microsoft.CommandPalette.Extensions;
+using Microsoft.CommandPalette.Extensions.Toolkit;
+
+internal sealed partial class MySettingsPage : ContentPage
+{
+    private readonly Settings _settings = new();
+
+    public MySettingsPage()
+    {
+        Name = "Settings";
+        Icon = new IconInfo("\uE713"); // Settings gear icon
+        Title = "Extension Settings";
+
+        _settings.Add(new ToggleSetting("notifications", true)
+        {
+            Label = "Enable notifications",
+            Description = "Show a notification when a task completes",
+        });
+        _settings.Add(new TextSetting("defaultQuery", string.Empty)
+        {
+            Label = "Default search query",
+            Description = "Pre-fill the search box with this text",
+        });
+
+        _settings.SettingsChanged += OnSettingsChanged;
+    }
+
+    public override IContent[] GetContent()
+    {
+        return _settings.ToContent();
+    }
+
+    private void OnSettingsChanged(object sender, Settings args)
+    {
+        // Read updated values
+        var notificationsEnabled = _settings.GetSetting<bool>("notifications");
+        var defaultQuery = _settings.GetSetting<string>("defaultQuery");
+    }
+}
+```
+
+## Available setting types
+
+| Type | Description | Default value type |
+| :--- | :--- | :--- |
+| [ToggleSetting](./microsoft-commandpalette-extensions-toolkit/togglesetting.md) | A checkbox / toggle switch | `bool` |
+| [TextSetting](./microsoft-commandpalette-extensions-toolkit/textsetting.md) | A single-line text input | `string` |
+| [ChoiceSetSetting](./microsoft-commandpalette-extensions-toolkit/choicesetsetting.md) | A drop-down list of choices | `string` (selected value) |
+
+### Choice set example
+
+```csharp
+var choices = new List<ChoiceSetSetting.Choice>
+{
+    new("Small", "sm"),
+    new("Medium", "md"),
+    new("Large", "lg"),
+};
+
+_settings.Add(new ChoiceSetSetting("size", choices)
+{
+    Label = "Result size",
+    Description = "Choose how results are displayed",
+});
+```
+
+## Read setting values
+
+Use `GetSetting<T>` to read a setting value by key at any time:
+
+```csharp
+var isEnabled = _settings.GetSetting<bool>("notifications");
+```
+
+Use `TryGetSetting<T>` when the setting might not exist:
+
+```csharp
+if (_settings.TryGetSetting<string>("defaultQuery", out var query))
+{
+    // use query
+}
+```
+
+## React to changes
+
+Subscribe to the `SettingsChanged` event to be notified when the user modifies any setting:
+
+```csharp
+_settings.SettingsChanged += (sender, args) =>
+{
+    // Refresh your extension state based on the new settings
+};
+```
+
+## Wire the settings page to your extension
+
+To make the settings page accessible from the Command Palette extension manager, expose it from your `ListPage` as a list item, or wire it through your command provider.
+
+```csharp
+new ListItem(new MySettingsPage())
+{
+    Title = "Settings",
+    Subtitle = "Configure extension options",
+    Icon = new IconInfo("\uE713"),
+}
+```
+
+## Related content
+
+- [Settings class reference](./microsoft-commandpalette-extensions-toolkit/settings.md)
+- [ICommandSettings interface](./microsoft-commandpalette-extensions/icommandsettings.md)
+- [Extension samples](samples.md)

hub/powertoys/command-palette/creating-an-extension.md

@@ -8,7 +8,7 @@ no-loc: [PowerToys, Windows, Insider]
 # Customer intent: As a Windows developer, I want to learn how to develop an extension for the Command Palette.
 ---
 
-# How to create Command Palette extensions
+# Getting started with Command Palette extensions
 
 Learn how to build custom extensions for the Command Palette using C#. This comprehensive guide covers everything from project setup to deployment, helping you enhance this powerful productivity tool for Windows.
 
@@ -25,9 +25,7 @@ The Command Palette extension system allows developers to create custom commands
 
 **Prerequisites:**
 
-- Visual Studio with the following workloads
-  - C# development workload
-  - WinUI application development workload
+- [Set up your Windows development environment](/windows/apps/get-started/start-here) — install Visual Studio with the required workloads for WinUI and the Windows App SDK
 - Windows 11 with PowerToys installed
 - Enable [Developer mode on Windows](/windows/advanced-settings/developer-mode)
 - Basic knowledge of C# programming

hub/powertoys/command-palette/extensibility-overview.md

@@ -1,41 +1,21 @@
 ---
-title: Command Palette Extensibility
-description: The Command Palette provides a full extension model, allowing you to create custom experiences for the palette. Learn how to create an extension and publish it.
-ms.date: 2/28/2025
+title: How Command Palette extensions work
+description: Understand the Command Palette extension model, including how extensions register, communicate, and provide commands and pages.
+ms.date: 04/10/2026
 ms.topic: concept-article
 no-loc: [PowerToys, Windows, Insider]
-# Customer intent: As a Windows developer, I want to learn how to develop an extension for the Command Palette.
+# Customer intent: As a Windows developer, I want to understand how the Command Palette extension model works.
 ---
 
-# Extensibility overview
+# How Command Palette extensions work
 
-The Command Palette provides a full extension model, allowing developers to create their own experiences for the palette. 
+Command Palette extensions are standalone .NET applications that communicate with Command Palette through a WinRT API. Each extension runs in its own process and registers with Command Palette through its app manifest, making extensions isolated, secure, and easy to deploy.
 
-The fastest way to get started writing extensions is from the Command Palette itself. Just run the "Create a new extension" command, fill out the fields to populate the template project, and you should be ready to start.
+This page explains the core concepts behind the extension model — how extensions are discovered, how they provide commands and pages, and what kinds of experiences you can build.
 
-For more detailed instructions, you can follow these pages:
+## How Command Palette discovers installed extensions
 
-* [Creating an extension](../command-palette/creating-an-extension.md)
-* [Adding commands](../command-palette/adding-commands.md)
-* [Update a list of commands](../command-palette/update-a-list-of-commands.md)
-* [Add top-level commands to your extension](../command-palette/add-top-level-commands-to-your-extension.md)
-* [Command results](../command-palette/command-results.md)
-* [Display markdown content](../command-palette/using-markdown-content.md)
-* [Get user input with forms](../command-palette/using-form-pages.md)
-* [Adding Dock support](../command-palette/adding-dock-support.md)
-<!-- * [Handle the search text](../command-palette/dynamic-lists.md) -->
-<!-- * [Advanced: Adding an extension to your package](../command-palette/adding-an-extension-to-your-package.md) -->
-
-
-## Extension details
-
-Command Palette defines a WinRT API ([Microsoft.CommandPalette.Extensions](./microsoft-commandpalette-extensions/microsoft-commandpalette-extensions.md)), which is how extensions can communicate with Command Palette. 
-
-Command Palette will use the Package Catalog to find apps that list themselves as an `windows.appExtension` for `com.microsoft.commandpalette`.
-
-### Registering your extension
-
-Extensions can register themselves with the Command Palette using their `.appxmanifest`. As an example:
+Command Palette uses the Windows Package Catalog to find installed apps that declare themselves as Command Palette extensions. Extensions register through their `.appxmanifest` by declaring a `windows.appExtension` with the name `com.microsoft.commandpalette`:
 
 ```xml
 <Extensions>
@@ -67,19 +47,47 @@ Extensions can register themselves with the Command Palette using their `.appxma
 </Extensions>
 ```
 
-In this manifest, we're using an out-of-process COM server to act as the communication layer between your app and Command Palette. **Don't worry about this**! The template project will take care of creating a COM server for you, starting it, and marshalling your objects to Command Palette. 
+Extensions use an out-of-process COM server as the communication layer between your app and Command Palette. **Don't worry about the details** — the template project handles creating the COM server, starting it, and marshalling your objects to Command Palette automatically.
+
+### Important notes about the manifest
+
+- The `AppExtension` must set `Name` to `com.microsoft.commandpalette`. This is the unique identifier that Command Palette uses to discover extensions.
+- The `ComServer` element registers a COM class GUID that Command Palette uses to instantiate your extension. Make sure this CLSID is unique and matches across all three locations in the manifest.
+- The `CmdPalProvider` element in the `Properties` section specifies the CLSID of the COM class that Command Palette will instantiate. Currently, only `Commands` is supported.
+
+## The extension API
 
-### Important notes
+Command Palette defines a WinRT API ([Microsoft.CommandPalette.Extensions](./microsoft-commandpalette-extensions/microsoft-commandpalette-extensions.md)) that extensions use to communicate with Command Palette. A companion toolkit library ([Microsoft.CommandPalette.Extensions.Toolkit](./microsoft-commandpalette-extensions-toolkit/microsoft-commandpalette-extensions-toolkit.md)) provides base classes and helpers that simplify common patterns.
 
-Some notable elements about the manifest example:
+Every extension implements the `IExtension` interface, which provides a `GetProvider` method that returns your `ICommandProvider`. The command provider is where you define the commands and pages that your extension offers.
 
-- The application must specify a `Extensions.uap3Extension.AppExtension` with the Name set to `com.microsoft.commandpalette`. This is the unique identifier which Command Palette uses to find it's extensions.
-- The application must specify a `Extensions.comExtension.ComServer` to host their COM class. This allows for the OS to register that GUID as a COM class we can instantiate.
-  - Make sure that this CLSID is unique, and matches the one in your application. If you change one, you need to change all three.
-- In the `Properties` of your `AppExtension`, you must specify a `CmdPalProvider` element. This is where you specify the CLSID of the COM class that Command Palette will instantiate to interact with your extension. 
-  - Currently, only `Commands` is supported.
+## Commands and pages
+
+Extensions can provide several types of content:
+
+- **Top-level commands** — Commands that appear on the Command Palette home page, making them immediately accessible to users.
+- **Fallback commands** — Commands that are triggered when no other results match a user's query, useful for search-based or catch-all functionality.
+- **Context menu items** — Additional actions that appear in the right-click context menu of other commands.
+
+Each command can navigate to a **page** that displays content. Command Palette supports the following page types:
+
+| Page type | Description |
+| :--- | :--- |
+| **List pages** | Display a searchable list of selectable items. |
+| **Detail pages** | Show rich content with sections, tags, and links. |
+| **Form pages** | Present user input fields for interactive workflows. |
+| **Markdown pages** | Render formatted markdown content. |
+| **Grid pages** | Display items in a gallery or grid layout. |
+
+Extensions can also provide their own settings pages for per-extension configuration, and support pinning commands to the [Dock](dock.md).
+
+## Get started
+
+Ready to build your first extension? Head to [Getting started](creating-an-extension.md) to set up your project and create your first command.
 
 ## Related content
 
-- [PowerToys Command Palette utility](overview.md)
+- [Getting started](creating-an-extension.md)
 - [Extension samples](samples.md)
+- [API reference](sdk-namespaces.md)
+- [PowerToys Command Palette utility](overview.md)

hub/powertoys/command-palette/extension-development.md

@@ -0,0 +1,43 @@
+---
+title: Command Palette extension development
+description: Build extensions for PowerToys Command Palette and bring your tools, workflows, and ideas to millions of Windows power users.
+ms.date: 04/10/2026
+ms.topic: concept-article
+no-loc: [PowerToys, Windows, Insider]
+# Customer intent: Understand the value proposition of building Command Palette extensions and find where to get started.
+---
+
+# Welcome to Command Palette extension development
+
+Command Palette is the go-to launcher for Windows power users — a fast, extensible interface for launching apps, running commands, and getting things done. With the Command Palette extension platform, you can build tools that plug directly into that workflow — putting your ideas right where people are already working.
+
+:::image type="content" source="../images/gallery.png" alt-text="A screenshot of the Command Palette Extension Gallery showing a list of available extensions.":::
+
+Whether you want to build something for yourself, share it with the community, or distribute it to your team, the platform is designed to get you from idea to working extension quickly.
+
+## Why build for Command Palette?
+
+- **Reach users where they are.** Your extension shows up right in the Command Palette — no separate app to open, no context switching.
+- **Built on .NET.** Use C# and the tools you already know. Leverage the full NuGet ecosystem to build what you imagine.
+- **Rich UI without the overhead.** Use built-in page types — lists, forms, markdown, detail views, and grids — to create polished experiences without designing UI from scratch.
+- **Scaffold and go.** Run the `Create extension` command directly from Command Palette to generate a ready-to-build project in seconds.
+- **Share with the community.** Publish your extension to the built-in Gallery and make it available to every Command Palette user.
+
+## How to build and publish an extension
+
+Here's the high-level process for creating and sharing a Command Palette extension:
+
+1. **[Understand how it works](extensibility-overview.md)** — Learn how the extension model works, including page types, commands, and how extensions communicate with Command Palette.
+2. **[Build your extension](creating-an-extension.md)** — Set up your project, add commands and pages, and test your extension locally.
+3. **[Publish your extension](publish-extension.md)** — Distribute your extension through the Microsoft Store, WinGet, or your own hosting.
+
+## What's in the docs
+
+- **[How it works](extensibility-overview.md)** — Understand the extension architecture, page types, and core concepts.
+- **[Getting started](creating-an-extension.md)** — Step-by-step guide to building your first extension.
+- **[Building your extension](adding-commands.md)** — Deep dives into commands, lists, forms, markdown, and Dock support.
+- **[Publishing your extension](publish-extension.md)** — Learn how to package and publish to the Gallery.
+- **[Extension samples](samples.md)** — Open-source examples to learn from and build on.
+- **[API reference](sdk-namespaces.md)** — Detailed API reference for the Command Palette SDK.
+
+Now, let's build. 💪