How to check if running in Cygwin, Mac or Linux?

Asked 12/8, 2010 at 9:10 Answered 30/4, 2019 at 19:33

465

I have a shell script that is used both on Windows/Cygwin and Mac and Linux. It needs slightly different variables for each versions.

How can a shell/bash script detect whether it is running in Cygwin, on a Mac or in Linux?

Pellucid answered 12/8, 2010 at 9:10 Comment(0)

471

Usually, uname with its various options will tell you what environment you're running in:

pax> uname -a
CYGWIN_NT-5.1 IBM-L3F3936 1.5.25(0.156/4/2) 2008-06-12 19:34 i686 Cygwin

pax> uname -s
CYGWIN_NT-5.1

And, according to the very helpful schot (in the comments), uname -s gives Darwin for OSX and Linux for Linux, while my Cygwin gives CYGWIN_NT-5.1. But you may have to experiment with all sorts of different versions.

So the bash code to do such a check would be along the lines of:

unameOut="$(uname -s)"
case "${unameOut}" in
    Linux*)     machine=Linux;;
    Darwin*)    machine=Mac;;
    CYGWIN*)    machine=Cygwin;;
    MINGW*)     machine=MinGw;;
    MSYS_NT*)   machine=Git;;
    *)          machine="UNKNOWN:${unameOut}"
esac
echo ${machine}

Note that I'm assuming here that you're actually running within CygWin (the bash shell of it) so paths should already be correctly set up. As one commenter notes, you can run the bash program, passing the script, from cmd itself and this may result in the paths not being set up as needed.

If you are doing that, it's your responsibility to ensure the correct executables (i.e., the CygWin ones) are being called, possibly by modifying the path beforehand or fully specifying the executable locations (e.g., /c/cygwin/bin/uname).

Pina answered 12/8, 2010 at 9:12 Comment(7)

Sometimes less is more ;) BTW, Wikipedia has a table of example uname output at en.wikipedia.org/wiki/Uname – Sulfatize 12/8, 2010 at 9:24

The Git Bash uname -s output on Windows 7 is MINGW32_NT-6.1. Also, there is no /cygdrive prefix, just /c for C:. – Romaine 10/9, 2011 at 1:24

Git Bash isn't Cygwin. It is MinGW, minimal GNU for MS Windows, which is why the behavior is different. – Geary 28/1, 2014 at 16:25

I promoted the other answer because this answer doesn't deal with the OP portion How can a shell/bash script detect ... and the other does. – Glowing 12/7, 2017 at 17:48

If I run a script under cygwin by executing "\cygwin64\bin\bash -c scriptname", this doesn't necessarily work. In this situation, the cygwin path doesn't get set up and uname -s ends up calling whatever uname is first in your current path, which on my system turns out to be the version installed with geda which returns the text WindowsNT. It could equally be the MinGW version as described above, though. A reliable detection for cygwin must not rely on the path being set appropriately, IMO. Therefore, $(uname -s) should be changed to $(/bin/uname -s) to detect cygwin. – Oteliaotero 21/11, 2017 at 0:45

@Jules, good points but I'm not sure they're relevant. The question talks about running in CygWin which I take to mean inside the bash shell of it (further supported by the tags). In that case, the paths should already be correctly set. While the path should be able to reach out for Windows executables, they should be after all the CygWin stuff. In any case, I'll clarify the answer. – Pina 21/11, 2017 at 1:22

You can run Bash in Windows 10 without cygwin. uname will return something like: MSYS_NT-10.0-19041 so matching against MSYS_NT*) will do the trick. – Dagda 10/11, 2020 at 19:48

395

Detect three different OS types (GNU/Linux, Mac OS X, Windows NT)

Notes

In your bash script, use #!/usr/bin/env bash instead of #!/bin/sh to prevent the problem caused by /bin/sh linked to different default shell in different platforms, or there will be error like unexpected operator, that's what happened on my computer (Ubuntu 64 bits 12.04).
Mac OS X 10.6.8 (Snow Leopard) do not have expr program unless you install it, so I just use uname.

Design

Use uname to get the system information (-s parameter).
Use expr and substr to deal with the string.
Use if elif fi to do the matching job.
You can add more system support if you want, just follow the uname -s specification.

Implementation

#!/usr/bin/env bash

if [ "$(uname)" == "Darwin" ]; then
    # Do something under Mac OS X platform        
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
    # Do something under GNU/Linux platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
    # Do something under 32 bits Windows NT platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then
    # Do something under 64 bits Windows NT platform
fi

Testing

