Detect whether current Windows version is 32 bit or 64 bit
Asked Answered
E

24

65

Believe it or not, my installer is so old that it doesn't have an option to detect the 64-bit version of Windows.

Is there a Windows DLL call or (even better) an environment variable that would give that information for Windows XP and Windows Vista?

One possible solution

I see that Wikipedia states that the 64-bit version of Windows XP and Windows Vista have a unique environment variable: %ProgramW6432%, so I'm guessing that'd be empty on 32-bit Windows.

This variable points to Program Files directory, which stores all the installed program of Windows and others. The default on English-language systems is C:\Program Files. In 64-bit editions of Windows (XP, 2003, Vista), there are also %ProgramFiles(x86)% which defaults to C:\Program Files (x86) and %ProgramW6432% which defaults to C:\Program Files. The %ProgramFiles% itself depends on whether the process requesting the environment variable is itself 32-bit or 64-bit (this is caused by Windows-on-Windows 64-bit redirection).

Echovirus answered 2/3, 2009 at 2:33 Comment(7)
Refer to: - If you're using .NET: How to detect Windows 64-bit platform with .NET? - If you want to use it outside .NET: How to detect programmatically whether you are running on 64-bit WindowsLandlord
Related to #1739485Townswoman
I posted the MSDN / Perl answer here: #2030539Douceur
Why not use a new installer? o_OFissiparous
For Java, see also #4749173 . (In brief, don't rely on os.arch.)Fealty
I see that Wikipedia states that the 64-bit version of Windows XP and Windows Vista have a unique environment variable: %ProgramW6432%, so I'm guessing that'd be empty on 32-bit Windows. Not quite. Windows XP seems to leave alone references to environment variables it doesn't know about. I.e echo %ProgramW6432% causes %ProgramW6432% to be echoed, rather than a null string. You should still be able to use this however, with a statement like: if "%ProgramW6432%" == "Program Files" echo 64-bit OS detected or if not "%ProgramW6432%" == "Program Files" echo 32-bit OS detectedLias
Also see: #29075173Akihito
T
9

See the batch script listed in How To Check If Computer Is Running A 32 Bit or 64 Bit Operating System. It also includes instructions for checking this from the Registry:

You can use the following registry location to check if computer is running 32 or 64 bit of Windows operating system:

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

You will see the following registry entries in the right pane:

Identifier     REG_SZ             x86 Family 6 Model 14 Stepping 12
Platform ID    REG_DWORD          0x00000020(32)

The above “x86” and “0x00000020(32)” indicate that the operating system version is 32 bit.

Townswoman answered 27/11, 2011 at 16:9 Comment(8)
I find the referenced KB article somewhat confusing: They look at whether the CPU is 32 or 64 bit, and from that they determine whether you're running 32-bit or 64-bit Windows? I'm pretty sure you can run 32-bit Windows on a 64-bit CPU. Or maybe I'm missing something..Snowfall
@daniel kullmann: Obviously the key will be faked to be X86 as the microsoft kb articel noticed to use HKLM\SYSTEM\CurrentCongtrolSet\Control\Session Manager\Envirornment to determine the actual processor type.Endocardial
With regards to HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0... - On a Win7 64 bit box, I have the following values: Identifier = "Intel64 Family 6 Model 23 Stepping 6", and Platform ID=1 - On a WinXP 32 box (a VM), I have the following values: Identifier = "x86 Family 6 Model 26 Stepping 5", and Platform ID=1 The point here is not to rely on Platform ID (as it's not always 0x00000020 for x86).Cuirass
On Win8.1x64, Platform ID not exist. But here other key Platform Specific Field 1 which is 0x00000002 (two)Mclean
Having 64bit CPU does not entail running 64 bit windows. I have a laptop with 64bit CPU but 32bit windows preinstalled on it.Sentimentalize
I'm using Window7 x86, Windows 8.1 x64, Windows Xp x86. But I can't find Platform ID on Windows 8.1 and the value is not 0x0000020 on Windows 7 and Windows Xp.Slattern
On Win10 x64 on Intel(R) Xeon(R) CPU E5520 @ 2.27GHz there is no Platform ID but Platform Specific Field 1 with value 1.Symbolic
Note that referenced KB article (Last Updated: Apr 17, 2018) states : Applies to: Microsoft Windows Server 2003 Datacenter Edition (32-bit x86)Microsoft Windows Server 2003 Enterprise Edition (32-bit x86)Microsoft Windows Server 2003 Standard Edition (32-bit x86)Microsoft Windows Server 2003 Web EditionSymbolic
T
63

To check for a 64-bit version of Windows in a command box, I use the following template:

test.bat:

@echo off
if defined ProgramFiles(x86) (
    @echo yes
    @echo Some 64-bit work
) else (
    @echo no
    @echo Some 32-bit work
)

ProgramFiles(x86) is an environment variable automatically defined by cmd.exe (both 32-bit and 64-bit versions) on Windows 64-bit machines only.

Tayib answered 2/12, 2009 at 13:53 Comment(7)
Are those Environment Variables you're testing there? And by the answer "yes, no", are you answering the question : "Is this the 64 bit version of Windows"?Echovirus
I've just checked on both 32 and 64 bit Windows 7 systems, and it works as advertised. Nice.Sarene
Note that braces for if work in XP+. If you care about Win98 that is ;-).Dilation
It's also simple enough to use without any additional cookbooks with tools such as Chef, which is a bonus.Ballista
Tested, I think this should be the accepted answer.Bougie
On my windows7, this won't work when used in a script inside an if block: "if defined ProgramFiles(x86) (" gives ") was unexpected at this time." And quoting "ProgramFiles(x86)" doesn't work either.Appanage
The variable ProgramFiles(x86) seems to serve interoperability between 32-bit and 64-bit parent and child processes. An SS64.com article Detecting 64 bit vs 32 bit shows tricks to detect 64-bit hardware, OS and processes. ss64.com/nt/syntax-64bit.htmlMonoicous
L
20

