The post Announcing Microsoft Desired State Configuration v3.1.0 appeared first on PowerShell Team.
]]>We’re pleased to announce the General Availability of Microsoft’s Desired State Configuration (DSC) version 3.1.0. This release marks a significant milestone in our effort to deliver cloud-native configuration management for cross-platform environments. DSC is a declarative configuration and orchestration platform that defines a standard way of exposing settings for applications and services. DSC v3.1.0 is built on collaboration with key improvements driven by partner requests. Special thanks to the Windows Package Manager (WinGet) team and the incredible support of the DSC community.
For additional details about the initial DSC v3.0.0 release, see:
This release continues our momentum by delivering features and improvements driven by real world use, partner feedback, and community contributions.
DSC v3.1 includes updates and fixes across the platform. Here are some of the most important improvements:
WinGet and partner-driven enhancements
Resource authoring improvements
Cross-Platform reliability and bug fixes
Performance and quality
set
, test
, and get
operations.Diagnostics and usability
For a full list of changes, see the DSC v3.1 changelog
To get started, follow these steps to install DSC on your system:
On Windows, you can install DSC from the Microsoft Store using winget
. By installing from the
Store or using winget
, you get automatic updates for DSC.
Search for the latest version of DSC:
winget search DesiredStateConfiguration --source msstore
Name Id Version Source
---------------------------------------------------------------
DesiredStateConfiguration 9NVTPZWRC6KQ Unknown msstore
DesiredStateConfiguration-Preview 9PCX3HX4HZ0Z Unknown msstore
Install DSC using the id
parameter:
# Install latest stable
winget install --id 9NVTPZWRC6KQ --source msstore
# Install latest preview
winget install --id 9PCX3HX4HZ0Z --source msstore
On Linux and macOS, you can install DSC using the following steps:
PATH
environment variable.DSC follows semantic versioning.
The first release of DSC version 3.0.0 is a Stable release. DSC version 3.1.0 is the current Stable release. Patch releases update the third digit of the semantic version number. For example, 3.1.1 is a patch update to 3.1.0. Stable releases receive patches for critical bugs and security vulnerabilities for three months after the next Stable release. For example, version 3.1.0 is supported for three months after 3.2.0 is released.
Always update to the latest patch version of the release you’re using.
For more information about Desired State Configuration v3.0 (DSC), see the DSC documentation. We value your feedback. Stop by our GitHub repository and let us know of any issues you find.
Jason Helmick
Sr. Product Manager, PowerShell
The post Announcing Microsoft Desired State Configuration v3.1.0 appeared first on PowerShell Team.
]]>The post AI Shell Preview 4 Release! appeared first on PowerShell Team.
]]>We’re excited to share the latest preview release of AI Shell that includes new features and
improvements based on your feedback. This release focuses on improving the user experience by
improving access to Azure OpenAI deployments, improvements to the Invoke-AIShell
command, and
expanded compatibility with macOS.
We’ve made significant improvements to the macOS side car experience with iTerm2. Previously, the
side car experience was unreliable and didn’t support the /code post
command. Now you have a more
reliable experience with feature parity with your experience on Windows. For this experience you
need to run PowerShell 7 in iTerm2. For more information about PowerShell 7 on macOS, see
Installing PowerShell on macOS.
To keep password and keys secure, we’ve added support for Entra ID authentication to to Azure OpenAI instances. Now you can access your Azure OpenAI resource without storing keys in the configuration file. The following example shows how to configure Entra ID authentication:
{
// Declare GPT instances.
"GPTs": [
// Declaration of an Azure OpenAI instance with EntraID authentication
{
"Name": "ps-az-entraId",
"Description": "A GPT instance with expertise in PowerShell scripting using Entra ID authentication.",
"Endpoint": "<Your Endpoint>",
"Deployment": "<Your Deployment Name>",
"ModelName": "<Your Model Name>",
"AuthType": "EntraID",
"SystemPrompt": "You are a helpful and friendly assistant with expertise in PowerShell scripting and command line."
}
],
// Specify the default GPT instance to use for user query.
"Active": "ps-az-entraId"
}
This is the hierarchy of credentials that AI Shell will use to authenticate to Azure OpenAI:
EnvironmentCredential
WorkloadIdentityCredential
ManagedIdentityCredential
SharedTokenCacheCredential
VisualStudioCredential
AzureCliCredential
AzurePowerShellCredential
AzureDeveloperCliCredential
InteractiveBrowserCredential
For more information on what these particular credentials are, please see the DefaultAzureCredential reference.
We’ve added additional parameters to the Invoke-AIShell
command to allow for easier use of the
side pane without leaving the left side of the screen.
-PostCode
– This parameter allows you to post code generated from the side pane to the connected
PowerShell session. It reduces the need to switch between the side pane and terminal to run the
/code post
command.-CopyCode
– This parameter allows you to copy code from the side pane without using the
/code copy
command.-Exit
– This parameter allows you to exit the side pane without using the /exit
command.These new parameters allow you to use your terminal normally. You can inject AI generated commands without cluttering your main buffer and keep all the details and descriptions in the side pane. This is a great way to use AI Shell as side by side shell assistant! Coupled with PSReadLine Predictive IntelliSense, you can quickly and easily use AI Shell in your normal shell workflow.
We’ve added a new experimental agent called Phi Silica. This agent uses the built-in Phi Silica model included with the latest Copilot+ PCs, allowing you to have an offline experience with AI Shell.
Note
This agent isn’t shipped with the default installation of AI Shell. To use this agent, you need to clone the repo and build the code. Follow the instructions at Locally Building AI Shell.This experimental AI provider is a proof of concept that’s still under development. You should only use it for testing. Expect breaking changes in future releases.
Here are a few additional improvements that have been made in this release:
To see the full list of changes, check out the changelog in the release page.
To install the latest version of AI Shell, run the following command in your PowerShell terminal:
Invoke-Expression "& { $(Invoke-RestMethod 'https://aka.ms/install-aishell.ps1') }"
As usual we would love for you to try AI Shell and provide feedback in our GitHub repository.
Thanks so much!
AI Shell Team
Steven Bucher & Dongbo Wang
The post AI Shell Preview 4 Release! appeared first on PowerShell Team.
]]>The post PowerShell, OpenSSH, and DSC team investments for 2025 appeared first on PowerShell Team.
]]>First, apologies getting this out so late into the year. We’ve been very busy and just found the time to write this update.
We continue to treat security as a top priority and as issues are discovered or reported, we will continue to prioritize these issues over new feature development.
We continue to fix various reported issues, as well as prioritizing the review and merging of community pull requests. Based on community feedback, we’re now using a GitHub project to provide transparency on which issues and pull requests team members are focusing on.
PowerShell 7.6 will be our latest Long-Term Servicing (LTS) release. We continue to align with the .NET 10 release cycle and support lifecycle. There have already been 4 preview releases published.
This has been a long-standing request from the community due to automatic sync of MyDocuments folder and OneDrive. While some users want to leverage OneDrive for syncing across their systems, many other users complain about the performance impact on PowerShell module discovery when modules are stored in the OneDrive folder. There was a previous experimental feature PSModuleAutoLoadSkipOfflineFiles that is now mainstream in PowerShell 7.5. With this change, PowerShell skips modules that are not marked being available locally. However, this also led to confusion for users who expected their modules to be available when they were not on disk.
As any change here is a breaking change, we’ve spent a lot of time discussing the best way to approach this. We are close to finishing a proposal that we will publish to the PowerShell-RFC repository for community feedback when ready. We will have experimental feature available within the 7.6 preview cycle for users to test and provide feedback on.
Note that the PowerShell content folder does not just contain modules, but also the user’s PowerShell profile, scripts installed from PowerShell Gallery, and updated help files.
A common ask from several of our Microsoft partners who are building native commands (Azure CLI, Winget) is to more easily integrate features such as Feedback Providers and Tab Completion where they don’t need to publish a separate module from their application.
We have already published a design proposal in our RFC repo and would welcome any feedback from the community. One of the key requirements is that an application’s install and uninstall should be clean and not leave behind any artifacts in PowerShell.
PATH
environment variable for WinGetCurrently, if you use WinGet to install a package, it will not update the PATH
environment variable.
This means that newly installed applications are not available in the current PowerShell session.
This feature will be similar to the one made in cmd.exe
and only apply to a specific applications.
As part of our work to enable managing popular developer applications’ settings,
we are working on exposing pwsh
as a DSC v3 resource.
This will allow users to manage the settings of PowerShell 7 in a declarative manner.
Significant behind-the-scenes work is happening to migrate the PowerShell Gallery from an Azure Cloud Services classic application to one hosted on Azure Kubernetes Service (AKS). This is a difficult effort but, ideally, one that won’t affect user access or performance.
Concurrently, we are working on support for EntraID authentication that allows users to use a managed identify to publish modules to the PowerShell Gallery instead of an API key.
Along with the changes necessary on the PowerShell Gallery side, corresponding changes are being made to PSResourceGet to support EntraID authentication.
We continue to progress towards General Availability for support of Microsoft Artifact Registry (MAR) in PSResourceGet. This allows users to have a default trusted repository for modules and scripts published by Microsoft. This is built on top of the support we already added for Azure Container Registry (ACR) Over time, we plan to generally support ORAS as a standard for storing artifacts in container registries, which would enable support any container registry that supports the OCI distribution spec.
We continue to merge upstream OpenSSH changes into our Windows OpenSSH distribution with previews published to GitHub and the final release updated into Windows.
We continue to develop a DSC v3 resource for SSHD_CONFIG
with expectations that previews will be available later this year.
We already announced DSC 3.0 General Availablity last month and already have two service updates available.
DSC v3.0 is available in the Microsoft Store or from our GitHub repo. The macOS and Linux releases are curently only available from our GitHub repo.
In addition, we are making rapid progress on a DSC v3.1 release with multiple previews already available. Preview releases are also available from the Microsoft Store or our GitHub repo.
You can see what features are approved or being considered for the 3.1 release.
Our AI Shell project continues to make progress towards integration of AI into the shell to boost productivity.
Some further improvements being planned:
We will continue to address reported issues and merge community pull requests for the following projects:
Security is our top priority. We continue to improve the security of how we deliver software. Those improvements are not visible to the community, but they ensure that we are delivering secure software. We will continue to work on the community’s top issues and pull requests across our many projects, when possible. We are very thankful to our active community members!
The post PowerShell, OpenSSH, and DSC team investments for 2025 appeared first on PowerShell Team.
]]>The post Authoring Enhancements in Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>Microsoft Desired State Configuration (DSC) v3.0.0 provides powerful feature that enhance the authoring experience.
TIP
This post uses the following terminology:
The completer command returns a shell script that, when executed, registers completions for the given shell.
DSC can generate completion scripts for the following shells:
To learn more, see the dsc completer
command reference documentation.
Working with DSC platform involves writing configuration documents and resource manifests. DSC validates these data files using a JSON schema. While the DSC schemas are useful for authoring, DSC also includes a set of enhanced schemas for authoring the files in VS Code.
These schemas define extra keywords specific to VS Code that:
To learn more, see Authoring with Enhanced Schemas.
Bicep is Microsoft’s domain specific language (DSL) for creating declarative Azure Resource Manager (ARM) deployments. It offers a clean, intuitive syntax that makes writing and maintaining DSC configurations more efficient. By using Bicep as a DSL, DSC users enjoy the benefits of strong validation, modularity, and seamless integration with Azure-native tooling, without the complexity of authoring in JSON or YAML.
You can write and invoke Bicep configurations locally–without access to Azure–or as part of your Azure deployments, combining Infrastructure as code (IaC) and Configuration as code (CaC).
The following Bicep configuration document calls the classic PowerShell resource WindowsFeature
from the PSDesiredStateConfiguration module to install the IIS web server feature on Windows
Server.
targetScope = 'dsc'
resource powershellAdapter 'Microsoft.Windows/WindowsPowerShell@2025-01-07' = {
name: 'Web server install'
properties: {
resources: [
{
name: 'Run WindowsFeature'
type: 'PSDesiredStateConfiguration/WindowsFeature'
properties: {
Name: 'Web-server'
Ensure: 'Present'
}
}
]
}
}
By default, a Bicep file is scoped to a Bicep resource. To use Bicep with DSC, you must set the
scope to dsc
. Bicep support is still being developed. We’ll make an announcement when Bicep
support and documentation is available.
For more information about DSC v3.0, see the DSCv3 documentation. We value your feedback. Stop by our GitHub repository and let us know of any issues you find.
Jason Helmick
Sr. Product Manager, PowerShell
The post Authoring Enhancements in Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>The post Get started with Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>This is the second post in a multi-part series about the new release of DSC.
Microsoft Desired State Configuration (DSC) v3.0.0 is a modern, cross-platform configuration management framework designed to help administrators and developers declaratively define and enforce system states. Whether you’re managing infrastructure, deploying applications, or automating system configurations, DSC provides a flexible and scalable approach to configuration as code.
TIP
This post uses the following terminology:
To get started, follow these steps to install DSC on your system:
On Windows, you can install DSC from the Microsoft Store using winget
. By installing from the
Store or using winget
, you get automatic updates for DSC.
winget search DesiredStateConfiguration
winget install --id <insert-package-id> --source msstore
On Linux and macOS, you can install DSC using the following steps:
PATH
environment variable.The dsc
command operates on a configuration document or invokes specific resources to manage
settings.
Run the following command to display the dsc
command help:
dsc --help
Apply configuration or invoke specific DSC resources
Usage: dsc.exe [OPTIONS] <COMMAND>
Commands:
completer Generate a shell completion script
config Apply a configuration document
resource Invoke a specific DSC resource
schema Get the JSON schema for a DSC type
help Print this message or the help of the given subcommand(s)
Options:
-l, --trace-level <TRACE_LEVEL> Trace level to use [possible values: error, warn, info, debug, trace]
-t, --trace-format <TRACE_FORMAT> Trace format to use [default: default] [possible values: default, plaintext, json]
-h, --help Print help
-V, --version Print version
Use the command to get version information.
dsc --version
dsc 3.0.0
To learn more, see the dsc
command reference documentation.
dsc resource
The dsc resource
command displays or invokes a specific DSC resource. The dsc resource
command
contains subcommands for listing DSC resources and invoking them directly.
Use the following command to display a list of installed DSC resources.
dsc resource list
Type Kind Version Caps RequireAdapter Description
----------------------------------------------------------------------------------------------------
Microsoft.DSC.Transitional/RunCommandOnSet Resource 0.1.0 gs------ Takes a si…
Microsoft.DSC/Assertion Group 0.1.0 gs--t--- `test` wil…
Microsoft.DSC/Group Group 0.1.0 gs--t--- All resour…
Microsoft.DSC/PowerShell Adapter 0.1.0 gs--t-e- Resource a…
Microsoft.Windows/RebootPending Resource 0.1.0 g------- Returns in…
Microsoft.Windows/Registry Resource 0.1.0 gs-w-d-- Manage Win…
Microsoft.Windows/WMI Adapter 0.1.0 g------- Resource a…
Microsoft.Windows/WindowsPowerShell Adapter 0.1.0 gs--t--- Resource a…
When the command includes the adapter option, dsc
checks for any resource adapters with a matching
name. Classic PowerShell resources are part of the Microsoft.Windows/WindowsPowerShell
adapter.
dsc resource list --adapter Microsoft.Windows/WindowsPowerShell
Partial listing
Type Kind Version Caps RequireAdapter
----------------------------------------------------------------------------------------------------
PSDesiredStateConfiguration/Archive Resource 1.1 gs--t--- Microsoft.Windo…
PSDesiredStateConfiguration/Environment Resource 1.1 gs--t--- Microsoft.Windo…
PSDesiredStateConfiguration/File Resource 1.0.0 gs--t--- Microsoft.Windo…
PSDesiredStateConfiguration/Group Resource 1.1 gs--t--- Microsoft.Windo…
PSDesiredStateConfiguration/GroupSet Resource 1.1 gs--t--- Microsoft.Windo…
PSDesiredStateConfiguration/Log Resource 1.1 gs--t--- Microsoft.Windo…
To learn more, see the dsc
resource command reference documentation.
The dsc config
command includes subcommands for managing the resource instances defined in a DSC
configuration document.
The following YAML configuration document calls the classic PowerShell resource WindowsFeature
from the PSDesiredStateConfiguration module to install a Windows web server (IIS) on Windows
Server.
$schema: https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/2024/04/config/document.json
resources:
- name: Use Windows PowerShell resources
type: Microsoft.Windows/WindowsPowerShell
properties:
resources:
- name: Web server install
type: PSDesiredStateConfiguration/WindowsFeature
properties:
Name: Web-Server
Ensure: Present
To set a machine to the configuration, use the dsc config set
subcommand. The following example
shows how you can send the configuration document to DSCv3 using PowerShell:
dsc config get --file ./web.comfig.dsc.yaml
To learn more, see the dsc config
command reference documentation.
Learn more about Authoring Enhancements in Desired State Configuration v3.0.0.
For more information about DSC v3.0, see the DSCv3 documentation. We value your feedback. Stop by our GitHub repository and let us know of any issues you find.
Jason Helmick
Sr. Product Manager, PowerShell
The post Get started with Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>The post Announcing Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>This is the first post in a multi-part series about the new release of DSC.
We’re pleased to announce the General Availability of Microsoft’s Desired State Configuration (DSC) version 3.0.0.
This version marks a significant evolution in cloud-native configuration management for cross-platform environments. DSC is a declarative configuration and orchestration platform that defines a standard way of exposing settings for applications and services. It’s a tool for managing systems and applications by describing what they should look like rather than how to make it that way. DSC simplifies system, service, and application management by separating what to do from how to do it.
With DSC, you can:
Windows PowerShell 5.1 includes PowerShell Desired State Configuration (PSDSC). We refer to as classic DSC, which encompasses PSDSC v1.1 and v2. However, DSC can use any classic DSC resources that exist today, including the script-based and class-based PSDSC resources. You can use PSDSC resources in DSC with both Windows PowerShell and PowerShell.
The release of DSC is a major change to the DSC platform. DSC differs from PSDSC in a few important ways:
dependsOn
keyword to define the order those groups are applied in a configuration.Microsoft.Dsc/Assertion
(a special group resource) to validate the
environment before running the configuration.The DSC repository has an example that shows how you can use an assertion to manage a
resource that should only run on a specific operating system.Microsoft.DSC/Include
resource.The DSC repository has an example that shows how you can use the Microsoft.Dsc/Include
resource to reuse a separate configuration document file, enabling you to compose a complex
configuration from smaller, simpler configuration documents.dsc resource export
command to get
every instance of that resource on a machine. Use the dsc config export
command to look up
a set of resources and return a new configuration document containing every instance of those
resources.DSC follows semantic versioning. The first release of DSC, version 3.0.0, is a Stable release.
The first release of DSC, version 3.0.0
, is a Stable release. Patch releases update the third
digit of the semantic version number. For example, 3.0.1 is a patch update to 3.0.0. Stable releases
receive patches for critical bugs and security vulnerabilities for three months after the next
Stable release. For example, version 3.0.0 is supported for three months after 3.1.0 is released.
Always update to the latest patch version of the release you’re using.
As I mentioned at the top of this post, this was the first in a series of posts about the new DSC. For the subsequent posts:
Now you are ready for the next post: Get Started with Desired State Configuration v3.0.0 (DSC)
For more information about Desired State Configuration v3.0 (DSC), visit the DSC documentation. We value your feedback. Stop by our GitHub repository and let us know of any issues you find.
Jason Helmick
Sr. Product Manager, PowerShell
The post Announcing Microsoft Desired State Configuration v3.0.0 appeared first on PowerShell Team.
]]>The post Announcing AI Shell Preview 2 appeared first on PowerShell Team.
]]>We’re excited to announce the Preview 2 release of AI Shell! With this update you can expect the following improvements:
AI Shell Preview 3 is released!
Preview 3 has been released just two weeks after Preview 2 due to a backend issue affecting the Azure Agent. This update addresses the problem, ensuring more reliable interactions with Azure services.The improvements to the azure
agent are designed to reduce friction when managing Azure resources
with the Azure CLI and PowerShell. The agent now offers deeper integration with Azure PowerShell,
making it easier to use AI-created Azure PowerShell scripts.
/replace
command now supports Azure PowerShell. The agent walks you through replacement of
parameter values in generated Azure PowerShell responses.Connect-AzAccount
command.
Previously, the agent only supported Azure CLI authentication.With this release, the openai-gpt
agent extends support to third party models that follow the
OpenAI API specifications, allowing for a more flexible AI experience. Many of these models are open
source tools for running SLMs and LLMs locally. The openai-gpt
agent nows supports the following
additional models:
To use these models, you only need to configure the endpoint
, key
and model name
in the agent
config file. The following openai.agents.config
file contains example configurations for two of
the new AI providers.
{
"GPTs": [
{
"Name": "gpt-deepseek",
"Description": "A GPT instance using DeepSeek v3.",
"Endpoint": "https://api.deepseek.com",
"ModelName": "deepseek-chat",
"Key": "<your-deepseek-api-key>",
"SystemPrompt": "You are a helpful assistant."
},
{
"Name": "gpt-gemini",
"Description": "A GPT instance using Google Gemini.",
"Endpoint": "https://generativelanguage.googleapis.com/v1beta/openai/",
"ModelName": "gemini-1.5-flash",
"Key": "<your-gemini-api-key>",
"SystemPrompt": "You are a helpful assistant."
}
]
"Active": "gpt-deepseek"
}
Resolve-Error
(alias fixit
) now uses the screen scraper API on Windows to capture the error
output of native commands. This allows AI Shell to provide better resolution of error messages that
come from native commands rather than from PowerShell.
We refactored the example code for the agent ollama
. This example provides the basic structure
that you can use to build out your own agent. The refactored code now uses the OllamaSharp
library and add the ability to configure the agent using settings files.
The ollama
agent isn’t shipped with AI Shell but you can build it yourself. See the instructions
in the locally build the repo section of the README. Thank you @kborowinski
on GitHub for
this contribution!
We added a Bicep template that deploys an Azure OpenAI instance in seconds. Using the template is much faster than manually creating an instance in the Azure portal. This template includes documentation with step by step instructions.
There are many bug fixes in this release. For a complete list of changes, see the changelog.
Use the following command in PowerShell 7 to install or upgrade AI Shell:
Invoke-Expression "& { $(Invoke-RestMethod 'https://aka.ms/install-aishell.ps1') }"
For more information, see Install AI Shell.
One piece of feedback we often hear is: How can I have AI Shell automatically start up when I open Windows Terminal?
It’s easy! Just add Start-AIShell
to your PowerShell profile script. Here’s how:
if ($PSVersionTable.PSVersion -ge ([version]'7.4.6') -and
(Get-Process -Id $pid).Parent.Name -eq 'WindowsTerminal') {
Start-AIShell
}
Now, AI Shell will automatically start when you open Windows Terminal.
NOTE
AI Shell only works with Windows Terminal and requires PowerShell 7.4.6 or higher.If you need help creating a profile scripts, see about_Profiles.
We would love to hear your feedback as we continue improving AI Shell. Join the discussion in our GitHub Issues and let us know how AI Shell is helping your automation workflows.
Stay tuned for future updates as we bring more AI-powered capabilities to your CLI experience.
Thanks!
Steven Bucher and Dongbo Wang
AI Shell Team
The post Announcing AI Shell Preview 2 appeared first on PowerShell Team.
]]>The post Microsoft Update changes for PowerShell 7 appeared first on PowerShell Team.
]]>It has been a while since we’ve updated folks on the latest behaviors for Microsoft Update! This post gives some background on Microsoft Update, explains our update rules, and announces our plans for updating your installs of PowerShell 7.2.
Microsoft Update (MU) is a service that provides automatic updates for Microsoft products and services. We first started using MU in PowerShell 7.2. MU provides a convenient way to automatically update PowerShell 7, which ensures you can control your update schedule, test it against your environment, and scale across your enterprise with ease.
During MSI installation, two checkboxes control update settings:
We recommend that you select both options to ensure comprehensive update coverage.
If you want to set these options while installing PowerShell from the command line, you can find detailed instructions in the PowerShell documentation.
After we release a new PowerShell version, it can take up to two weeks before the update is available through Microsoft Update. We strive to publish the update no later than 2 weeks after the GitHub release, but there is no guarantee. There may be circumstances that delay the update. If you need the update before it’s available via MU, you can download it directly from the PowerShell Releases page on GitHub.
We defined the rules for updates in an intentional way to ensure that users who are using LTS versions stay on LTS versions. This means that you might not be updated to the latest version of PowerShell 7 when you expected.
These are the rules for updates:
We will never update an LTS version to a stable non-LTS version, like 7.4 to 7.5. However, a stable non-LTS release WILL be upgraded to the higher LTS release when support for the stable release ends. The only time we update an LTS version to a different version would be when an LTS version is out of support. For example, we will update 7.4 to 7.6 (next LTS) once 7.4 goes out of support.
Preview versions will never be updated to the latest stable version. Instead, we will update you to the latest preview release. This means if you are on 7.5-rc.1 you will be updated to 7.6-preview.2 (since preview.1 was skipped) instead of 7.5.
NOTE
Beginning March 14, 2025, we will be updating users who are on 7.2 to 7.4.Hopefully this post helps you understand the MU process. If you want more information about our MU release process, PowerShell releases, or the PowerShell Support Lifecycle, check out the following articles.
As always, we look forward to your feedback. You can provide feedback via GitHub Issues.
Thank you so much!
Steven Bucher
PM on the PowerShell Team
The post Microsoft Update changes for PowerShell 7 appeared first on PowerShell Team.
]]>The post PowerShell 7.5 GA is now available appeared first on PowerShell Team.
]]>Please note that support for PowerShell 7.2 is ended November 8, 2024. PowerShell 7.4 is the current LTS release of PowerShell and is supported until November 2026.
PowerShell 7 is supported on Windows, Linux, and macOS. Consult the documentation for installation instructions and supported platforms.
The PowerShell 7.5 milestone focused on security, quality and community contributions. A few highlights include:
ConvertTo-CliXml
and ConvertFrom-CliXml
(Thanks @ArmaanMcleod!)PSDirectToVariable
, PSNativeWindowsTildeExpansion
, and PSSerializeJSONLongEnumAsNumber
(Thanks @jborean93 and @domsleee!)For more information on what’s changed, see What’s new in PowerShell 7.5.
The following experimental features were converted to mainstream features in PowerShell 7.5:
PSCommandNotFoundSuggestion
PSCommandWithArgs
PSModuleAutoLoadSkipOfflineFiles
PowerShell 7.5 also includes the following experimental features:
PSRedirectToVariable
PSNativeWindowsTildeExpansion
PSSerializeJSONLongEnumAsNumber
For more information, see Using Experimental Features in PowerShell.
We are also releasing previews of PowerShell 7.6, our next long term servicing (LTS) release. We appreciate all the efforts of the community, both individuals and working group members. We look forward to your continued feedback and contributions!
Jason
PowerShell Team
The post PowerShell 7.5 GA is now available appeared first on PowerShell Team.
]]>The post Announcing the Public Preview of AI Shell appeared first on PowerShell Team.
]]>We’re thrilled to unveil the public preview of AI Shell! AI Shell enhances your shell with AI capabilities to facilitate your interactions with the command line. AI Shell create an interactive shell that can interact with various large language model and provides a framework that you can use to build a custom system that meet your needs. Users can interact with the AI agents in a conversational manner.
The AI Shell project includes:
aish
) interfaceEach AI assistant is known as an agent. The initial release of AI Shell includes two agents:
NOTE
The Azure OpenAI agent needs additional configuration to connect to your Azure OpenAI instance. To get started, follow the instructions provided when you start start the agent.Recognizing that you may have different CLI command needs, AI Shell provides a framework for creating your own agents. For more information, see Creating an Agent.
We know every CLI user has their own preferences, so AI Shell offers two flexible modes to fit your workflow:
You can use AI Shell as a self-contained executable, allowing it to run independently from any shell. This setup is perfect if you’re looking for a dedicated, streamlined experience that’s easily accessible without dependencies.
This is the recommended method for using AI Shell because it enables an uninterrupted work flow. The
AIShell module connects the aish
tool to your PowerShell 7 session for deeply integrated user
experience. AI Shell opens in a side pane right next to your PowerShell 7 session that enables a
rich communication between panes, results from the chat can be carried seamlessly to your PowerShell
session for easy execution and the AI agent can be used to provide assistance to resolve a
PowerShell error.
Some system requirements are needed to run AI Shell.
AI Shell (aish
) and the AIShell module are separate downloads. For your convenience, we
created a script to download and install them for you.
Some prerequisites are needed to run AI Shell on Windows.
The following install script will:
aish.exe
to $env:LOCALAPPDATA\Programs\AIShell
and adds it to your PATHSome prerequisites are needed to run AI Shell on MacOS.
On MacOS, this script:
aish
executable to /usr/local/AIShell
and creates a symbolic link at
/usr/local/bin/aish
NOTE
This script only works on Windows and Mac systems. Linux users need to follow the manual installation instructions.To install AI Shell, run the following command in your PowerShell session:
Invoke-Expression "& { $(Invoke-RestMethod 'https://aka.ms/install-aishell.ps1') }"
To find details on manual installation please see, Installing AI Shell manually.
After running the install script, you can run Start-AIShell
to begin using AI Shell.
AI Shell starts in the side by side experience. You can switch between the agents by using the
@<agent name>
command. For example, to switch to the Azure OpenAI agent you would use the
@openai-gpt
command. Additionally you can do @<agent name> <question>
to send a question to the
agent immediately.
Copying and pasting a lot of code can be annoying. AI Shell makes it easy to insert the AI generated
code directly into your PowerShell 7 session with the /code post
command. In your AI Shell, run
/code post
or use the Ctrl+d,Ctrl+d keyboard shortcut
to copy the code into your PowerShell session.
If you are familiar with PowerShell 7 you may be familiar with Predictive Intellisense. When you get multi-step commands in your AI Shell response, you can easily get each subsequent step in your Predictive Intellisense buffer.
If you encounter an error in your working terminal, you can use the Resolve-Error
cmdlet to send
that error to the open AI Shell window for resolution. This command asks the AI model to help you
resolve the error.
One key scenario we wanted to support is being able to pipe output of one command into the AI Shell
to get more information or ask a follow up question on the data given. With the Invoke-AIShell
command you can easily do this.
Invoke-AIShell
can take input from the pipeline but also can just be used to call the AI agent
selected in AI Shell without having to switch back and forth.
There are other chat commands and hot-keys that make using AI Shell easier. For a full list of the chat commands, see the AI Shell reference.
Key bindings | Command | Functionality |
---|---|---|
Ctrl+d, Ctrl+c | /code copy |
Copy all the generated code snippets to clipboard |
Ctrl+<n> | /code copy <n> |
Copy the n-th generated code snippet to clipboard |
Ctrl+d, Ctrl+d | /code post |
Post all the generated code snippets to the connected application |
Ctrl+d,<n> | /code post <n> |
Post the n-th generated code snippet to the connected application |
Additionally, you can switch between the panes easier using the following keyboard shortcuts.
Key bindings | Functionality |
---|---|
Alt+RightArrow | Moves your cursor to the right AI Shell pane |
Alt+LeftArrow | Moves your cursor to the left PowerShell pane |
AI Shell was built for those who seek intelligence and adaptability from their command-line. With multi-agent support, AI Shell aims to be the assistant for any CLI tool. You’ll benefit from advanced AI capabilities, deeper integration with your PowerShell session, and an extensibility model to get the assistance you need.
This public preview is just the beginning. We’d love to hear your feedback and insights as we refine AI Shell to better serve the CLI and PowerShell community. Download it today in PowerShell with
Invoke-Expression "& { $(Invoke-RestMethod 'https://aka.ms/install-aishell.ps1') }"
Be sure to explore the capabilities of the Copilot in Azure and Azure OpenAI agents, and take command-line productivity to the next level! Feel free to give us feedback on the current tool and sign up for early access to future features at aka.ms/AIShell-Feedback.
Thank you so much!
Steven Bucher
Product Manager on the PowerShell/CLI Team
The post Announcing the Public Preview of AI Shell appeared first on PowerShell Team.
]]>