How to find the Windows version from the PowerShell command line

Question

How do I find which Windows version I'm using?

I'm using PowerShell 2.0 and tried:

PS C:\> ver
The term 'ver' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify tha
t the path is correct and try again.
At line:1 char:4
+ ver <<<< 
    + CategoryInfo          : ObjectNotFound: (ver:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException

How do I do this?

Cronus

If you're viewing this in 2019+, ignore the answer that's marked as correct and go straight to the one that is correct. You're welcome. – Unstable

If you're viewing this in 2023+, (gin).OSDisplayVersion works for Win11 & reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v DisplayVersion works for Win10 22H2, which is last version of Win10. – Litman

This function might help someone out. – Salliesallow

Answer 1

Since you have access to the .NET library, you could access the OSVersion property of the System.Environment class to get this information. For the version number, there is the Version property.

For example,

PS C:\> [System.Environment]::OSVersion.Version

Major  Minor  Build  Revision
-----  -----  -----  --------
6      1      7601   65536

Details of Windows versions can be found here.

Fond

Note that [Environment]::OSVersion works in windows-10, OSVersion.Version.Major returns 10. – Seismic

When I run winver it shows me version 1607. But the powershell command above does not give 1607. Where do I get this "1607" number in Powershell? – Limburger

@Limburger (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId – Settle

This method was deprecated as of Windows 8.1. See this link for details. – Jacobina

Interestingly if you use Start-Transcript one of the values it includes in the opening of the output transcript is the "Build Version" which is the OS version. – Heuristic

(Get-CimInstance Win32_OperatingSystem).version is best currently as it'll work in Windows 8.1 see: devblogs.microsoft.com/scripting/… – Chiu

Why isn't the answer just winver? That command seems simpler. – Viperish

@SlogmeisterExtraordinaire The command [System.Environment]::OSVersion wasn't deprecated, the method which it uses in the background has been deprecated. New PS versions are changing the backend behavior: github.com/PowerShell/PowerShell/issues/… – Dybbuk

@Viperish winver will have an external popup that really can't be used working with execution of PowerShell scripts since you can't grab data from it. It is easier, but dosn't suit this question. – Wellhead

Answer 2

1. To get the Windows version number, as Jeff notes in his answer, use:

   [Environment]::OSVersion
   

   It is worth noting that the result is of type [System.Version], so it is possible to check for, say, Windows 7/Windows Server 2008 R2 and later with

   [Environment]::OSVersion.Version -ge (new-object 'Version' 6,1)
   

   However this will not tell you if it is client or server Windows, nor the name of the version.

2. Use WMI's Win32_OperatingSystem class (always single instance), for example:

   (Get-WmiObject -class Win32_OperatingSystem).Caption
   

   will return something like

   Microsoft® Windows Server® 2008 Standard

Boatman

Caveat for Get-WmiObject: some times takes several seconds to return – Feces

[Environment]::OSVersion is unreliable devblogs.microsoft.com/scripting/… – Kept

Great answer using .Caption...finally a way to get something human readable without going to a stupid table to figure it out! – Pig

Answer 3

Unfortunately most of the other answers do not provide information specific to Windows 10.

Windows 10 has versions of its own: 1507, 1511, 1607, 1703, etc. This is what winver shows.

Powershell:
(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId

Command prompt (CMD.EXE):
Reg Query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion" /v ReleaseId

See also related question on superuser.

As for other Windows versions use systeminfo. Powershell wrapper:

PS C:\> systeminfo /fo csv | ConvertFrom-Csv | select OS*, System*, Hotfix* | Format-List


OS Name             : Microsoft Windows 7 Enterprise
OS Version          : 6.1.7601 Service Pack 1 Build 7601
OS Manufacturer     : Microsoft Corporation
OS Configuration    : Standalone Workstation
OS Build Type       : Multiprocessor Free
System Type         : x64-based PC
System Locale       : ru;Russian
Hotfix(s)           : 274 Hotfix(s) Installed.,[01]: KB2849697,[02]: KB2849697,[03]:...

Windows 10 output for the same command:

OS Name             : Microsoft Windows 10 Enterprise N 2016 LTSB
OS Version          : 10.0.14393 N/A Build 14393
OS Manufacturer     : Microsoft Corporation
OS Configuration    : Standalone Workstation
OS Build Type       : Multiprocessor Free
System Type         : x64-based PC
System Directory    : C:\Windows\system32
System Locale       : en-us;English (United States)
Hotfix(s)           : N/A

Settle

This is easy to remember winver on desktop and systeminfo on server. It has baffled me for years that there is no uniform way of getting this info. – Guarantor

Great links to MS info that is actually useful. It should be noted that for Win8.1 (and below?) the info shown is: OS Version : 6.3.9600 N/A Build 9600. So in versions below W81, it may be more informative to look at the (always overlooked) LTSB versions. See output from: (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx which may look like: 9600.19179.amd64fre.winblue_ltsb_escrow.181015-1847. My guess is that the 181015 part is the build date, whereas the 1847 is build or release version. You may also need to compare this to kernel, hal. – Stridor

Should be the accepted answer in 2020. Hey SO Team, can we change the accepted answer over the years? Would this be a meta issue? – Fungoid

releaseid no longer works for 21h1, instead displayversion is now used. which doesn't exist for older versions – Kept

I'm on Windows 11 and thought the BuildLabEx from the Registry above would be it, but it in fact still reports a year-old (RTM?) build 22000.1 + lab string rather than my current build 22000.675 according to winver. Nothing in the CurrentVersion key reports my current build number as part of a full string. Only the value UBR will report the integer 675 which is correct, but then not in the form of a full build string. – Traveler

Answer 4

Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

returns

WindowsProductName    WindowsVersion OsHardwareAbstractionLayer
------------------    -------------- --------------------------
Windows 10 Enterprise 1709           10.0.16299.371 

Boltrope

@Stridor Really? About 1 sec on my Surface Book 2. – Trusty

Get-ComputerInfo | select WindowsVersion no longer works for 21h1 - it shows 2009 (same as 20h2) – Kept

That is annoying... Microsoft are so... consistent. Not. – Boltrope

Answer 5

This will give you the full version of Windows (including Revision/Build number) unlike all the solutions above:

(Get-ItemProperty -Path c:\windows\system32\hal.dll).VersionInfo.FileVersion

Result:

10.0.10240.16392 (th1_st1.150716-1608)

Orenorenburg

This is the best solution as far as I'm concerned as it is reporting the revision number correctly. None of the others are (at least as I have tested them). – Maggoty

This is the only solution so far that has allowed me to get the full build number. However, not all the files in system32 are updated with each update - for example, my hal.dll still shows 10.0.10586.0 (th2_release.151029-1700), while winload.exe has 10.0.10586.63 (th2_release.160104-1513). – Merl

Here's a little script that obtains the version from the dll/exe with the highest build date: gist – Merl

Would be interesting to exemplify how to use this for remote situations. – Inkling

This relies on an implementation detail on Microsoft's side which there is no guarantee they will continue to do. It works now but you should avoid relying on this if you want your script to work in the long run. – Karynkaryo

Yeah, this no longer works -- as of 1803, this shows something like: 10.0.17134.1 (WinBuild.160101.0800) – Aiden

@Stridor It's just not the right information. First, if you want to know the windows version, then the output needs to include it. If WinVer shows "Version 1803" where is 1803 in this output? Additionally, the build number is out of date -- because as melak47 pointed out, you can't count on hal.dll being updated in every build. My WinVer today shows OS Build 17134.407, while hal.dll is 17134.285 – Aiden

@Aiden Well, I don't agree, for 2 reasons. (1) because those "1803"-like numbers are not always available (e.g. on Win8), so what should be used there? (2) There is no technical reason why there should be just one correct version. The OS is built (and updated) by parts, i.e. the Kernel, the HAL, the UBR, and the features etc. So then we should really display all of them. In that respect I think BuildLabEx, Kernel and HAL (in that order) would be the most appropriate way to give a more proper version. But since you seem to know what is wrong, you should post what is right. – Stridor

So far and in my testing this worked for me. From windows 2016 (included) and back, the BuildREV number is on registry, and NOT showed in most commands (inluding winver for 2012r2 and older, or in any in "ver" or "cmd /?") and I needed this buildrev to quickly check if the OS is at the lastest update. From W10/2019 and up, the "ver" command includes the BuildREV. So far I did a batch code to detect first the family of OS and then go for the registry or the ver command output. But getting the version from this DLL worked in all of them – Correggio

Answer 6

Since PowerShell 5:

Get-ComputerInfo
Get-ComputerInfo -Property Windows*

I think this command pretty much tries the 1001 different ways so far discovered to collect system information...

Coburg

Part of the response I got from this is strange... I'm on Windows 10 1909, but "WindowsCurrentVersion" is 6.3. I would think that would be 10, as 6.3 is Windows 8.1. Otherwise, I like the information provided by this command – Dybbuk

Get-ComputerInfo -Property Os* gets the uptodate info. Look at the whole list from Get-ComputerInfo, and it looks like most of what you'd get from CIM/WMI. – Rosebay

Answer 7

If you want to differentiate between Windows 8.1 (6.3.9600) and Windows 8 (6.2.9200) use

(Get-CimInstance Win32_OperatingSystem).Version 

to get the proper version. [Environment]::OSVersion doesn't work properly in Windows 8.1 (it returns a Windows 8 version).

Balm

Note that [Environment]::OSVersion works in windows-10, OSVersion.Version.Major returns 10. – Seismic

Both (Get-CimInstance Win32_OperatingSystem).Version and [Environment]::OSVersion works for me and return the same result: 6.3.9600.0 – Topdress

unfortunately 6.3.9600 isn't just Win 8.1, server 2012 R2 also returns this same build number. – Reciprocation

Answer 8

I am refining one of the answers

I reached this question while trying to match the output from winver.exe:

Version 1607 (OS Build 14393.351)

I was able to extract the build string with:

,((Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx -split '\.') | % {  $_[0..1] -join '.' }  

Result: 14393.351

Updated: Here is a slightly simplified script using regex

(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx -match '^[0-9]+\.[0-9]+' |  % { $matches.Values }

Polyploid

Just a comment, this wont work in 2019+ OS, to get the full build (including REV) since is not longer stored in the registry. (saddly) – Correggio

Answer 9

If you are trying to decipher info MS puts on their patching site such as https://technet.microsoft.com/en-us/library/security/ms17-010.aspx

you will need a combo such as:

$name=(Get-WmiObject Win32_OperatingSystem).caption $bit=(Get-WmiObject Win32_OperatingSystem).OSArchitecture $ver=(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId Write-Host $name, $bit, $ver

Microsoft Windows 10 Home 64-bit 1703

Conception

Answer 10

To produce identical output to winver.exe in PowerShell v5 on Windows 10 1809:

$Version = Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\'
"Version $($Version.ReleaseId) (OS Build $($Version.CurrentBuildNumber).$($Version.UBR))"

Saros

Also it matches the version in "Settings > System > About" in Windows 10. And gets Update Build Revision right, which many of the solutions don't on my machine 👍 – Apian

This stopped working for me. WinVer.exe shows Version 20H2 (OS Build 19042.804) but this gives Version 2009 (OS Build 19042.804). Changing ReleaseId to DisplayVersion fixes it, but older OS's don't have DisplayVersion. – Apian

releaseid no longer works for 21h1, instead displayversion is now used. which doesn't exist for older versions – Kept

Answer 11

I took the scripts above and tweaked them a little to come up with this:

$name=(Get-WmiObject Win32_OperatingSystem).caption
$bit=(Get-WmiObject Win32_OperatingSystem).OSArchitecture

$vert = " Version:"
$ver=(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId

$buildt = " Build:"
$build= (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").BuildLabEx -match '^[0-9]+\.[0-9]+' |  % { $matches.Values }

$installd = Get-ComputerInfo -Property WindowsInstallDateFromRegistry

Write-host $installd
Write-Host $name, $bit, $vert, $ver, `enter code here`$buildt, $build, $installd

---

To get a result like this:

Microsoft Windows 10 Home 64-bit Version: 1709 Build: 16299.431 @{WindowsInstallDateFromRegistry=18-01-01 2:29:11 AM}

Hint: I'd appreciate a hand stripping the prefix text from the install date so I can replace it with a more readable header.

Tamtama

The install date command takes a while to run, so I found a faster one: [timezone]::CurrentTimeZone.ToLocalTime(([datetime]'1/1/1970')).AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) It's a little more complex, but it runs a lot quicker. You might even be able to leave out the timezone part: ([datetime]'1/1/1970').AddSeconds($(get-itemproperty "HKLM:\Software\Microsoft\Windows NT\CurrentVersion").InstallDate) – Dybbuk

Answer 12

In addition to other answers, here are some useful information that can be retrieved using PowerShell:

Querying OS & Hardware Info via PowerShell:

Querying General OS (Operating System) Information:

Quickest way to view the OS name:

cmd ?

#Using Get-ComputerInfo:

Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

#Using Get-WmiObject:

$name=(Get-WmiObject Win32_OperatingSystem).caption
$bit=(Get-WmiObject Win32_OperatingSystem).OSArchitecture
$ver=(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId
Write-Host " OS-Name: `t $name `n Architct: `t $bit  `n Release: `t $ver" 

To list Major Minor Version info:

[System.Environment]::OSVersion.Version 

Querying HostName:

$Env:ComputerName

OR

hostname    #cmd command

Also, if you know the IP address, use the "ping" command (e.g.: ping /a <your_ip_address>) you will see your "hostname" in first line.

Querying Current (Logged-in) User:

whoami    #cmd command

OR

[System.Security.Principal.WindowsIdentity]::GetCurrent().Name 

Querying Mapped Drives: List Mapped Drives - using WMI:

Get-WmiObject -Class Win32_LogicalDisk | Format-Table 

OR

wmic logicaldisk get name       #list just logical-drive letters

OR, to list logical-drive info: FreeSpace, Provider (Real Network Location), Size, and VolumeName:

wmic logicaldisk list brief

List Mapped Drives - using [DriveInfo] class:

[System.IO.DriveInfo]::GetDrives()

List Removable Drives:

$drives = [System.IO.DriveInfo]::GetDrives()
$r = $drives | Where-Object { $_.DriveType -eq 'Removable' -and $_.IsReady }
if ($r) {
    return @($r)[-1]
}

Querying disk capacity, space & Volume-Type

Invoke-Command -ComputerName S1 {Get-PSDrive C} | Select-Object PSComputerName,Used,Free 

Free Space:

(Get-PSDrive C).Free

OR (in GB)

[Math]::Floor(((Get-PSDrive C).Free /[Math]::Pow(2, 30)*10)) /10

Used Space:

(Get-PSDrive C).Used

OR (Used space in GB's)

[Math]::Floor(((Get-PSDrive C).Used /[Math]::Pow(2, 30)*10)) /10

Additionally to view total Space: (in GB)

$totalSpace = ((Get-PSDrive C).Used + (Get-PSDrive C).Free)/(1024*1024*1024)
OR
$totalSpace = ((Get-PSDrive C).Used + (Get-PSDrive C).Free)/[Math]::Pow(2, 30)

Rounded off values:

[Math]::Floor($totalSpace*10) / 10
OR
[Math]::Round($totalSpace,1)

Querying Motherboard info:

wmic baseboard get product,Manufacturer,version,serialnumber

Querying Disk Volume (Of Disk Partitions) Info: Get-Volume returns information about storage drive's partitions, e.g.:

Get-Volume                 # All partitions
Get-Volume -DriveLetter C  # Specific partition

#file system type:

Get-Volume -DriveLetter C | select FileSystem
(Get-Volume -DriveLetter C).FileSystem

#partition size:

Get-Volume -DriveLetter C | select Size
OR (in GB)
[Math]::Floor(((Get-Volume -DriveLetter C).Size/[Math]::Pow(2, 30)*10)) /10

Querying Memory / Query RAM

Get-WmiObject Win32_PhysicalMemory | Measure-Object -Property Capacity -Sum
OR (in GB)
$memory = (Get-WmiObject Win32_PhysicalMemory | Measure -Property Capacity -Sum).Sum
$memory = [Math]::Floor(($memory/[Math]::Pow(2, 30)*10)) /10
$memory.ToString() + " gb"

#Query RAM including Frequency / Speed:

Get-CimInstance win32_physicalmemory | Format-Table Manufacturer,Banklabel,Configuredclockspeed,Devicelocator,Capacity,Serialnumber –autosize

---

As mentioned, this answer goes bit beyond the question asked, but could be useful for those who'd like additional OS or Hardware information using PowerShell.

Malvinamalvino

[System.Environment]::OSVersion.Version is my favorite, works on pwsh installed with brew on mac Monterey. – Fungoid

Thanks @Timo, I will add that to my answer just for reference (not that it's a comprehensive list of options but your input is valuable so thanks). – Malvinamalvino

Answer 13

Use:

Get-WmiObject -class win32_operatingsystem -computer computername | Select-Object Caption

Virgel

Can also get the version number using this: Get-WmiObject -class win32_operatingsystem | select Version – Portis

You could improve this answer by showing the output. – Dorset

Answer 14

As MoonStom says, [Environment]::OSVersion doesn't work properly on an upgraded Windows 8.1 (it returns a Windows 8 version): link.

If you want to differentiate between Windows 8.1 (6.3.9600) and Windows 8 (6.2.9200), you can use (Get-CimInstance Win32_OperatingSystem).Version to get the proper version. However this doesn't work in PowerShell 2. So use this:

$version = $null
try {
    $version = (Get-CimInstance Win32_OperatingSystem).Version
}
catch {
    $version = [System.Environment]::OSVersion.Version | % {"{0}.{1}.{2}" -f $_.Major,$_.Minor,$_.Build}
}

Gecko

Answer 15

Should be easy like this :

Get-ComputerInfo  | select windowsversion

Viscoid

Get-ComputerInfo | select WindowsVersion no longer works for 21h1 - it shows 2009 (same as 20h2) – Kept

I neet to add , use Powershell to execute this command, Thanks – Cybill

Answer 16

This is really a long thread, and probably because the answers albeit correct are not resolving the fundamental question. I came across this site: Version & Build Numbers that provided a clear overview of what is what in the Microsoft Windows world.

Since my interest is to know which exact windows OS I am dealing with, I left aside the entire version rainbow and instead focused on the BuildNumber. The build number may be attained either by:

([Environment]::OSVersion.Version).Build

or by:

(Get-CimInstance Win32_OperatingSystem).buildNumber

the choice is yours which ever way you prefer it. So from there I could do something along the lines of:

    switch ((Get-CimInstance Win32_OperatingSystem).BuildNumber) 
{
    6001 {$OS = "W2K8"}
    7600 {$OS = "W2K8R2"}
    7601 {$OS = "W2K8R2SP1"}    
    9200 {$OS = "W2K12"}
    9600 {$OS = "W2K12R2"}
    14393 {$OS = "W2K16v1607"}
    16229 {$OS = "W2K16v1709"}
    default { $OS = "Not Listed"}

}
Write-Host "Server system: $OS" -foregroundcolor Green

Note: As you can see I used the above just for server systems, however it could easily be applied to workstations or even cleverly extended to support both... but I'll leave that to you.

Enjoy, & have fun!

Jugal

I'd be glad to adapt it to workstations but how can PS detect if its running on a Windows Server or a simple Windows PC ? – Buddhi

The Windows Client OS versions have different build values, check this Microsoft link out: learn.microsoft.com/en-us/windows/win32/sysinfo/…. In addition you'll need to check the product Type: (Get-CimInstance Win32_OperatingSystem).productType, if it equals 1 then it's a client – Jugal

The link you gave doesn't give the build values but ""+[Environment]::OSVersion.Version.Major+"."+[Environment]::OSVersion.Version.Minor Do you have a link containing the official Microsoft build table ? – Buddhi

@Buddhi See Windows 10 release information, has build table for each released version along with build numbers for each version, at the bottom of the webpage. And here is Windows 11 release information. – Salvadorsalvadore

Answer 17

You guys are trying too hard. This works with your local or remote sessions using Enter-PSSession - give it a shot.

All you have to do is type:

cmd ?

Microsoft Windows [Version 10.0.19042.1237]

Eastwardly

This doesn't just show the version number - it starts an entirely new shell instance too, and that instance is not even Powershell! So mind that if you intend to use that interactively or in a script, and not just as a winver replacement. – Traveler

Answer 18

Windows PowerShell 2.0:

$windows = New-Object -Type PSObject |
           Add-Member -MemberType NoteProperty -Name Caption -Value (Get-WmiObject -Class Win32_OperatingSystem).Caption -PassThru |
           Add-Member -MemberType NoteProperty -Name Version -Value [Environment]::OSVersion.Version                     -PassThru

Windows PowerShell 3.0:

$windows = [PSCustomObject]@{
    Caption = (Get-WmiObject -Class Win32_OperatingSystem).Caption
    Version = [Environment]::OSVersion.Version
}

For display (both versions):

"{0}  ({1})" -f $windows.Caption, $windows.Version 

Urbane

Answer 19

The more offical way, today, is using this:

Get-ComputerInfo | select WindowsProductName, OsOperatingSystemSKU, OsName | fl

# <output>
# WindowsProductName   : Windows 10 Home
# OsOperatingSystemSKU : WindowsHome
# OsName               : Microsoft Windows 10 Home

If you want other items, look in the list from:

(Get-CimInstance Win32_OperatingSystem) | select *

# ...
# and: 
(Get-CimInstance Win32_OperatingSystem).Caption

# Microsoft Windows 10 Home

Stridor

Answer 20

Here's my version based on the registry. I used to check the ubr to see if a certain monthly update was installed.

#patchtest.ps1

$reg = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
$releaseid = $reg.releaseid
$ubr = $reg.ubr
$displayversion = $reg.displayversion
$currentbuild = $reg.currentBuild

[pscustomobject]@{result = 
  switch ($releaseid) {
    '1607' { $ubr -ge '4651' } # kb5005573
    '1709' { $false } 
    '1809' { $false }
    '1903' { $false } 
    '1909' { $ubr -ge '1801' } # KB5005566
    '2004' { $ubr -ge '1288' } # kb5006670
    '2009' { $ubr -ge '1288' } # kb5006670
    default { $false }
  }
  releaseid = $releaseid
  displayversion = $displayversion
  ubr = $ubr
  currentBuild = $currentBuild
}

icm comp001 .\patchtest.ps1 | ft


result releaseid displayversion  ubr currentBuild PSComputerName RunspaceId
------ --------- --------------  --- ------------ -------------- ----------
  True 2009      21H2           3086 19044        comp001        e86b1b65-f939-...

Sherrisherrie

Answer 21

(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx

Fabiola

Shows the RTM version of Windows 11 despite having applied servicing updates. So it'll probably always differ from the actual version on Windows 11 at least. – Traveler

Answer 22

I searched a lot to find out the exact version, because WSUS server shows the wrong version. The best is to get revision from UBR registry KEY.

    $WinVer = New-Object –TypeName PSObject
$WinVer | Add-Member –MemberType NoteProperty –Name Major –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentMajorVersionNumber).CurrentMajorVersionNumber
$WinVer | Add-Member –MemberType NoteProperty –Name Minor –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentMinorVersionNumber).CurrentMinorVersionNumber
$WinVer | Add-Member –MemberType NoteProperty –Name Build –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' CurrentBuild).CurrentBuild
$WinVer | Add-Member –MemberType NoteProperty –Name Revision –Value $(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion' UBR).UBR
$WinVer

Panslavism

Answer 23

(Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Update\TargetingInfo\Installed\Client.OS.rs2.amd64').version

Based off of Tim's earlier answer, the nice thing about this particular location is that the property is already in what I would call a preferred format.

Selectee

Answer 24

A Powershell equivalent of winver

Works for all versions of Windows 10 until 20h2, is fast and not too complex*

function Get-WinVer() {
    $win_release = (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").displayversion
    if (!($win_release)) {
        $win_release = (Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion").ReleaseId}
    $win_release
}
Get-WinVer

It shows exactly what winver.exe shows next to "Version".

I didn't expect to have to read so much to come up with this code and I really hope I will not have to tweak it for 22h1 (or what ever the name is at that time).

---

*: Microsoft certainly made it more complex than it should

Feces

Answer 25

I don't really like MS changing how they store the version number :/

But at least all information is available in Get-ComputerInfo (although somewhat slow to get at).

Get-ComputerInfo | select OSName, 
  @{
    l = 'BuildNumber'
    e = {$_.WindowsBuildLabEx.Split('.')[0]}
  },
  @{
    l = 'Version'
    e = {
      if ($_.OSDisplayVersion) {$_.OSDisplayVersion} # Win 11
      else {$_.WindowsVersion} # Win 10
    } 
  }

Udometer

Answer 26

This will give you the full and CORRECT (the same version number that you find when you run winver.exe) version of Windows (including revision/build number) REMOTELY unlike all the other solutions (tested on Windows 10):

Function Get-OSVersion {
Param($ComputerName)
    Invoke-Command -ComputerName $ComputerName -ScriptBlock {
        $all = @()
        (Get-Childitem c:\windows\system32) | ? Length | Foreach {

            $all += (Get-ItemProperty -Path $_.FullName).VersionInfo.Productversion
        }
        $version = [System.Environment]::OSVersion.Version
        $osversion = "$($version.major).0.$($version.build)"
        $minor = @()
        $all | ? {$_ -like "$osversion*"} | Foreach {
            $minor += [int]($_ -replace".*\.")
        }
        $minor = $minor | sort | Select -Last 1

        return "$osversion.$minor"
    }
}

Excretory

I got error running this with 'localhost' and using the actual computer name (as returned by 'hostname') on my localhost - is is possible to tweak this solution to allow it get the information from a local machine without to enable services etc ? – Began

[xxxxxx] Connecting to remote server xxxxxx failed with the following error message : The client cannot connect to the destination specified in the request. Verify that the service on the destination is running and is accepting requests. Consult the logs and documentation for the WS-Management service running on the destination, most commonly IIS or WinRM. If the destination is the WinRM service, run the following command on the destination to analyze and configure the WinRM service: "winrm quickconfig". For more information,[...] – Began

Worked for me. Upvoted. That would be a perfect script if it would include windows 10 release id - 1507, 1511, 1607 etc. – Settle

Answer 27

Using Windows Powershell, it possible to get the data you need in the following way

Caption:

(Get-WmiObject -class Win32_OperatingSystem).Caption

ReleaseId:

(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name ReleaseId).ReleaseId

version:

(Get-CimInstance Win32_OperatingSystem).version

Jedediah

releaseid no longer works for 21h1, instead displayversion is now used. which doesn't exist for older versions – Kept

Answer 28

[solved]

#copy all the code below:
#save file as .ps1 run and see the magic

 Get-WmiObject -Class Win32_OperatingSystem | ForEach-Object -MemberName Caption
 (Get-CimInstance Win32_OperatingSystem).version


#-------------comment-------------#
#-----finding windows version-----#

$version= (Get-CimInstance Win32_OperatingSystem).version
$length= $version.Length
$index= $version.IndexOf(".")
[int]$windows= $version.Remove($index,$length-2)  
$windows
#-----------end------------------#
#-----------comment-----------------#

Screwy

Welcome to SO! When you reply a question, please try to explain a little bit. In this case, there are 20 more replies so consider to expose the Pros of yours. – Inception

Answer 29

You could also use something like this, by checking the OSVersion.Version.Major:

IF ([System.Environment]::OSVersion.Version.Major -ge 10) {Write-Host "Windows 10 or above"}
IF ([System.Environment]::OSVersion.Version.Major -lt 10) {Write-Host "Windows 8.1 or below"}

Portis

Answer 30

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Update\TargetingInfo\Installed\Client.OS.rs2.amd64\Version 'For Win 10 Client'

HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Update\TargetingInfo\Installed\Server.OS.amd64\Version 'For Server OS'

Stets

Hi Tim, can you explain how this help with finding the answer for the question? I happen to now these are Windows registry addresses, but not everyone will. Also, the question was asked how to do this in PowerShell. Can you add code in PowerShell that shows how to do this? – Granoff

Answer 31

I wanted to just complete a small script. We used the switch version that was answered before and just elaborated on it. There is no place that will give you the friendly name we are used to. Windows 10 1909 or windows 10 20H2. So we have to program them manually.

$osversion = (Get-CimInstance -class Win32_OperatingSystem).Caption
$buildnumber = (Get-CimInstance Win32_OperatingSystem).BuildNumber
if($osversion -match "Windows 10")
{   
    switch ($buildnumber) 
    { 
        10240 {$OS = "Windows 10 1507"}
        10586 {$OS = "Windows 10 1511"}
        14393 {$OS = "Windows 10 1607"}
        15063 {$OS = "Windows 10 1703"}
        16299 {$OS = "Windows 10 1709"}
        17134 {$OS = "Windows 10 1803"}
        17763 {$OS = "Windows 10 1809"}
        18362 {$OS = "Windows 10 1903"}
        18363 {$OS = "Windows 10 1909"}
        19041 {$OS = "Windows 10 20H1"}
        19042 {$OS = "Windows 10 20H2"}
        19043 {$OS = "Windows 10 21H1"}
        default { $OS = "Not Listed"}
    }
}
if($osversion -match "Windows Server")
{
    switch ($buildnumber) 
    {
        3790 {$OS = "Windows Server 2003 R2"}
        6001 {$OS = "Windows Server 2008"}
        7600 {$OS = "Windows Server 2008 SP1"}
        7601 {$OS = "Windows Server 2008 R2"}    
        9200 {$OS = "Windows Server 2012"}
        9600 {$OS = "Windows Server 2012 R2"}
        14393 {$OS = "Windows Server 2016"}
        17763 {$OS = "Windows Server 2019"}
    }
}
Write-Host "Server system: $OS | $osversion | $buildnumber" -foregroundcolor Green

Now if you want to scan multiple pc's at once like I wanted to use invoke-command or new-pssession Please note Get-WMIObject is depreciated and replaced with get-ciminstance

If you would like an example I can provide later If your using windows 2003 R2 Or earlier.. Stop Move to a new OS.

Dropsonde

Answer 32

The answers above were helpful in determining the correct way to grab the full Windows version, Including the last set of numbers that corresponds to the currently installed patch.

$Build = ((Get-CimInstance Win32_OperatingSystem).Version)
$Patch = ((Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\').UBR)
$Version = ($Build+"."+$Patch)

Results in Variable of $Version, which if you do a Write-Host on it, will reveal the full OS version (similar to the versions reported by Intune or SCCM)

This is the most effective way to get what is needed in this scenario. The other answers are great, but they are only grabbing a portion of the build number. I had an instance where I needed to create a script to grab the full build number to determine what patch each machine had installed. This was the best way to do so.

Kilometer

Answer 33

Using winver.exe simply queries the registry keys located here: HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\. We can grab the necessary keys to format a string to include the Major version, Minor version, Current build number, and revision number.

$keys = "CurrentMajorVersionNumber", "CurrentMinorVersionNumber", "CurrentBuildNumber", "UBR"; ($keys | ForEach-Object { (Get-ItemProperty -path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\").$_ }) -join '.'

This will give you the ACTUAL current build information, including the revision number.

Henriquez

It doesn't work with Windows 11... – Udometer

Answer 34

systeminfo at the C:\ prompt in powershell or at the cmd prompt window gives OS name version configuration manufacturer and lots more...

Malik

This is already mentioned in other answers. – Monodic

Does this apply to MS Windows 10? – Delano

Answer 35

$OSVersion = [Version](Get-ItemProperty -Path "$($Env:Windir)\System32\hal.dll" -ErrorAction SilentlyContinue).VersionInfo.FileVersion.Split()[0]

On Windows 10 returns: 10.0.10586.420

You can then use the variable to access properties for granular comparison

$OSVersion.Major equals 10
$OSVersion.Minor equals 0
$OSVersion.Build equals 10586
$OSVersion.Revision equals 420

Additionally, you can compare operating system versions using the following

If ([Version]$OSVersion -ge [Version]"6.1")
   {
       #Do Something
   }

Wolcott

This does not work. The hal.dll file represents what version of WinRE is installed, not the existing OS. Do NOT use this, it is not accurate. – Kilometer

Answer 36

You can use python, to simplify things (works on all Windows versions and all other platforms):

import platform

print(platform.system()) # returns 'Windows', 'Linux' etc.
print(platform.release()) # returns for Windows 10 or Server 2019 '10'

if platform.system() = 'Windows':
    print(platform.win32_ver()) # returns (10, 10.0.17744, SP0, Multiprocessor Free) on windows server 2019

Tenorio

The question is "How to find the Windows version from the PowerShell command line". This is not really an answer to that question and you should consider deleting it. – Brattishing