Using software

To get your work done on the cluster, the software you require must be available on the cluster. Much common software is already installed, but if you need some special program it has to be installed. As a user you have the possibility to install software in your home directory. If you need support on installation please send a support request.

To organise all the software installed on the cluster we use the Environment Module System. It allows you to list available software and dynamically load software modules in your command line session. The command used is simply called module, see man module for detailed usage information.

We offer a module system with a lot of pre-installed software. If your software isn't available, we offer several compilers for compiling the software yourself. Many languages also have systems in place for user local installations, see Python, Perl below. If it's a common software, we can do a system installation.


A module system is used to allow the user to specify which application/software he or she wants to use on the cluster. The modules package allows dynamical modification of a user's environment (PATH etc.), which makes the program available from the shell. Modules can be loaded and unloaded dynamically.

The module command

The module command (or the ml shortcut) controls how to change the software you have available. For the complete manual, please use

man module

To see the available applications/software installed use:

module avail
ml avail

To see what modules are loaded at the moment use:

module list

To load/unload a modulefile making a certain application/compiler available or not use:

module load <modulename>
module add <modulename>
module unload <modulename>
module rm <modulename>
module purge    # Unloads all currently loaded modules`
ml <modulename>
ml <modulename>
ml unload <modulename>
ml rm <modulename>
ml purge

To see what a module does, use

module show <modulename>
ml show <modulename>

This will display what environment variables the module sets or modifies.


A toolchain is a set of modules that makes up the necessary components to build most software.

Most commercial (closed source) tools, do not require a toolchain, e.g. Mathematica, MATLAB. These can be loaded directly;

module load MATLAB

while most other tool requiring picking a toolchain first, e.g:

module load intel
module load Python

We install most software under the intel toolchain, and secondarily foss. You can see all the available compilers and toolchains by calling

module avail

Looking for available modules

To search for all available software independently of the particular toolchain you can use the module spider <software_name> command. If you are a new user on our system, please take the time and search for the particular software you want to use in your research. Chances are that it is installed an ready to go!

For example, if you want to use Python/Numpy/Scipy have a look at,

module spider scipy

You can also view the modules for your currently loaded toolchain (including other toolchains) by running:

module avail

However, when you first log in to our systems this won't show you most software, since no toolchain is loaded by default. Instead, you have to pick a toolchain, in order for module avail to show more modules. For example

module load intel
module avail

will show all modules compiled under the intel toolchain. Please note that some software might only be available in some toolchains, including specific versions of a toolchain, e.g.

module load foss/2016b
module avail

Finding the right toolchain for a module

Searching for a specific version gives you additional information about the module, e.g:

module spider Python/2.7.12

      Python: Python/2.7.12
          Python is a programming language that lets you work more quickly and
          integrate your systems more effectively. - Homepage:

         Other possible modules matches:

        This module can only be loaded through the following modules:

          GCC/5.4.0-2.26  OpenMPI/1.10.3
          icc/2016.3.210-GCC-5.4.0-2.26  impi/
          ifort/2016.3.210-GCC-5.4.0-2.26  impi/

          Python is a programming language that lets you work more quickly and integrate your systems
           more effectively. - Homepage:

      To find other possible module matches do:
          module -r spider '.*Python/2.7.12.*'

Here, it tells us that that we can do either

module load GCC/5.4.0-2.26  OpenMPI/1.10.3
module load Python/2.7.12


module load icc/2016.3.210-GCC-5.4.0-2.26  impi/
module load Python/2.7.12

or, as GCC + OpenMPI are part of the foss/2016b, and icc/ifort + impi are part of the intel/2016b toolchain, we could also do

module load foss/2016b
module load Python/2.7.12


module load intel/2016b
module load Python/2.7.12


Modern compilers and development tools are available through the module system. It is highly recommended to always load a toolchain, even if you are just using GCC, as the system compiler is very dated.

Intel compiler suite

The intel compiler toolchain includes:

  • icpc - C++ compiler
  • icc - C compiler
  • ifort - FORTRAN
  • imkl - Intel Math Kernel Library (BLAS, LAPACK, FFT, etc.)
  • impi - Intel MPI

Exactly how to instruct a build system to use these compilers varies from software to software.

In addition some tools are also available:

  • VTune - Visual profiling tool
  • Advisor - Code optimisation tool
  • Inspector - Memory and thread error detection tool

all of which you can find in the menu when logging in with over remote graphics.


The foss compiler toolchain includes:

  • g++ - C++ compiler
  • gcc - C compiler
  • gfortran - Fortran compiler
  • OpenBLAS - Efficient open source BLAS and LAPACK library
  • OpenMPI

Using a compiler with a build system

Common build systems (e.g. CMake) use cc, c++, or f95 for locating a compiler by default. These will point towards the very old system compilers.

With CMake, you will want to do

module load foss CMake
CC=gcc CXX=g++ FC=gfortran cmake path/to/src


module load intel CMake
CC=icc CXX=icpc FC=ifort cmake path/to/src

The variables CC, CXX, FC, are standard names that will work with other build systems as well (such as autoconf) However, some software relies on custom made build tools which makes things more difficult and will require custom solutions.

Additional libraries

We install many libraries which can greatly simplify Loading modules will set the CPATH and LIBRARY_PATH environment variables, which are usually picked up popular build systems. However, many build systems will fail to respect these general rules, and may require some tweaking to build correctly.

Every library is not installed for every toolchain version. If you are missing some dependency for your software, you can request an installation, or install it locally.

Building CUDA code

If you compile code for GPU:s using for example nvcc you must be aware that you need to make sure you not only build for the type of GPU on the system you are compiling with, but also other parts of the resource.

To do this please add the flags -gencode=arch=compute_XX,code=sm_XX for each compute capability XX you want to support to the nvcc commands.

  • For Vera, please replace XX with/add 61 (for frontend machines), 70 (for V100:s) and 75 (for T4:s)
  • For Alvis, please replace XX with/add 70 (for V100:s) and 75 (for T4:s)

See the NVIDIA page for more information.

Allinea/ARM Forge

Allinea Forge (named recently changed to ARM Forge) is a graphical tool to debug and profile parallel codes (MPI, OpenMP, CUDA). You can find this tool in the menu when logging in over remote graphics.