Available toolchain options (by toolchain)

(see also eb --avail-toolchain-opts <tcname> )

ClangGCC - CrayCCE - CrayGNU - CrayIntel - CrayPGI - FCC - Fujitsu - GCC - GCCcore - GNU - NVHPC - PGI - cgmpich - cgmpolf - cgmvapich2 - cgmvolf - cgompi - cgoolf - ffmpi - foss - fosscuda - gcccuda - gfbf - gimkl - gimpi - gimpic - giolf - giolfc - gmacml - gmkl - gmklc - gmpich2 - gmpich - gmpit - gmpolf - gmvapich2 - gmvolf - goalf - gobff - goblf - gofbf - golf - golfc - gomkl - gomklc - gompi - gompic - goolf - goolfc - gpsmpi - gpsolf - gqacml - gsmpi - gsolf - iccifort - iccifortcuda - ictce - iibff - iimkl - iimklc - iimpi - iimpic - iiqmpi - impich - impmkl - intel-compilers - intel-para - intel - intelcuda - iomkl - iomklc - iompi - iompic - ipsmpi - iqacml - ismkl - nvompi - nvompic - nvpsmpi - nvpsmpic - pmkl - pomkl - pompi - system - xlcxlf - xlmpich2 - xlmpich - xlmvapich2 - xlompi

Available options for ClangGCC toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for CrayCCE toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
dynamic	Generate dynamically linked executable	True
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
mpich-mt	Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions.	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	False
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	True
veryloose	Very loose precision	False

Available options for CrayGNU toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
dynamic	Generate dynamically linked executable	True
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
mpich-mt	Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions.	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	False
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	True
veryloose	Very loose precision	False

Available options for CrayIntel toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
dynamic	Generate dynamically linked executable	True
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
mpich-mt	Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions.	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	False
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	True
veryloose	Very loose precision	False

Available options for CrayPGI toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
dynamic	Generate dynamically linked executable	True
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
mpich-mt	Directs the driver to link in an alternate version of the Cray-MPICH library which provides fine-grained multi-threading support to applications that perform MPI operations within threaded regions.	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	False
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	True
veryloose	Very loose precision	False

Available options for FCC toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for Fujitsu toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for GCC toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for GCCcore toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for GNU toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for NVHPC toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for PGI toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgmpich toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgmpolf toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgmvapich2 toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgmvolf toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgompi toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for cgoolf toolchain

option	description	default
32bit	Compile 32bit target	False
basic-block-vectorize	Basic block vectorization	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop-vectorize	Loop vectorization	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for ffmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for foss toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for fosscuda toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gcccuda toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gfbf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gimkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gimpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gimpic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for giolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for giolfc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmacml toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmklc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmpich2 toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmpich toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmpit toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmpolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmvapich2 toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gmvolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for goalf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gobff toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for goblf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gofbf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for golf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for golfc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gomkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gomklc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gompi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gompic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for goolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for goolfc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gpsmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gpsolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gqacml toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gsmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for gsolf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
f2c	Generate code compatible with f2c and f77	False
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loop	Automatic loop parallellisation	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
lto	Enable Link Time Optimization	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iccifort toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iccifortcuda toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for ictce toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iibff toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iimkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iimklc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iimpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iimpic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iiqmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for impich toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for impmkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for intel-compilers toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for intel-para toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for intel toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for intelcuda toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iomkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iomklc toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iompi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
oneapi	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iompic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for ipsmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for iqacml toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for ismkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
intel-static	Link Intel provided libraries statically	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
no-icc	Don’t set Intel specific macros	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for nvompi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for nvompic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for nvpsmpi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for nvpsmpic toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for pmkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for pomkl toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for pompi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for system toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for xlcxlf toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ibm-static	Link IBM XL provided libraries statically	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for xlmpich2 toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ibm-static	Link IBM XL provided libraries statically	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for xlmpich toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ibm-static	Link IBM XL provided libraries statically	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for xlmvapich2 toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ibm-static	Link IBM XL provided libraries statically	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False

Available options for xlompi toolchain

option	description	default
32bit	Compile 32bit target	False
cciscxx	Use CC as CXX	False
cstd	Specify C standard	None
debug	Enable debug	False
defaultopt	Default compiler optimizations	False
defaultprec	Default precision	False
error-unknown-option	Error instead of warning for unknown options	False
extra_cflags	Specify extra CFLAGS options.	None
extra_cxxflags	Specify extra CXXFLAGS options.	None
extra_f90flags	Specify extra F90FLAGS options.	None
extra_fcflags	Specify extra FCFLAGS options.	None
extra_fflags	Specify extra FFLAGS options.	None
i8	Integers are 8 byte integers	False
ibm-static	Link IBM XL provided libraries statically	False
ieee	Adhere to IEEE-754 rules	False
loose	Loose precision	False
lowopt	Low compiler optimizations	False
noopt	Disable compiler optimizations	False
openmp	Enable OpenMP	False
opt	High compiler optimizations	False
optarch	Enable architecture optimizations	True
packed-linker-options	Pack the linker options as comma separated list	False
pic	Use PIC	False
precise	High precision	False
r8	Real is 8 byte real	False
rpath	Use RPATH wrappers when –rpath is enabled in EasyBuild configuration	True
shared	Build shared library	False
static	Build static library	False
strict	Strict (highest) precision	False
unroll	Unroll loops	False
usempi	Use MPI compiler as default compiler	False
vectorize	Enable compiler auto-vectorization, default except for noopt and lowopt	None
verbose	Verbose output	False
veryloose	Very loose precision	False