Linux (Ubuntu 12.04 LTS, Kernel 3.2.0) tested OK.
OS X (10.6.8 Snow Leopard) tested OK.
Windows (Windows 7 64 bit) tested OK.

What I learned

Check for both opening and closing quotes.
Check for missing parentheses and braces {}

References

Kristofor answered 12/6, 2013 at 17:50 Comment(8)

For MinGW, it may make more sense to check: [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]. – Bordelon 13/7, 2013 at 20:27

@Albert: expression "$(expr substr $(uname -s) 1 5)" is weird a bit. There are more pretty ways to do that, for example: if [ `uname -s` == CYGWIN* ]; then. Read it: if uname -s starts with CYGWIN then... – Dispend 14/5, 2014 at 15:6

@DawidFerenczy I believe it would require double brackets like if [[ $(uname -s) == CYGWIN* ]]; then – Viole 31/8, 2015 at 20:58

This doesn't detect Cygwin, as was asked in the question. – Annulet 25/10, 2016 at 15:49

Why does this check only the first 5 characters for Linux? Are there examples of modern Linux distros where uname -s will yield something other than "Linux"? – Continue 15/12, 2016 at 17:37

On 64-bit Windows 10, the third case should read MINGW64_NT instead of MINGW32_NT. – Georgenegeorges 8/3, 2017 at 23:27

@CraigOtis I do not have the environment to test the new modification, if the new codes have bugs, corrections are welcomed. – Kristofor 19/3, 2017 at 7:39

ShellCheck will complain about expr usage: github.com/koalaman/shellcheck/wiki/SC2003 – Poolroom 4/6, 2020 at 14:30

195

Use uname -s (--kernel-name) because uname -o (--operating-system) is not supported on some Operating Systems such as Mac OS and Solaris. You may also use just uname without any argument since the default argument is -s (--kernel-name).

To distinguish WSL from Linux, einarmagnus recommends uname -sr (--kernel-name --kernel-release) as proposed in the following script. 😉

#!/bin/sh

case "$(uname -sr)" in

   Darwin*)
     echo 'Mac OS X'
     ;;

   Linux*Microsoft*)
     echo 'WSL'  # Windows Subsystem for Linux
     ;;

   Linux*)
     echo 'Linux'
     ;;

   CYGWIN*|MINGW*|MINGW32*|MSYS*)
     echo 'MS Windows'
     ;;

   # Add here more strings to compare
   # See correspondence table at the bottom of this answer

   *)
     echo 'Other OS' 
     ;;
esac

The following Makefile is inspired from Git project (config.mak.uname).

ifdef MSVC     # Avoid the MingW/Cygwin sections
    uname_S := Windows
else                          # If uname not available => 'not' 
    uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
endif

# Avoid nesting "if .. else if .. else .. endif endif"
# because maintenance of matching if/else/endif is a pain

ifeq ($(uname_S),Windows)
    CC := cl 
endif
ifeq ($(uname_S),OSF1)
    CFLAGS += -D_OSF_SOURCE
endif
ifeq ($(uname_S),Linux)
    CFLAGS += -DNDEBUG
endif
ifeq ($(uname_S),GNU/kFreeBSD)
    CFLAGS += -D_BSD_ALLOC
endif
ifeq ($(uname_S),UnixWare)
    CFLAGS += -Wextra
endif
...

The correspondence table in the bottom of this answer is from Wikipedia article about uname. Please contribute to keep it up-to-date (edit the answer or post a comment). You may also update the Wikipedia article and post a comment to notify me about your contribution ;-)

Operating System	uname -s
Mac OS X	Darwin
Cygwin 32-bit (Win-XP)	CYGWIN_NT-5.1
Cygwin 32-bit (Win-7 32-bit)	CYGWIN_NT-6.1
Cygwin 32-bit (Win-7 64-bit)	CYGWIN_NT-6.1-WOW64
Cygwin 64-bit (Win-7 64-bit)	CYGWIN_NT-6.1
MinGW (Windows 7 32-bit)	MINGW32_NT-6.1
MinGW (Windows 10 64-bit)	MINGW64_NT-10.0
Interix (Services for UNIX)	Interix
MSYS	MSYS_NT-6.1
MSYS2	MSYS_NT-10.0-17763
Windows Subsystem for Linux	Linux
Android	Linux
coreutils	Linux
CentOS	Linux
Fedora	Linux
Gentoo	Linux
Red Hat Linux	Linux
Linux Mint	Linux
openSUSE	Linux
Ubuntu	Linux
Unity Linux	Linux
Manjaro Linux	Linux
OpenWRT r40420	Linux
Debian (Linux)	Linux
Debian (GNU Hurd)	GNU
Debian (kFreeBSD)	GNU/kFreeBSD
FreeBSD	FreeBSD
NetBSD	NetBSD
OpenBSD	OpenBSD
DragonFlyBSD	DragonFly
Haiku	Haiku
NonStop	NONSTOP_KERNEL
QNX	QNX
ReliantUNIX	ReliantUNIX-Y
SINIX	SINIX-Y
Tru64	OSF1
Ultrix	ULTRIX
IRIX 32 bits	IRIX
IRIX 64 bits	IRIX64
MINIX	Minix
Solaris	SunOS
UWIN (64-bit Windows 7)	UWIN-W7
SYS$UNIX:SH on OpenVMS	IS/WB
z/OS USS	OS/390
Cray	sn5176
(SCO) OpenServer	SCO_SV
(SCO) System V	SCO_SV
(SCO) UnixWare	UnixWare
IBM AIX	AIX
IBM i with QSH	OS400
HP-UX	HP-UX

