Software

Available software and how to use it

Modified

2026-04-30

The cluster provides software through environment modules (Lmod). Modules let you load specific software versions into your session without conflicts.

Module basics

# List all available modules
module avail

# Load a module
module load R/4.5.3

# See what you have loaded
module list

# Unload a module
module unload R

# Unload everything
module purge

Modules set up PATH, library paths, and other environment variables so the software “just works” when loaded.

Make it permanent

Add module load commands to your ~/.bashrc to load software automatically on login:

echo 'module load R/4.5.3' >> ~/.bashrc

Available software

R

R is managed via rig (R Installation Manager) and available as a module:

module avail R         # See available versions
module load R/4.5.3    # Load R

See R on the Cluster for details on package installation, parallelism, and workflows.

LaTeX / TeX Live

TeX Live is available as a module for PDF rendering (R Markdown, Quarto, standalone LaTeX):

module load texlive/2025    # Frozen historic version

For day-to-day use, most users prefer the lighter tinytex R package instead. See LaTeX / TeX Live for details on both options.

Python

We recommend using uv for Python environment management rather than a system-wide Python installation. See Python on the Cluster.

PLINK (genomics)

Both PLINK versions are available:

module load plink/1.9              # PLINK 1.9
module load spack/1.1.1            # Load spack modules first...
module load plink2/2.0.0-a.6.9    # ...then PLINK 2.0

The binaries are named plink and plink2 respectively, so both can be loaded at the same time if needed.

Note

PLINK 1.9 is available directly via module load plink/1.9. PLINK 2.0 is installed via Spack, so you need to load the spack module first to make it visible.

regenie (genomics)

regenie is a tool for whole-genome regression modelling of large genome-wide association studies (GWAS). It is installed via Spack:

module load spack/1.1.1    # Load Spack modules first
module load regenie         # Then load regenie

Or equivalently:

module load spack/1.1.1
spack load regenie

CUDA toolkit

The CUDA toolkit (nvcc, libraries, headers) is installed via Spack for GPU development. To see available versions:

spack find cuda

To load a specific version:

# Option 1: spack load (works without loading the spack module first)
spack load cuda@12.4.0

# Option 2: via environment modules
module load spack/1.1.1
module avail cuda            # See available versions
module load cuda/12.4.0

This gives you nvcc, CUDA headers, and libraries. The NVIDIA driver is already installed on the GPU node — you only need the toolkit for compiling CUDA code.

Note

You don’t need to load CUDA manually for Python (PyTorch) or R (torch) GPU work — both bundle their own CUDA runtime when installed with GPU support (see GPU Jobs). The CUDA spack module is only needed for compiling custom CUDA code (.cu files).

TabPFN (pre-trained tabular foundation model)

TabPFN is a pre-trained transformer that performs tabular classification and regression in a single forward pass. The (gated) model weights are pre-downloaded to a shared location so users don’t have to fetch them individually:

ls -l /srv/software/model-weights/tabpfn/

The TABPFN_MODEL_CACHE_DIR environment variable is set system-wide (via /etc/profile.d/tabpfn.sh for shell sessions and Renviron.site for R sessions), so the Python and R TabPFN packages should pick up the cached weights automatically. Verify it is set in your current session — from the shell:

echo $TABPFN_MODEL_CACHE_DIR
# /srv/software/model-weights/tabpfn/

…or from R:

Sys.getenv("TABPFN_MODEL_CACHE_DIR")
# [1] "/srv/software/model-weights/tabpfn/"

If the variable is empty in your context — for example inside a minimal container, a script that scrubs the environment, or a Slurm job submitted with --export=NONE — point it at the shared directory yourself.

In the shell:

export TABPFN_MODEL_CACHE_DIR=/srv/software/model-weights/tabpfn/

In Python, before importing tabpfn:

import os
os.environ["TABPFN_MODEL_CACHE_DIR"] = "/srv/software/model-weights/tabpfn/"

In R, before loading the TabPFN package:

Sys.setenv(TABPFN_MODEL_CACHE_DIR = "/srv/software/model-weights/tabpfn/")

Using TabPFN from R

The tabpfn R package provides a tidymodels-friendly interface. Under the hood it uses reticulate to call the Python tabpfn package, so on first use it will set up a Python environment and install the Python dependencies into it. Run that first install on the head node (compute nodes have no internet):

install.packages("tabpfn")
library(tabpfn)
# First call triggers reticulate to provision the Python env

Once the Python side is in place, training and prediction work like any other parsnip model. Because TABPFN_MODEL_CACHE_DIR is inherited by the embedded Python process, the cached weights are reused — no extra configuration needed.

Note

The shared directory contains the default classifier and regressor checkpoints listed in the TabPFN model registry. If you need a different checkpoint, ask the admin to add it — that way every user benefits from the cache instead of redownloading gated weights into ~/.

Spack (HPC package manager)

Spack is an HPC package manager used to install optimized scientific software. The cluster has a system-wide Spack installation with packages targeting the AMD Zen 3 instruction set (for broad compatibility) using the AMD AOCC compiler.

Loading Spack and its packages

module load spack/1.1.1

This gives you:

The spack command (for querying and loading packages)
Access to all Spack-installed modules via module avail

# List all Spack-installed packages
spack find

# Load a package
spack load <package>

# Or use the module system
module avail          # Shows spack-installed modules too
module load plink2/2.0.0-a.6.9

Installing your own packages

If you need software that isn’t installed system-wide, you can install packages in your home directory that build on top of the system installation. This requires a one-time setup.

One-time setup

Run these commands once to configure Spack for user-local installs:

mkdir -p ~/.spack

cat > ~/.spack/upstreams.yaml << 'EOF'
upstreams:
  system:
    install_tree: /srv/software/spack/opt
EOF

cat > ~/.spack/config.yaml << 'EOF'
config:
  install_tree:
    root: ~/spack/opt
  source_cache: ~/.spack/cache/source
  misc_cache: ~/.spack/cache/misc
  build_stage:
    - $tempdir/$user/spack-stage
EOF

cat > ~/.spack/modules.yaml << 'EOF'
modules:
  default:
    enable:
      - lmod
    roots:
      lmod: ~/spack/modules
    lmod:
      core_compilers:
        - aocc@5.1.0
        - gcc@11.5.0
      hierarchy: []
      hash_length: 0
      hide_implicits: true
      all:
        autoload: direct
      projections:
        all: '{name}/{version}'
EOF

This configures:

upstreams.yaml: Tells Spack to reuse system-installed packages as dependencies instead of rebuilding everything
config.yaml: Redirects the install tree, source cache, and build staging to your home directory (otherwise Spack would try to write to root-owned system paths)
modules.yaml: Redirects module file generation to your home directory

Installing packages

module load spack/1.1.1
spack install <package>

Spack will reuse system-installed dependencies and only build what’s missing.

Use the AMD compiler for best performance

The cluster CPUs are AMD Zen3. For computationally intensive software, build with the AMD AOCC compiler:

spack install <package> %aocc@5.1.0

If a package fails to build with AOCC, fall back to GCC:

spack install <package> %gcc@11.5.0

If you don’t specify a compiler, Spack will choose one automatically.

Note

Package installation compiles from source, which can be slow. Only use this if the software you need isn’t already installed. For common requests, ask the admin to install it system-wide – these packages are then available for everyone.