# General
`make target ARCH=arch [COMP=compiler] [COMPCXX=cxx]`
## Targets
```
help > Display architecture details
profile-build > standard build with profile-guided optimization
build > skip profile-guided optimization
net > Download the default nnue net
strip > Strip executable
install > Install executable
clean > Clean up
```
## Archs
```
x86-64-vnni512 > x86 64-bit with vnni 512bit support
x86-64-vnni256 > x86 64-bit with vnni 512bit support, limit operands to 256bit wide
x86-64-avx512 > x86 64-bit with avx512 support
x86-64-avxvnni > x86 64-bit with vnni 256bit support
x86-64-bmi2 > x86 64-bit with bmi2 support
x86-64-avx2 > x86 64-bit with avx2 support
x86-64-sse41-popcnt > x86 64-bit with sse41 and popcnt support
x86-64-modern > common modern CPU, currently x86-64-sse41-popcnt
x86-64-ssse3 > x86 64-bit with ssse3 support
x86-64-sse3-popcnt > x86 64-bit with sse3 and popcnt support
x86-64 > x86 64-bit generic (with sse2 support)
x86-32-sse41-popcnt > x86 32-bit with sse41 and popcnt support
x86-32-sse2 > x86 32-bit with sse2 support
x86-32 > x86 32-bit generic (with mmx and sse support)
ppc-64 > PPC 64-bit
ppc-32 > PPC 32-bit
armv7 > ARMv7 32-bit
armv7-neon > ARMv7 32-bit with popcnt and neon
armv8 > ARMv8 64-bit with popcnt and neon
armv8-dotprod > ARMv8 64-bit with popcnt, neon and dot product support
e2k > Elbrus 2000
apple-silicon > Apple silicon ARM64
general-64 > unspecified 64-bit
general-32 > unspecified 32-bit
riscv64 > RISC-V 64-bit
```
## Compilers
```
gcc > Gnu compiler (default)
mingw > Gnu compiler with MinGW under Windows
clang > LLVM Clang compiler
icc > Intel compiler
ndk > Google NDK to cross-compile for Android
```
## Simple examples
If you don't know what to do, you likely want to run:
Fast compile for most common modern CPUs
```bash
make -j build ARCH=x86-64-modern
```
Slow compile for 64-bit systems
```bash
make -j build ARCH=x86-64
```
Slow compile for 32-bit systems
```bash
make -j build ARCH=x86-32
```
## Advanced examples
For experienced users looking for performance:
```bash
make -j profile-build ARCH=x86-64-bmi2
```
```bash
make -j profile-build ARCH=x86-64-bmi2 COMP=gcc COMPCXX=g++-9.0
```
```bash
make -j build ARCH=x86-64-ssse3 COMP=clang
```
_See also: [How to lower compilation time](#lower-compilation-time) and [How to optimize for your CPU](#optimize-for-your-cpu)._
---
# Linux
On Unix-like systems, it should be easy to compile Stockfish directly from the source code with the included Makefile in the folder `src`.
In general it is recommended to run `make help` to see a list of make targets with corresponding descriptions.
```bash
cd src
make help
make -j build ARCH=x86-64-modern
```
---
# Windows
## About MSYS2 & MinGW-w64
MSYS2 is a software distribution and building platform for Windows. It provides a Unix-like environment, a command line interface, and a software repository, making it easy to install software on Windows or build software on Windows with either the GCC compiler or the Clang/LLVM compiler and using the Microsoft Visual C++ Runtime (mvscrt, shipped with all Windows versions) or the newer Microsoft Universal C Runtime (ucrt, shipped by default starting with Windows 10).
MSYS2 consists of several subsystems, `msys2`, `mingw32`, and `mingw64`:
* The `mingw32` and `mingw64` subsystems are native Windows applications that use either the mvscrt or the ucrt.
* The `msys2` subsystem provides an emulated mostly-POSIX-compliant environment based on Cygwin.
Each subsystem has an associated "terminal/shell", which is essentially a set of environment variables that allow the subsystems to co-operate properly:
* `MSYS2 MinGW x64`, to build Windows-native 64-bit applications with GCC compiler using mvscrt.
* `MSYS2 MinGW x86`, to build Windows-native 32-bit applications using GCC compiler using mvscrt.
* `MSYS2 MSYS`, to build POSIX applications using the Cygwin compatibility layer.
* `MSYS2 MinGW UCRT x64`, to build Windows-native 64-bit applications with GCC compiler using ucrt.
* `MSYS2 MinGW Clang x86`, to build Windows-native 64-bit applications with Clang/LLVM compiler using ucrt.
Refer to the [MSYS2 homepage](https://www.msys2.org/) for more detailed information on the MSYS2 subsystems and terminals/shells.
## Installing MSYS2
### Install MSYS2 with Chocolatey
[Chocolatey](https://chocolatey.org/) is a command line package manager for Windows, always run Chocolatey commands in a powershell/cmd with administrator rights (right click on `Start` menu, select `Windows Powershell (Admin)` or `Command Prompt (Admin)`):
1. Open a powershell (admin) (not a cmd) and copy the official [Chocolatey install command](https://chocolatey.org/install) to install Chocolatey
2. In a powershell/cmd (admin) execute the command `choco install msys2 -y`
As alternative write this text file `install_choco_msys2.cmd`, right click and select `Run as administrator`:
Click to view
```cmd
@echo off
::https://chocolatey.org/install
::https://chocolatey.org/courses/installation/installing?method=installing-chocolatey?quiz=true
::download and run install.ps1
"%SystemRoot%\System32\WindowsPowerShell\v1.0\powershell.exe" -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin"
::install msys2
choco install msys2 -y
```
64-bit Windows
```bash
#!/bin/bash
# makefish.sh
# install packages if not already installed
pacman -S --noconfirm --needed unzip make mingw-w64-x86_64-gcc
# download the Stockfish source code
wget -O master.zip https://github.com/official-stockfish/Stockfish/archive/master.zip
unzip -o master.zip
cd Stockfish-master/src
file_nnue=$(grep 'define.*EvalFileDefaultName' evaluate.h | grep -Ewo 'nn-[a-z0-9]{12}.nnue')
ls *.nnue | grep -v ${file_nnue} | xargs -d '\n' -r rm --
# find the CPU architecture
gcc_enabled=$(g++ -Q -march=native --help=target | grep "\[enabled\]")
gcc_arch=$(g++ -Q -march=native --help=target | grep "march")
if [[ "${gcc_enabled}" =~ "-mavx512vnni " && "${gcc_enabled}" =~ "-mavx512dq " && "${gcc_enabled}" =~ "-mavx512f " && "${gcc_enabled}" =~ "-mavx512bw " && "${gcc_enabled}" =~ "-mavx512vl " ]] ; then
arch_cpu="x86-64-vnni256"
elif [[ "${gcc_enabled}" =~ "-mavx512f " && "${gcc_enabled}" =~ "-mavx512bw " ]] ; then
arch_cpu="x86-64-avx512"
elif [[ "${gcc_enabled}" =~ "-mbmi2 " && ! "${gcc_arch}" =~ "znver1" && ! "${gcc_arch}" =~ "znver2" ]] ; then
arch_cpu="x86-64-bmi2"
elif [[ "${gcc_enabled}" =~ "-mavx2 " ]] ; then
arch_cpu="x86-64-avx2"
elif [[ "${gcc_enabled}" =~ "-mpopcnt " && "${gcc_enabled}" =~ "-msse4.1 " ]] ; then
arch_cpu="x86-64-modern"
elif [[ "${gcc_enabled}" =~ "-mssse3 " ]] ; then
arch_cpu="x86-64-ssse3"
elif [[ "${gcc_enabled}" =~ "-mpopcnt " && "${gcc_enabled}" =~ "-msse3 " ]] ; then
arch_cpu="x86-64-sse3-popcnt"
else
arch_cpu="x86-64"
fi
# build the fastest Stockfish executable
make -j profile-build ARCH=${arch_cpu} COMP=mingw
make strip
mv stockfish.exe ../../stockfish_${arch_cpu}.exe
make clean
cd
```
32-bit Windows
```bash
#!/bin/bash
# makefish.sh
# install packages if not already installed
pacman -S --noconfirm --needed unzip make mingw-w64-i686-gcc
# download the Stockfish source code
wget -O master.zip https://github.com/official-stockfish/Stockfish/archive/master.zip
unzip -o master.zip
cd Stockfish-master/src
file_nnue=$(grep 'define.*EvalFileDefaultName' evaluate.h | grep -Ewo 'nn-[a-z0-9]{12}.nnue')
ls *.nnue | grep -v ${file_nnue} | xargs -d '\n' -r rm --
# find the CPU architecture
gcc_enabled=$(g++ -Q -march=native --help=target | grep "\[enabled\]")
gcc_arch=$(g++ -Q -march=native --help=target | grep "march")
if [[ "${gcc_enabled}" =~ "-mpopcnt " && "${gcc_enabled}" =~ "-msse4.1 " ]] ; then
arch_cpu="x86-32-sse41-popcnt"
elif [[ "${gcc_enabled}" =~ "--msse2 " ]] ; then
arch_cpu="x86-32-sse2"
else
arch_cpu="x86-32"
fi
# build the fastest Stockfish executable
make -j profile-build ARCH=${arch_cpu} COMP=mingw
make strip
mv stockfish.exe ../../stockfish_${arch_cpu}.exe
make clean
cd
```
64-bit Windows
```bash
#!/bin/bash
# makefish.sh
# install packages if not already installed
pacman -S --noconfirm --needed unzip make mingw-w64-clang-x86_64-clang
# download the Stockfish source code
wget -O master.zip https://github.com/official-stockfish/Stockfish/archive/master.zip
unzip -o master.zip
cd Stockfish-master/src
file_nnue=$(grep 'define.*EvalFileDefaultName' evaluate.h | grep -Ewo 'nn-[a-z0-9]{12}.nnue')
ls *.nnue | grep -v ${file_nnue} | xargs -d '\n' -r rm --
# write here your CPU architecture
arch_cpu="x86-64-modern"
# build the fastest Stockfish executable
make -j profile-build ARCH=${arch_cpu} COMP=clang
make strip COMP=clang
mv stockfish.exe ../../stockfish_${arch_cpu}.exe
make clean COMP=clang
cd
```
Click to view
```bash
#!/bin/bash
# makefish.sh
# set PATH to use GCC 8.1.0
if [ -d "/mingw64-810/bin" ] ; then
PATH="/mingw64-810/bin:${PATH}"
else
echo "folder error"
exit 1
fi
# download the Stockfish source code
wget -O master.zip https://github.com/official-stockfish/Stockfish/archive/master.zip
unzip master.zip
cd Stockfish-master/src
# find the CPU architecture
# CPU without popcnt and bmi2 instructions (e.g. older than Intel Sandy Bridge)
arch_cpu=x86-64
# CPU with bmi2 instruction (e.g. Intel Haswell or newer)
if [ "$(g++ -Q -march=native --help=target | grep mbmi2 | grep enabled)" ] ; then
# CPU AMD zen
if [ "$(g++ -Q -march=native --help=target | grep march | grep 'znver[12]')" ] ; then
arch_cpu=x86-64-avx2
else
arch_cpu=x86-64-bmi2
fi
# CPU with popcnt instruction (e.g. Intel Sandy Bridge)
elif [ "$(g++ -Q -march=native --help=target | grep mpopcnt | grep enabled)" ] ; then
arch_cpu=x86-64-modern
fi
# build the Stockfish executable
make profile-build ARCH=${arch_cpu} COMP=mingw
make strip
mv stockfish.exe ../../stockfish_${arch_cpu}.exe
make clean
cd
```
Click to view
```bash
#!/bin/bash
# functions to build Stockfish
_build_sf () {
make build ARCH=x86-64$1 COMP=mingw -j
make strip COMP=mingw
mv stockfish.exe ../../stockfish-x64${1}.exe
make clean COMP=mingw
}
_build_sf_pgo () {
make profile-build ARCH=x86-64$1 COMP=mingw PGOBENCH="wine ./stockfish.exe bench" -j
make strip COMP=mingw
mv stockfish.exe ../../stockfish-x64${1}-pgo.exe
make clean COMP=mingw
}
# full-upgrade and install required packages
sudo apt update && sudo apt full-upgrade -y && sudo apt autoremove -y && sudo apt clean
sudo apt install -y \
make \
mingw-w64 \
git \
wine64 \
binutils
# clone Stockfish source code
git clone --single-branch --branch master https://github.com/official-stockfish/Stockfish.git
cd Stockfish/src
# build Stockfish executables
# to speedup the building process you can keep only the section fitting your CPU architecture
# build the binary for CPUs without popcnt and bmi2 instructions (e.g. older than Intel Sandy Bridge)
_build_sf_pgo
# build the binary for CPU with popcnt instruction (e.g. Intel Sandy Bridge)
if [ "$(x86_64-w64-mingw32-c++-posix -Q -march=native --help=target | grep mpopcnt | grep enabled)" ] ; then
_build_sf_pgo -modern
else
_build_sf -modern
fi
# build the binary for CPU with bmi2 instruction (e.g. Intel Haswell or newer)
if [ "$(x86_64-w64-mingw32-c++-posix -Q -march=native --help=target | grep mbmi2 | grep enabled)" ] ; then
_build_sf_pgo -bmi2
else
_build_sf -bmi2
fi
```
Click to view
```bash
# Use a clean Ubuntu to cross compile
# a static build for armv8 and armv7 on Linux/Android
# one time configuration
sudo apt update && sudo apt install -y make git
sudo snap install zig --classic --edge
sudo apt install -y qemu-user
# armv8 static build with musl libc
git clone https://github.com/official-stockfish/Stockfish.git
cd Stockfish/src
make -j build ARCH=armv8 COMP=gcc CXX="zig c++ -target aarch64-linux-musl"
# test: qemu's magic at work
qemu-aarch64 stockfish compiler
qemu-aarch64 stockfish bench
# armv7 static build with musl libc
# comment out "-latomic" flag in Makefile
make clean
make -j build ARCH=armv7 COMP=gcc CXX="zig c++ -target arm-linux-musleabihf"
# test: qemu's magic at work
qemu-arm stockfish compiler
qemu-arm stockfish bench
```
Click to view
```bash
# Use msys2 to cross compile
# a static build for armv8 and armv7 on Linux/Android
# one time configuration
pacman -S --noconfirm --needed git make unzip
wget https://ziglang.org/builds/zig-windows-x86_64-0.10.0-dev.2220+802f22073.zip
unzip zig-windows-x86_64-0.10.0-dev.2220+802f22073.zip
PATH=$(pwd)/zig-windows-x86_64-0.10.0-dev.2220+802f22073:${PATH}
# armv8 static build with musl libc
git clone https://github.com/official-stockfish/Stockfish.git
cd Stockfish/src
make -j build ARCH=armv8 COMP=gcc CXX="zig c++ -target aarch64-linux-musl"
mv stockfish.exe stockfish_armv8
```