Penalty answered 5/1, 2015 at 9:42 Comment(10)

Thumbs up for Solaris and research above. – Tidy 6/2, 2017 at 14:15

Hi @okutane. I do not understand what you mean. Please provide more details. Do you suggest something? Cheers – Penalty 10/2, 2017 at 10:32

I'm voting up, that's it. – Tidy 10/2, 2017 at 10:36

This is precisely what I was looking for in order to write a portable/cross-platform ~/.profile (to set environment variables like $PATH -- commenting to provide search keywords for posterity). – Interlock 1/10, 2017 at 16:36

Should probably add Windows Subsystem for Linux now – Aaronson 16/8, 2018 at 1:46

Thank you @William for your feedback. I do not have Windows Subsystem for Linux but I have found this uname sample. I suppose uname -s displays Linux on Windows Subsystem for Linux, isn't it? Can you confirm? – Penalty 20/8, 2018 at 12:39

This is what ubuntu subsystem for linux displays for me Linux uname -a DESKTOP-9ETGU1K 4.4.0-17134-Microsoft #285-Microsoft Thu Aug 30 17:31:00 PST 2018 x86_64 x86_64 x86_64 GNU/Linux – Aaronson 30/9, 2018 at 1:38

Thank you @William I have just added "Windows Subsystem for Linux" in the table. Cheers – Penalty 1/10, 2018 at 7:7

I came here because I wanted to detect WSL specifically, and differentiate it from other Linuxes. What seems to work for me then is to check uname -sr and compare against Linux*Microsoft) before Linux*). – Hamblin 6/5, 2020 at 10:13

A case solution as shown here is usually the most elegant & flexible (better than if elif etc). must use it more often – Impletion 26/8, 2021 at 9:52

Bash sets the shell variable OSTYPE. From man bash:

Automatically set to a string that describes the operating system on which bash is executing.

This has a tiny advantage over uname in that it doesn't require launching a new process, so will be quicker to execute.

However, I'm unable to find an authoritative list of expected values. For me on Ubuntu 14.04 it is set to 'linux-gnu'. I've scraped the web for some other values. Hence:

case "$OSTYPE" in
  linux*)   echo "Linux / WSL" ;;
  darwin*)  echo "Mac OS" ;; 
  win*)     echo "Windows" ;;
  msys*)    echo "MSYS / MinGW / Git Bash" ;;
  cygwin*)  echo "Cygwin" ;;
  bsd*)     echo "BSD" ;;
  solaris*) echo "Solaris" ;;
  *)        echo "unknown: $OSTYPE" ;;
esac

The asterisks are important in some instances - for example OSX appends an OS version number after the 'darwin'. The 'win' value is actually 'win32', I'm told - maybe there is a 'win64'?

Perhaps we could work together to populate a table of verified values here:

Linux Ubuntu (incl. WSL): linux-gnu
Cygwin 64-bit: cygwin
Msys/MINGW (Git Bash for Windows): msys
MacOS Venura: darwin22.0

(Please append your value if it differs from existing entries)

Hexagonal answered 12/8, 2010 at 9:10 Comment(5)

I already like your answer more than mine, fits perfectly on the rare times I've needed this – Disposition 25/5, 2016 at 23:43

Technically, it's not an environment variable, it's a shell variable. That's why you won't see it under env | grep OSTYPE, but you will see it under set | grep OSTYPE – Bela 16/2, 2017 at 0:20

For those interested, Bash's OSTYPE variable (conftypes.h) is configured at build time using the exact copy of automake's OS variable (Makefile.in). One may consult automake's lib/config.sub file for all of the available types. – Ot 25/3, 2017 at 19:58

