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?

1

31 Answers

1 2

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.

9

  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

2

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
5
Get-ComputerInfo | select WindowsProductName, WindowsVersion, OsHardwareAbstractionLayer

returns

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

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)
8

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...

1

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).

3

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 }

If you are trying to decipher info MS puts on their patching site such as

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

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.

1

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))"
3

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} }
0

Use:

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

Should be easy like this :

Get-ComputerInfo | select windowsversion
2

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!

4

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

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]

1

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.

2
(Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" -Name BuildLabEx).BuildLabEx
1
(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.

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

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" } }
3

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

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
1

[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-----------------#
1

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"}

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'

1

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.

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

2
$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 }
0

1 2