MATLAB, 4 bytes

ispc

From the documentation:

tf = ispc returns logical 1 (true) if the version of MATLAB® software is for the Microsoft® Windows® platform. Otherwise, it returns logical 0 (false).

There are also the functions ismac and isunix. I'll leave it to the reader to figure out what those functions do. Mego kindly asked for diagrams explaining ismac and isunix so I've tried to illustrate it here:

It was not asked for a diagram of ispc but I can reveal that the behaviour is pretty similar, except substitute OSX and Unix with Windows.

Second approach:

If someone is not satisfied with this answer, I'll provide a second approach with getenv using 19 bytes that should be bullet proof, unless there's another operating system starting with W:

getenv('OS')(1)==87

getenv 'name' searches the underlying operating system environment list for text of the form name=value, where name is the input character vector. If found, MATLAB® returns the character vector value. If the specified name cannot be found, an empty matrix is returned.

Python 2.7.10, 24 bytes

import os
0/('['>os.sep)

Thanks to FlipTack for 3 bytes

This program takes advantage of the fact that Windows is the only OS to use \ as a path separator. Normally this is frustrating and bad, but for once it is actually an advantage. On Windows, '['>os.sep is false, and thus 0/0 is computed, causing a ZeroDivisionError and exiting with a non-zero exit code. On non-Windows platforms, '['>os.sep is true, making the expression 0/1, which does nothing, and the program exits with exit code 0.

PHP, 22 bytes

`<?=PATH_SEPARATOR>":";`  

prints 1 if the path separator is semicolon (colon or empty for all other OSs except for DOS and OS/2), else nothing.

also 22 bytes, but not that safe:

<?=strpos(__FILE__,92);

prints a positive integer if the file path contains a backslash; else nothing.
A safe alternative with 27 bytes: <?=DIRECTORY_SEPARATOR>"/"; prints 1 or nothing.

Strange: <?=__FILE__[1]==":"; (20 bytes) should be, not safe either, but ok. But although __FILE__ pretends to be a string (I tried var_dump and gettype), indexing it throws an error (at least in online testers).
I´ll try it on my server tomorrow. Will someone test it on Windows?

27 bytes: <?=stripos(PHP_OS,win)===0;
tests if predefined PHP_OS constant starts with win (case insensitive; Windows,WIN32,WINNT, but not CYGWIN or Darwin); prints 1 for Windows, else nothing.

17/18 bytes:

<?=strlen("
")-1;

prints 1 if it was stored with Windows linebreak (also on DOS, OS/2 and Atari TOS - although I doubt that anyone ever compiled PHP for TOS), else 0.

You could also check the constant PHP_EOL.

more options:

PHP_SHLIB_SUFFIX is dll on Windows, but not necessarily only there.
php_uname() returns info on the operating system and more; starts with Windows for Windows.
$_SERVER['HTTP_USER_AGENT'] will contain Windows when called in a browser on Windows.
<?=defined(PHP_WINDOWS_VERSION_BUILD); (38 bytes) works in PHP>=5.3

conclusion

The only failsafe way to tell if it´s really Windows, not anything looking like it, seems to be a check on the OS name. For PHP: php_os() may be disabled for security reasons; but PHP_OS will probably always contain the desired info.

Vim, 2 bytes

<C-a>1

On Windows, <C-a> (ctrl+a) is mapped by default to Select All. If you type a 1 in select mode in Windows, it replaces the selection with what you typed (1) leaving a 1 in the buffer.

On other operating systems, <C-a> by default is mapped to Increment number. Because there's no number to increment, it's a no-op, and then the 1 increases the count but in terms of the buffer is a no-op.

1 is truthy in Vim, and an empty string is falsy

C, 44 43 38 36 bytes

Thanks to @Downgoat for a byte! ^{crossed out 44 is still regular 44}
Thanks to @Neil for two bytes!

f(){return
#ifdef WIN32
!
#endif
0;}

x86 Assembly, 3 bytes (Inspired by Runemoro's answer)

40 CD 80

Or

inc eax
int 0x80

Description

First of all, we'll set eax to 1 (the system call number for exit(int val) for Linux, FreeBSD and OSX). Then, we'll call the interrupt gate 0x80 which is the system call gate for Linux, FreeBSD and OSX. That would cause the program to exit with status of ebx which is 0 (false).

On Windows int 0x80 is an invalid gate (It uses 2e as a syscall gate) and would crash the program, causing it to end with a positive exit code (true).

References and further reading

• FreeBSD - System Calls: Information about system calls in FreeBSD.
• System calls in the Linux kernel. Part 2.: A great article about Linux's system calls.
• Linux Syscall Reference: a system call numbers reference for Linux.
• Windows Syscall Shellcode : An article about directly calling system calls in windows from assembly.
• Making system calls from Assembly in Mac OS X: An article about system calls on OSX.

Mathematica, 28 bytes

$OperatingSystem=="Windows"&

Java 8, 33 bytes

Special thanks to Olivier Grégoire for suggesting separatorChar, and Kritixi Lithos for -1 byte!

This is a lambda expression which returns a boolean. This can be assigned to Supplier<Boolean> f = ...; and called with f.get().

()->java.io.File.separatorChar>90

Try it online! - the server isn't windows, so this prints false. However, in my windows machine, the same code prints true.

What this code does is get the System's file seperator, and check whether its codepoint is larger than the character [. This true for Windows, as it uses \ as the seperator - but every other OS uses /, which has a lower code in the ASCII table.

J, 7 bytes

6=9!:12

This is a verb (similar to a function) that uses the builtin foreign conjunction 9!:12 to acquire the system type where 5 is Unix and 6 is Windows32.

Befunge-98, 7 bytes

6y2%!.@

Try it online!

This works by querying the system path separator, which is \ on Windows and / on other operating systems.

6y            System information query: #6 returns the path separator.
  2%          Test the low bit - this will be 1 for '/' and 0 for '\'.
    !         Not the value, so it becomes 0 for '/' and 1 for '\'.   
     .@       Output the result and exit.

julia, 10 bytes

is_windows

A function that returns true for windows

x86 machine code, 9 bytes

40 39 04 24 75 02 CD 80 C3

Compiled from:

inc eax        ; set eax to 1
cmp [esp], eax ; check if [esp] == 1 (linux)
jne windows    ; jump over "int 0x80" if on windows
int 0x80       ; exit with exit code 0 (ebx)
windows:
ret            ; exit with exit code 1 (eax)

Batch, 50 bytes

@if %OS%==Windows_NT if not exist Z:\bin\sh echo 1

Edit: Fixed to ignore DOS instead of claiming that it's Windows.

The only other way I know of running Batch outside of Windows is to use WINE which by default will map Z: to /. Therefore if Z:\bin\sh exists, chances are that it's /bin/sh, so not MS Windows.

I don't know what WINE sets %OS% to, but if it's not Windows_NT then I could save 23 bytes.

R, 15 bytes

.Platform$O>"v"

Thanks to plannapus for the suggestion to use partial matching for list element extraction.

.Platform is a list with some details of the platform under which R was built. There is an element OS.type (the only element with name starting with "O") which is character string, giving the Operating System (family) of the computer. One of "unix" or "windows".

So "unix" is less then "v", but "windows" is greater then "v". Other valid 15 bytes answers are

.Platform$O>"V"
.Platform$O>"w"
.Platform$O>"W"

R is being developed for the Unix-like, Windows and Mac families of operating systems. Other OS families are not supported.

Perl 6,  19  18 bytes

put $*DISTRO.is-win

put ?($*CWD~~/\\/)

Both output True␤ or False␤ depending on the system it is run on.

Dyalog APL, 21 bytes

'W'=⊃⊃⎕WG'APLVersion'

⎕WG'APLVersion' system function Windows Get property APL Version

⊃ pick the first element (Target Environment)

⊃ pick the first letter (Windows/Linux/AIX/Solaris)

'W'= W equal to that letter?

C#, 61 bytes

bool f(){return(int)System.Environment.OSVersion.Platform<4;}

Or a full program at 83 bytes:

class P{static int Main(){return(int)System.Environment.OSVersion.Platform<4?1:0;}}

Various Windows variants use enum values 0 to 3 in the Microsoft .NET implementation. 4 is Unix, 5 is Xbox (which I won't consider "Windows"), 6 is MacOSX. Mono uses the same values, adding 128 for Unix/Linux in earlier versions.

Therefore, anything < 4 is Windows, and everything else is not Windows.

QBasic, 31 bytes

?INSTR(ENVIRON$("COMSPEC"),"W")

Prints non-zero under Windows, 0 under everything else.

COMSPEC is an environment variable unique to Microsoft OSs. It points to the command interpreter, typically command.com or cmd.exe. Under Windows, the command interpreter sits somewhere in the Windows directory; under MS-DOS, it sits in the DOS directory or on the root of the disk, and under any other OS, it doesn't exist.

By checking to see if the value of COMSPEC contains a "W", we can tell the difference between Windows and not-Windows.

JavaScript, 42 30 26 bytes

console.log((
//Begin
_=>navigator.oscpu[0]=='W'
//End
)())

Only Windows has an oscpu value starting with W, according to this post. Also, tested with Firefox. Chrome doesn't have the oscpu property.

Edits

1. Saved 12 bytes thanks to Neil.
2. Saved another four bytes

Excel VBA, 41 40 Bytes

Immediate windows function that returns if the true if the name of the operating system starts with W. This will only ever be true on Windows based systems as Excel VBA is restricted to Windows and OSX.

?Left(Application.OperatingSystem,1)="W"

-1 Thanks to Neil for using Left(...,1) over Mid(...,1,1)

Node.js, 27 bytes

_=>require('path').sep!='/'

PHP 17 Bytes

The following will output 1 if windows and nothing if anything else. Ignoring notices of string convertion.

<?=PHP_OS==WINNT;

Try online Online tests for linux because the sandbox is linux for PoC.

Perl, 12 bytes

print$^O=~/W/

^O should be replaced by a literal Control-O.

Outputs 1 on windows, nothing on another OS.

Note that I'm not using say as it adds a trailing newline, which is truthy in Perl.

-1 bytes thanks to ais523.

tcl, 38 bytes

 expr [lsearch $tcl_platform windows]>0

Java 8, 49 bytes

()->System.getenv().get("OS").contains("Windows")

Longer than the other Java answer, but takes a different approach.

This lambda fits in a Supplier<Boolean> and can be tested with the following program:

public class DetectMSWindows {

  public static void main(String[] args) {
    System.out.println(f(() -> System.getenv().get("OS").contains("Windows")));
  }

  private static boolean f(java.util.function.Supplier<Boolean> s) {
    return s.get();
  }

}

8th, 11 characters

 
os 1- not .
 

Prints true on Windows, false on Linux and macOS. Other platforms supported by 8th are Android, iOS and Raspberry Pi, but I am not able to test on them.

Ungolfed version (with comments)

 
G:os  \ Return a number n indicating the operating system 
      \ 0 for Linux
      \ 1 for Windows 
      \ 2 for macOS
      \ 3 for Android 
      \ 4 for iOS 
      \ 5 for Raspberry Pi
n:1-  \ Subtract 1
G:not \ If Windows --> true, otherwise --> false
.     \ Print result
 

FPC, 61 chars

begin{$ifdef win32}write('f');{$else}write('nf');{$endif}end;

Haskell, 39 31 bytes

import System.Info
f=os!!0=='m'

I check for the first letter output of "m", which should be "mingw" for windows. As far as I could tell, there is no other OS which starts with M. The information comes from https://github.com/ghc/ghc/blob/master/compiler/utils/Platform.hs

puts [string match windows $tcl_platform(platform)]

puts [string match W* $tcl_platform(os)]

assuming Windows is the only system the name begins on a W.

3rd attempt:

tcl, 26

puts [info exists env(OS)]

assuming Windows is the only system the OS environment variable is defined.

Racket, 26 17 bytes

Shameless plug for the TCL answer I saw that used the OS environment variable.

(and(getenv"OS"))

(Old answer)

Pretty straight forward. system-type with no argument returns a symbol indicating the system operating system type.

(eq?'windows(system-type))