Here is some Delphi code to check whether your program is running on a 64 bit operating system:

function Is64BitOS: Boolean;
{$IFNDEF WIN64}
type
  TIsWow64Process = function(Handle:THandle; var IsWow64 : BOOL) : BOOL; stdcall;
var
  hKernel32 : Integer;
  IsWow64Process : TIsWow64Process;
  IsWow64 : BOOL;
{$ENDIF}
begin
  {$IFDEF WIN64}
     //We're a 64-bit application; obviously we're running on 64-bit Windows.
     Result := True;
  {$ELSE}
  // We can check if the operating system is 64-bit by checking whether
  // we are running under Wow64 (we are 32-bit code). We must check if this
  // function is implemented before we call it, because some older 32-bit 
  // versions of kernel32.dll (eg. Windows 2000) don't know about it.
  // See "IsWow64Process", http://msdn.microsoft.com/en-us/library/ms684139.aspx
  Result := False;
  hKernel32 := LoadLibrary('kernel32.dll');
  if hKernel32 = 0 then RaiseLastOSError;
  try
    @IsWow64Process := GetProcAddress(hkernel32, 'IsWow64Process');
    if Assigned(IsWow64Process) then begin
      if (IsWow64Process(GetCurrentProcess, IsWow64)) then begin
        Result := IsWow64;
      end
      else RaiseLastOSError;
    end;
  finally
    FreeLibrary(hKernel32);
  end;  
  {$ENDIf}
end;
Lettielettish answered 27/10, 2009 at 22:25 Comment(8)
Since stackoverflow is a programming site, this is the programmers answer: using the API intended to answer this question.Wrap
Does it work? Since you test at COMPILE time if the app was build on a 64bit system. Basically, if the app was compiled on 64 bits it will always answer TRUE even, of 32 bits. Am I right?Akihito
Also see: #29075173Akihito
@Altar no, I'm testing at compile time if the app was built for a 64bit system. You can compile 32-bit programs on a 64-bit system.Lettielettish
blogs.msdn.com/b/oldnewthing/archive/2005/02/01/364563.aspx and MSDN both suggest that this function is always defined in win32 and win64 so the code could be made simpler by just executing IsWow64Process.Gumption
@Gumption MSDN appears to agree with me..Lettielettish
My point was your whole code bloat could be reduced to just one line of code.Gumption
@Gumption I understand what you are saying, but you are incorrect. Read the msdn link. "Minimum supported client Windows Vista, Windows XP with SP2" -- Win2k, for example, does not have IsWow64Process. The same point is made in the comments of the blog post you linked.Lettielettish
T
14

From a batch script:

IF PROCESSOR_ARCHITECTURE == x86 AND
   PROCESSOR_ARCHITEW6432 NOT DEFINED THEN
   // OS is 32bit
ELSE
   // OS is 64bit
END IF

Using Windows API:

