Available toolchain options (by toolchain) {: #avail_toolchain_opts }

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

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

cgmpich

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`

cgmpolf

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`

cgmvapich2

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`

cgmvolf

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`

cgompi

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`

cgoolf

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`

ClangGCC

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`

CrayCCE

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`

CrayGNU

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`

CrayIntel

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`

CrayPGI

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`

FCC

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`

ffmpi

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`

foss

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 parallelisation	`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`

fosscuda

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 parallelisation	`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`

Fujitsu

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`

GCC

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 parallelisation	`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`

GCCcore

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 parallelisation	`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`

gcccuda

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 parallelisation	`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`

gfbf

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 parallelisation	`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`

gimkl

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 parallelisation	`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`

gimpi

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 parallelisation	`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`

gimpic

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 parallelisation	`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`

giolf

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 parallelisation	`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`

giolfc

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 parallelisation	`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`

gmacml

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 parallelisation	`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`

gmkl

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 parallelisation	`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`

gmklc

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 parallelisation	`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`

gmpflf

Available options for gmpflf 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 parallelisation	`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`

gmpich2

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 parallelisation	`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`

gmpich

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 parallelisation	`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`

gmpit

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 parallelisation	`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`

gmpolf

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 parallelisation	`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`

gmvapich2

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 parallelisation	`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`

gmvolf

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 parallelisation	`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`

GNU

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 parallelisation	`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`

goalf

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 parallelisation	`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`

gobff

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 parallelisation	`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`

goblf

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 parallelisation	`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`

gofbf

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 parallelisation	`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`

golf

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 parallelisation	`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`

golfc

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 parallelisation	`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`

gomkl

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 parallelisation	`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`

gomklc

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 parallelisation	`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`

gompi

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 parallelisation	`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`

gompic

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 parallelisation	`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`

goolf

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 parallelisation	`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`

goolfc

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 parallelisation	`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`

gpsmpi

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 parallelisation	`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`

gpsolf

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 parallelisation	`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`

gqacml

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 parallelisation	`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`

gsmpi

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 parallelisation	`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`

gsolf

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 parallelisation	`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`

iccifort

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`

iccifortcuda

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`

ictce

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

ifbf

Available options for ifbf 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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iibff

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iimkl

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`
`oneapi`	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iimklc

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`
`oneapi`	Use oneAPI compilers icx/icpx/ifx instead of classic compilers	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iimpi

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iimpic

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`

iiqmpi

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`

impich

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`

impmkl

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`

intel-compilers

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

intel-para

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`

intel

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

intelcuda

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`

iofbf

Available options for iofbf 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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iomkl

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iomklc

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`

iompi

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	`None`
`oneapi_c_cxx`	Use oneAPI C/C++ compilers icx/icpx instead of classic Intel C/C++ compilers (auto-enabled for Intel compilers version 2022.2.0, or newer)	`None`
`oneapi_fortran`	Use oneAPI Fortran compiler ifx instead of classic Intel Fortran compiler (auto-enabled for Intel compilers version 2024.0.0, or newer)	`None`
`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`

iompic

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`

ipsmpi

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`

iqacml

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`

ismkl

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`

NVHPC

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`

nvofbf

Available options for nvofbf 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`

nvompi

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`

nvompic

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`

nvpsmpi

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`

nvpsmpic

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`

PGI

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`

pmkl

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`

pomkl

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`

pompi

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`

system

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`

xlcxlf

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`

xlmpich2

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`

xlmpich

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`

xlmvapich2

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`

xlompi

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`

Files

toolchain-opts.md

Latest commit

History

toolchain-opts.md

File metadata and controls

Available toolchain options (by toolchain) {: #avail_toolchain_opts }

cgmpich

Available options for cgmpich toolchain

cgmpolf

Available options for cgmpolf toolchain

cgmvapich2

Available options for cgmvapich2 toolchain

cgmvolf

Available options for cgmvolf toolchain

cgompi

Available options for cgompi toolchain

cgoolf

Available options for cgoolf toolchain

ClangGCC

Available options for ClangGCC toolchain

CrayCCE

Available options for CrayCCE toolchain

CrayGNU

Available options for CrayGNU toolchain

CrayIntel

Available options for CrayIntel toolchain

CrayPGI

Available options for CrayPGI toolchain

FCC

Available options for FCC toolchain

ffmpi

Available options for ffmpi toolchain

foss

Available options for foss toolchain

fosscuda

Available options for fosscuda toolchain

Fujitsu

Available options for Fujitsu toolchain

GCC

Available options for GCC toolchain

GCCcore

Available options for GCCcore toolchain

gcccuda

Available options for gcccuda toolchain

gfbf

Available options for gfbf toolchain

gimkl

Available options for gimkl toolchain

gimpi

Available options for gimpi toolchain

gimpic

Available options for gimpic toolchain

giolf

Available options for giolf toolchain

giolfc

Available options for giolfc toolchain

gmacml

Available options for gmacml toolchain

gmkl

Available options for gmkl toolchain

gmklc

Available options for gmklc toolchain

gmpflf

Available options for gmpflf toolchain

gmpich2

Available options for gmpich2 toolchain

gmpich

Available options for gmpich toolchain

gmpit

Available options for gmpit toolchain

gmpolf

Available options for gmpolf toolchain

gmvapich2

Available options for gmvapich2 toolchain

gmvolf

Available options for gmvolf toolchain

GNU

Available options for GNU toolchain

goalf