also zsh sets OSTYPE – Impletion 26/8, 2021 at 9:56

macOS with HomeBrew Bash show linux-gnu . – Claus 11/12, 2023 at 13:23

# This script fragment emits Cygwin rulez under bash/cygwin
if [[ $(uname -s) == CYGWIN* ]];then
    echo Cygwin rulez
else 
    echo Unix is king
fi

If the 6 first chars of uname -s command is "CYGWIN", a cygwin system is assumed

Cocky answered 13/3, 2013 at 17:10 Comment(4)

if [ `uname -s` == CYGWIN* ]; then looks better and works the same. – Dispend 14/5, 2014 at 15:9

Yes, but use double brackets: [[ $(uname -s) == CYGWIN* ]]. Note also that extended regular expressions are more precise in our case: [[ $(uname -s) =~ ^CYGWIN* ]]. – Calendre 30/12, 2014 at 4:19

Above works better, because expr substr $(uname -s) 1 6 gives an error (expr: syntax error) on macOS. – Kuykendall 20/9, 2018 at 9:33

Note that extended regular expressions are not globs, so to match "any char" after the CYGWIN requires .*. Adding * will only match extra Ns. So [[ $(uname -s) =~ ^CYGWIN.*$ ]] is needed for precision, but for our case [[ $(uname -s) =~ ^CYGWIN ]] would suffice – Imprudent 9/6, 2021 at 11:58

To build upon Albert's answer, I like to use $COMSPEC for detecting Windows:

#!/bin/bash

if [ "$(uname)" == "Darwin" ]
then
 echo Do something under Mac OS X platform
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]
then
  echo Do something under Linux platform
elif [ -n "$COMSPEC" -a -x "$COMSPEC" ]
then 
  echo $0: this script does not support Windows \:\(
fi

This avoids parsing variants of Windows names for $OS, and parsing variants of uname like MINGW, Cygwin, etc.

Background: %COMSPEC% is a Windows environmental variable specifying the full path to the command processor (aka the Windows shell). The value of this variable is typically %SystemRoot%\system32\cmd.exe, which typically evaluates to C:\Windows\system32\cmd.exe .

Udell answered 13/9, 2013 at 16:14 Comment(1)

Not correct any more as $COMSPEC is not set when running under the Windows UWS Bash environment. – Christenechristening 8/12, 2017 at 14:51

https://en.wikipedia.org/wiki/Uname

All the info you'll ever need. Google is your friend.

Use uname -s to query the system name.

Mac: Darwin
Cygwin: CYGWIN_...
Linux: various, LINUX for most

Multiplier answered 12/8, 2010 at 9:22 Comment(1)

I don't have enough rep for a 1-character edit, but that Wikipedia URL should be updated to point to the https version. Can a higher-rep user please do that? – Cannular 9/2, 2022 at 19:33

Windows Subsystem for Linux did not exist when this question was asked. It gave these results in my test:

uname -s -> Linux
uname -o -> GNU/Linux
uname -r -> 4.4.0-17763-Microsoft

This means that you need uname -r to distinguish it from native Linux.

Slavin answered 30/4, 2019 at 19:33 Comment(1)

Unfortunately, Mingw-w64 gives exactly the same. – Slavin 14/5, 2019 at 9:2

Ok, here is my way.

osis()
{
    local n=0
    if [[ "$1" = "-n" ]]; then n=1;shift; fi

    # echo $OS|grep $1 -i >/dev/null
    uname -s |grep -i "$1" >/dev/null

    return $(( $n ^ $? ))
}

e.g.

osis Darwin &&
{
    log_debug Detect mac osx
}
osis Linux &&
{
    log_debug Detect linux
}
osis -n Cygwin &&
{
    log_debug Not Cygwin
}

I use this in my dotfiles

Ingeingeberg answered 13/2, 2015 at 6:46 Comment(0)

I guess the uname answer is unbeatable, mainly in terms of cleanliness.

Although it takes a ridiculous time to execute, I found that testing for specific files presence also gives me good and quicker results, since I'm not invoking an executable:

So,

[ -f /usr/bin/cygwin1.dll ] && echo Yep, Cygwin running

just uses a quick Bash file presence check. As I'm on Windows right now, I can't tell you any specific files for Linuxes and Mac OS X from my head, but I'm pretty sure they do exist. :-)

Disposition answered 12/8, 2015 at 0:12 Comment(0)

Hot tags

Godot Unity Godot Help Programming Godot 4.X GUI GDScript 3D 2D Physics CSharp Godot 3.X VR XR Projects C++