if (GetSystemWow64Directory(Directory, MaxDirectory) > 0) 
   // OS is 64bit
else
   // OS is 32bit

Sources:

  1. HOWTO: Detect Process Bitness
  2. GetSystemWow64Directory function
Townswoman answered 27/11, 2011 at 16:20 Comment(1)
Note my 64bit Win7 machine has PROCESSOR_ARCHITECTURE set to AMD64Rollet
E
13

I tested the solution I suggested in my question:

Tested for Windows Environment Variable: ProgramW6432

If it's non empty then it's 64 bit Windows.W

Echovirus answered 17/3, 2009 at 19:5 Comment(6)
The environment variable you listed in your question was ProgramW6432. Here, you list PROCESSOR_ARCHITEW6432. Which one did you use?Hectogram
Thanks Andrew. I found out about this mistake the hard way: when I had someone test it ;-). Should have been: ProgramW6432 .Fixing it now.Echovirus
I don't have either of these environment variables (ProgramW6432 PROCESSOR_ARCHITEW6432), on my Vista 64. I do have PROCESSOR_ARCHITECTURE, which is set to x86 or AMD64Dongdonga
Thanks Mike! Now, if I can just figure out if Processor_Architecture is always present on Win 64.Echovirus
Except for PROCESSOR_ARCHITE*, these env variables were added in Win7/Server2008: msdn.microsoft.com/en-us/library/aa384274(VS.85).aspxNeckband
@Mike, @total, @Clay: I do have ProgramW6432, PROCESSOR_ARCHITEW6432 and CommonProgramW6432 on my 64-bit Vista Enterprise SP2, but only in 32-bit command prompt. Whether or not these variables are defined seems to depend on the bitness of the calling process, not the OS bitness.Philis
T
9

See the batch script listed in How To Check If Computer Is Running A 32 Bit or 64 Bit Operating System. It also includes instructions for checking this from the Registry:

You can use the following registry location to check if computer is running 32 or 64 bit of Windows operating system:

HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0

You will see the following registry entries in the right pane:

Identifier     REG_SZ             x86 Family 6 Model 14 Stepping 12
Platform ID    REG_DWORD          0x00000020(32)

The above “x86” and “0x00000020(32)” indicate that the operating system version is 32 bit.

