Find Windows OS Version with PowerShell: A Quick Guide

Hey guys! Ever needed to figure out exactly which version of Windows you’re running on a machine using PowerShell? Whether you’re scripting, troubleshooting, or just curious, knowing how to grab that info programmatically is super handy. Let’s dive into a few simple ways to get the Windows OS version using PowerShell. It’s easier than you think, and I’ll walk you through it step by step.

Why Knowing the OS Version Matters

Before we jump into the how-to, let’s quickly chat about why knowing the OS version is important. Imagine you’re rolling out a new application across your company network. Some of your users might be on Windows 10, while others are still rocking Windows 7 or have already upgraded to Windows 11. Your application might behave differently (or not at all!) depending on the OS version. That’s where PowerShell comes to the rescue. By programmatically identifying the OS version, you can tailor your scripts and deployments to ensure everything runs smoothly for everyone. Plus, when you’re troubleshooting issues, knowing the exact OS version helps you narrow down the possible causes and find solutions faster. It’s all about being efficient and effective, right?

Method 1: Using the Get-ComputerInfo Cmdlet

One of the easiest ways to grab the OS version is by using the Get-ComputerInfo cmdlet. This cmdlet provides a wealth of information about your system, including (you guessed it) the OS version. Here’s how you can use it:

Get-ComputerInfo | Select-Object OsName, OsVersion, WindowsVersion

When you run this command, you’ll get an output that includes the OS name, the version number, and the Windows version. The Select-Object part of the command is just there to filter out the specific properties we’re interested in. If you want to see all the info that Get-ComputerInfo provides, just leave out the Select-Object part. The OsName property gives you a human-readable name for the operating system, like “Microsoft Windows 10 Pro.” The OsVersion property provides the version number, such as “10.0.19042.” Lastly, the WindowsVersion property provides the version of the Windows operating system.

This method is super straightforward and gives you a clear, easy-to-read output. Plus, Get-ComputerInfo provides a ton of other useful system information, so it’s a great cmdlet to have in your PowerShell toolkit. Use it wisely!

Method 2: Accessing the Win32_OperatingSystem WMI Class

Another way to get the OS version is by using the Win32_OperatingSystem WMI (Windows Management Instrumentation) class. WMI is a powerful way to access all sorts of system information, and PowerShell makes it easy to query WMI classes. Here’s the command you’ll need:

Get-WmiObject -Class Win32_OperatingSystem | Select-Object Caption, Version, BuildNumber

In this command, Get-WmiObject is used to retrieve instances of the Win32_OperatingSystem class. We then use Select-Object to filter the output to show only the Caption , Version , and BuildNumber properties. The Caption property gives you the OS name, the Version property gives you the version number, and the BuildNumber property gives you the build number. For example, the Caption might be “Microsoft Windows 10 Pro,” the Version might be “10.0.19042,” and the BuildNumber might be “19042.” This method is especially useful when you need more detailed information about the OS, such as the build number, which can be helpful for identifying specific updates or patches. WMI is a treasure trove of system information, so it’s worth exploring what else you can find there!

Method 3: Using the $PSVersionTable Variable

For a more PowerShell-centric approach, you can use the $PSVersionTable automatic variable. This variable contains information about the PowerShell environment itself, including the OS version. Here’s how:

$PSVersionTable.OSVersion

This command directly accesses the OSVersion property of the $PSVersionTable variable. The output will be the OS version, like “6.2.9200.0.” This method is quick and easy, but it only gives you the raw version number. It doesn’t provide the OS name or other details. However, if you just need the version number for comparison or scripting purposes, this is a super-fast way to get it. The $PSVersionTable variable is a great resource for all sorts of PowerShell environment information, so poke around and see what else you can find!

Method 4: Using the [System.Environment]::OSVersion Property

Another method to retrieve the OS version in PowerShell involves using the .NET framework directly. You can access the OSVersion property of the System.Environment class to get detailed information about the operating system. This approach is particularly useful when you need specific details about the OS version, service pack, or platform. Here’s how you can do it:

[System.Environment]::OSVersion

When you run this command, you’ll get an output that includes information about the operating system, version, platform, and service pack. The output will be similar to this:

OperatingSystem : Microsoft Windows NT 10.0.19042.0
Version         : 10.0.19042.0
Platform        : Win32NT
ServicePack     :
VersionString   : Microsoft Windows NT 10.0.19042.0

Here’s a breakdown of the properties:

• OperatingSystem : Provides the name and version of the operating system.
• Version : The version number of the operating system.
• Platform : Indicates the platform the OS is running on (e.g., Win32NT).
• ServicePack : Shows any service packs installed on the OS.
• VersionString : A string representation of the OS version.

This method is beneficial because it gives you a comprehensive overview of the OS version, including details that might not be readily available through other methods. It’s especially useful in more complex scripting scenarios where you need to make decisions based on specific OS characteristics. For instance, you might use this information to determine whether a particular service pack is installed before applying an update, or to verify that the script is running on the correct platform. Using .NET classes directly in PowerShell scripts provides a powerful way to access detailed system information and perform advanced tasks.

Method 5: Checking the Registry

Alright, let’s dive into another cool method: peeking into the Windows Registry. This is like going straight to the source for system info. The Registry holds tons of configuration settings, and we can find the OS version in there too. Here’s the command you need:

Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' | Select-Object ProductName, ReleaseId, CurrentBuild, UBR

When you run this command, PowerShell digs into the Registry and pulls out some key details about your OS. Let’s break down what each part does:

• Get-ItemProperty : This cmdlet is your tool for reading values from the Registry. We’re telling it to go to a specific path.
• -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion' : This is the exact location in the Registry where the OS version info is stored. It’s like giving PowerShell the precise coordinates to find the treasure.
• Select-Object ProductName, ReleaseId, CurrentBuild, UBR : This part filters the output to show only the properties we care about. ProductName gives you the name of the OS, ReleaseId tells you the version, CurrentBuild is the build number, and UBR is the Update Build Revision.

Here’s what the output might look like:

ProductName : Windows 10 Pro
ReleaseId   : 2009
CurrentBuild : 19042
UBR         : 1237

• ProductName : This tells you the edition of Windows you’re running, like “Windows 10 Pro” or “Windows 11 Home.”
• ReleaseId : This is the marketing name for the Windows version, like “2009” for the October 2020 release of Windows 10.
• CurrentBuild : This is the internal build number of the OS. It’s a more precise identifier than the ReleaseId .
• UBR : The Update Build Revision number. This tells you the specific cumulative update that’s installed on the system.

Why is this method useful? Well, sometimes you need to get really specific about the OS version. The Registry gives you that level of detail. Plus, it’s a reliable way to get the info, even if other methods are being finicky. Just remember, when you’re messing with the Registry, be careful! Changing the wrong thing can cause problems. But reading values is generally safe, so go ahead and give it a try.

Wrapping Up

So there you have it – several ways to get the Windows OS version using PowerShell. Whether you prefer the simplicity of Get-ComputerInfo , the power of WMI, the directness of $PSVersionTable , leveraging .NET or diving into the Registry, PowerShell has you covered. Each method has its strengths, so choose the one that best fits your needs. Happy scripting!