Townswoman answered 27/11, 2011 at 16:9 Comment(8)
I find the referenced KB article somewhat confusing: They look at whether the CPU is 32 or 64 bit, and from that they determine whether you're running 32-bit or 64-bit Windows? I'm pretty sure you can run 32-bit Windows on a 64-bit CPU. Or maybe I'm missing something..Snowfall
@daniel kullmann: Obviously the key will be faked to be X86 as the microsoft kb articel noticed to use HKLM\SYSTEM\CurrentCongtrolSet\Control\Session Manager\Envirornment to determine the actual processor type.Endocardial
With regards to HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0... - On a Win7 64 bit box, I have the following values: Identifier = "Intel64 Family 6 Model 23 Stepping 6", and Platform ID=1 - On a WinXP 32 box (a VM), I have the following values: Identifier = "x86 Family 6 Model 26 Stepping 5", and Platform ID=1 The point here is not to rely on Platform ID (as it's not always 0x00000020 for x86).Cuirass
On Win8.1x64, Platform ID not exist. But here other key Platform Specific Field 1 which is 0x00000002 (two)Mclean
Having 64bit CPU does not entail running 64 bit windows. I have a laptop with 64bit CPU but 32bit windows preinstalled on it.Sentimentalize
I'm using Window7 x86, Windows 8.1 x64, Windows Xp x86. But I can't find Platform ID on Windows 8.1 and the value is not 0x0000020 on Windows 7 and Windows Xp.Slattern
On Win10 x64 on Intel(R) Xeon(R) CPU E5520 @ 2.27GHz there is no Platform ID but Platform Specific Field 1 with value 1.Symbolic
Note that referenced KB article (Last Updated: Apr 17, 2018) states : Applies to: Microsoft Windows Server 2003 Datacenter Edition (32-bit x86)Microsoft Windows Server 2003 Enterprise Edition (32-bit x86)Microsoft Windows Server 2003 Standard Edition (32-bit x86)Microsoft Windows Server 2003 Web EditionSymbolic
A
8

If you can make API calls, try using GetProcAddress / GetModuleHandle to check for the existence of IsWow64Process which is only present in Windows OS that have 64-bit versions.

You could also try the ProgramFiles(x86) environment variable used in Vista/2008 for backwards compatibility, but I'm not 100% sure about XP-64 or 2003-64.

Good luck!

Akan answered 2/3, 2009 at 2:40 Comment(4)
PG(x86) is in at least XP-64 and since XP-64 is more related to 2003-64 than, say, XP original I'd bet it's in 2003-64 too.Wobble
According to the MSDN article for IsWow64Process, "Note that this technique is not a reliable way to detect whether the operating system is a 64-bit version of Windows because the Kernel32.dll in current versions of 32-bit Windows also contains this function."Donetsk
Checking the existence of IsWow64Process is not reliable. Just failed on Windows Xp 32 bit. IsWow64Process is presentMacaw
Checking for the entry point is not a reliable test, but according to Raymond Chen calling that entry point (if present) and checking the return value is. If it's not present or returns FALSE you're on 32-bit Windows, if it returns TRUE you're running under WOW64 so running on a Windows of at least 64 bits...Astragalus
V
6

I used this within a login script to detect 64 bit Windows

if "%ProgramW6432%" == "%ProgramFiles%" goto is64flag
Vigilance answered 4/3, 2010 at 23:29 Comment(0)
H
4

I don't know what language you're using, but .NET has the environment variable PROCESSOR_ARCHITEW6432 if the OS is 64-bit.

If all you want to know is whether your application is running 32-bit or 64-bit, you can check IntPtr.Size. It will be 4 if running in 32-bit mode and 8 if running in 64-bit mode.

Hectogram answered 2/3, 2009 at 2:40 Comment(3)
This option only works in .net. I need an option that'll work with my installer.Echovirus
If you force the project to 32-bit (e.g. Project->Propterties and change platform target to x86), the IntPtr.Size value will be 4.Souvaine
@Jader: Right you are. I didn't realize how ambiguous my answer was before, but it was obvious as soon as you pointed it out. I've edited my answer for clarity.Hectogram
F
4

For a VBScript / WMI one-liner that retrieves the actuals bits number (32 or 64) of the OS or the Hardware, take a look at http://csi-windows.com/toolkit/csi-getosbits

Flypaper answered 14/12, 2010 at 14:39 Comment(0)
L
3

I want to add what I use in shell scripts (but can easily be used in any language) here. The reason is, that some of the solutions here don't work an WoW64, some use things not really meant for that (checking if there is a *(x86) folder) or don't work in cmd scripts. I feel, this is the "proper" way to do it, and should be safe even in future versions of Windows.

 @echo off
 if /i %processor_architecture%==AMD64 GOTO AMD64
 if /i %PROCESSOR_ARCHITEW6432%==AMD64 GOTO AMD64
    rem only defined in WoW64 processes
 if /i %processor_architecture%==x86 GOTO x86
 GOTO ERR
 :AMD64
    rem do amd64 stuff
 GOTO EXEC
 :x86
    rem do x86 stuff
 GOTO EXEC
 :EXEC
    rem do arch independent stuff
 GOTO END
 :ERR
    rem I feel there should always be a proper error-path!
    @echo Unsupported architecture!
    pause
 :END
Lecturer answered 8/7, 2012 at 14:37 Comment(6)
Josef, have you tested this on a 32 bit and 64 bit machine?Echovirus
My use for this is to have my installer behave differently so I'd need a return value. So I'd call this script and then have it return a value (1 or 0, etc.).Echovirus
For anyone who's wondering, the PROCESSOR_ARCHITECTURE variable appears to change for compiled programs. echo %PROCESSOR_ARCHITECTURE% reported AMD64 on Windows XP x64, but when I ran a 32-bit compiled program using this variable, it came back as x86.Freespoken
@Freespoken that's why the check for "%PROCESSOR_ARCHITEW6432%" is there! That script works flawlessly for all windows versions >= XP and even if called in a 32bit cmd.exe on a 64bit os!Lecturer
@Lecturer That environment variable didn't appear to be on the systems I was testing against... Maybe I wasn't looking close enough.Freespoken
@Lecturer Right you are, friend! It's a magic environment variable that didn't show up when I ran set, but it's there in the compiled program. Silly me. Thanks for setting me straight!Freespoken
S
3

A lot of answers mention calling IsWoW64Process() or related functions. This is not the correct way. You should use GetNativeSystemInfo() which was designed for this purpose. Here's an example:

SYSTEM_INFO info;
GetNativeSystemInfo(&info);

if (info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
  // It's a 64-bit OS
}

Also see: https://msdn.microsoft.com/en-us/library/windows/desktop/ms724340%28v=vs.85%29.aspx

Singlet answered 24/3, 2015 at 4:42 Comment(0)
E
2

I don't know on which Windows version it exists, but on Windows Vista and later this runs:

Function Is64Bit As Boolean
    Dim x64 As Boolean = System.Environment.Is64BitOperatingSystem
    If x64 Then
       Return true
    Else
       Return false
    End If
End Function
Elsaelsbeth answered 2/2, 2011 at 14:31 Comment(0)
D
1

In C#:

public bool Is64bit() {
    return Marshal.SizeOf(typeof(IntPtr)) == 8;
}

In VB.NET:

Public Function Is64bit() As Boolean
   If Marshal.SizeOf(GetType(IntPtr)) = 8 Then Return True
   Return False
End Function
Derr answered 2/3, 2009 at 3:0 Comment(2)
That detects if the application is a 64-bit app. If you force it to 32-bit (e.g. Project->Propterties and change platform target to x86), the return value will be 4.Mycostatin
Not the answer to this question, this detect if application is compilered as 64bit.Calendra
H
1

I use this:

@echo off
if "%PROCESSOR_ARCHITECTURE%"=="AMD64" (
 echo 64 BIT
) else (
 echo 32 BIT
)

It works on Windows XP, tested it on Windows XP Professional Both 64 bit and 32 bit.

Heteronym answered 9/1, 2015 at 13:3 Comment(0)
P
0

I tested the following batch file on Windows 7 x64/x86 and Windows XP x86 and it's fine, but I haven't tried Windows XP x64 yet, but this will probably work:

If Defined ProgramW6432 (Do x64 stuff or end if you are aiming for x86) else (Do x86 stuff or end if you are aiming for x64) 
Promulgate answered 2/1, 2012 at 13:16 Comment(0)
H
0

I know this is ancient but, here's what I use to detect Win764

On Error Resume Next

Set objWSHShell = CreateObject("WScript.Shell")

strWinVer = objWSHShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\BuildLabEx")

If len(strWinVer) > 0 Then
    arrWinVer = Split(strWinVer,".")
    strWinVer = arrWinVer(2)
End If

Select Case strWinVer
Case "x86fre"
strWinVer = "Win7"
Case "amd64fre"
    strWinVer = "Win7 64-bit"
Case Else
    objWSHShell.Popup("OS Not Recognized")
    WScript.Quit
End Select
Holmen answered 19/1, 2012 at 21:43 Comment(0)
C
0

Using Windows Powershell, if the following expression returns true, then it's a 64 bit OS:

(([Array](Get-WmiObject -Class Win32_Processor | Select-Object AddressWidth))[0].AddressWidth -eq 64)

This was taken and modified from: http://depsharee.blogspot.com/2011/06/how-do-detect-operating-system.html (Method #3). I've tested this on Win7 64 bit (in both 32 and 64 bit PowerShell sessions), and XP 32 bit.

Cuirass answered 21/1, 2014 at 22:15 Comment(0)
L
0

The best way is surely just to check whether there are two program files directories, 'Program Files'and 'Program Files (x86)' The advantage of this method is you can do it when the o/s is not running, for instance if the machine has failed to start and you wish to reinstall the operating system

Loginov answered 25/4, 2014 at 7:42 Comment(3)
They can be moved and/or renamed. Those are just the default names.Ecstatics
Have you tried this? I've never seen an installation without these directoriesLoginov
It may be possible, but just... don't. Just like you don'r rm -rf / on your Linux, even though you couldWildfire
G
0

Interestingly, if I use

get-wmiobject -class Win32_Environment -filter "Name='PROCESSOR_ARCHITECTURE'"

I get AMD64 in both 32-bit and 64-bit ISE (on Win7 64-bit).

Greisen answered 9/7, 2014 at 3:17 Comment(0)
M
0

Another way created by eGerman that uses PE numbers of compiled executables (does not rely on registry records or environment variables):

@echo off &setlocal


call :getPETarget "%SystemRoot%\explorer.exe"


if "%=ExitCode%" EQU "00008664" (
    echo x64
) else (
    if "%=ExitCode%" EQU "0000014C" (
        echo x32
    ) else (
        echo undefined
    )
)


goto :eof


:getPETarget FilePath
:: ~~~~~~~~~~~~~~~~~~~~~~
:: Errorlevel
::   0 Success
::   1 File Not Found
::   2 Wrong Magic Number
::   3 Out Of Scope
::   4 No PE File
:: ~~~~~~~~~~~~~~~~~~~~~~
:: =ExitCode
::   CPU identifier

setlocal DisableDelayedExpansion
set "File=%~1"
set Cmp="%temp%\%random%.%random%.1KB"
set Dmp="%temp%\%random%.%random%.dmp"

REM write 1024 times 'A' into a temporary file
if exist "%File%" (
  >%Cmp% (
    for /l %%i in (1 1 32) do <nul set /p "=AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  )
  setlocal EnableDelayedExpansion
) else (endlocal &cmd /c exit 0 &exit /b 1)

REM generate a HEX dump of the executable file (first 1024 Bytes)
set "X=1"
>!Dmp! (
  for /f "skip=1 tokens=1,2 delims=: " %%i in ('fc /b "!File!" !Cmp!^|findstr /vbi "FC:"') do (
    set /a "Y=0x%%i"
    for /l %%k in (!X! 1 !Y!) do echo 41
    set /a "X=Y+2"
    echo %%j
  )
)
del !Cmp!

REM read certain values out of the HEX dump
set "err="
<!Dmp! (
  set /p "A="
  set /p "B="
  REM magic number has to be "MZ"
  if "!A!!B!" neq "4D5A" (set "err=2") else (
    REM skip next 58 bytes
    for /l %%i in (3 1 60) do set /p "="
    REM bytes 61-64 contain the offset to the PE header in little endian order
    set /p "C="
    set /p "D="
    set /p "E="
    set /p "F="
    REM check if the beginning of the PE header is part of the HEX dump
    if 0x!F!!E!!D!!C! lss 1 (set "err=3") else (
      if 0x!F!!E!!D!!C! gtr 1018 (set "err=3") else (
        REM skip the offset to the PE header
        for /l %%i in (65 1 0x!F!!E!!D!!C!) do set /p "="
        REM next 4 bytes have to contain the signature of the PE header
        set /p "G="
        set /p "H="
        set /p "I="
        set /p "J="
        REM next 2 bytes contain the CPU identifier in little endian order
        set /p "K="
        set /p "L="
      )
    )
  )
)
del !Dmp!
if defined err (endlocal &endlocal &cmd /c exit 0 &exit /b %err%)

REM was the signature ("PE\0\0") of the PE header found
if "%G%%H%%I%%J%"=="50450000" (
  REM calculate the decimal value of the CPU identifier
  set /a "CPUID=0x%L%%K%"
) else (endlocal &endlocal &cmd /c exit 0 &exit /b 4)
endlocal &endlocal &cmd /c exit %CPUID% &exit /b 0
Marcomarconi answered 20/8, 2014 at 9:20 Comment(0)
L
0

Here is a simpler method for batch scripts

    @echo off

    goto %PROCESSOR_ARCHITECTURE%

    :AMD64
    echo AMD64
    goto :EOF

    :x86 
    echo x86
    goto :EOF
Limousin answered 20/11, 2014 at 13:58 Comment(0)
P
0

Answer for Newer Versions of Windows

Today, I posted some code on another question and an explanation of how to do this with IsWow64Process2 for Windows 10 version 1511 or later and Windows Server 2016. Additionally, the code determines if the process is 32 or 64 bit and whether the process is running under the WOW64 emulator.

One of the main reasons I have posted the answer is because while there were several suggestions to use IsWow64Process2, no code that I saw showed how.

Please see the answer here: https://mcmap.net/q/302398/-detect-32-bit-or-64-bit-of-windows

Protestation answered 23/12, 2019 at 0:16 Comment(0)
S
0

You can use the module from npm called @wider/utils_where-am-i. This runs in any javascript environment on a windows machine and elsewhere such as linux. On a windows machine it delivers an object which has { os: 'win32' } or { os : 'win64' }. It can run as legacy plain javascript say in wshell, in classic ASP or nodeJS

Sylph answered 12/9, 2021 at 9:4 Comment(0)
L
-2

Check the Registry for the existence of HKLM\SOFTWARE\Wow6432Node - If it's there, the system is 64-bit - 32-bit, otherwise.

Linen answered 4/4, 2013 at 15:36 Comment(1)
I'd caution against using the existence of the HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node key in the registry -- It just takes one other (incorrect) program to install something there on a 32 bit OS to cause this method to fail -- that's the reason I found this page in the first place!Cuirass

© 2022 - 2024 — McMap. All rights reserved.