Software modules make it easy for you to use software installed on CS servers. We provide a wide range of software across all our servers so that you don't have to install software on your own. We also offer different versions of software, letting users choose which they want to use.

Software modules modify Environment Variables unique to your shell. Environment variables include the variable PATH, which are directory path(s) to executables to use when typing a command in your terminal. For example, when you log in via SSH, variables such as the PATH variable are set or updated to contain the location(s) of various executable commands such as vim, sinfo, and others.

Each time you load a module, this variable and others are updated to make additional commands or libraries available to your shell.

If software is needed but is not listed, please send an email to cshelpdesk@virginia.edu with the following information:

1. In the subject line, write: Software Module Request: <software name and version>
2. In the body of the email, include information about the requested software
   1. Links to software documentation page(s) if available
   2. Version(s) required

• Standardized on specific versions of GCC to simplify compilation and module usage
• Modules and versions that will be available are listed below
• Combined modules for GCCCore and GCC, renaming to gcc/<version>

If software is required but is not listed, please send an email to cshelpdesk@virginia.edu.

For modules that list a toolchain other than system, the toolchain module(s) must be loaded first before loading the listed module.

For example, to load boost/1.83.0 the following must be done, all three variations accomplish the same thing

Note, gcc/11.4.0 is loaded by default when a version is not specified

// load default versions
~$ module load gcc boost

OR

// load specific version
~$ module load gcc
~$ module load boost/1.83.0

OR

// load default versions using shorthand
~$ ml gcc boost

• LMOD software FAQ LMOD FAQ Link

• I'm unable to run module commands in a *ZSH* shell OR receiving the error compinit: function definition file not found
  • To solve this, execute the following command before starting your zsh shell
    • ~$ unset FPATH
    • ~$ zsh
    • ~$ source /etc/profile.d/modules.sh (this may not be necessary depending on your zsh configurations)

• The error module command not found is displayed
  • To resolve this, simply execute ~$ source /etc/profile.d/modules.sh in your terminal (including in VSCode)

• Generally, executing ~$ module purge before loading software or when switching modules is recommended. This ensures dependency modules are unloaded from other software(s) and only the software you want is loaded

• When a version is not specifed, the default will be loaded. Default modules are marked with (D) when using ~$ module avail

• Can I still use the old software stack?
  • Yes! To use the previous software stack, simply execute the following export command
  • Note, these modules may or may not work since they are from an old stack version
  • Be sure to include the option --ignore_cache when executing module commands if you're using the previous stack

  • ~$ export MODULEPATH=/sw/ubuntu/modulefiles_old/core:/sw/ubuntu/modulefiles_old/toolchains:/sw/ubuntu/custom/modulefiles:/sw/ubuntu/licensed/modulefiles

  • Then, you can use commands such as the following to use the previous stack modules

  • ~$ module --ignore_cache load <software name>/<version>

1. Common/Core
   • These are software modules compiled and maintained using EasyBuild

1. Custom
   • These are software modules that were manually compiled that are not available within EasyBuild or have another reason for manual compilation

1. Licensed
   • These are software modules that require some form of license to use (for example, matlab, gurobi, etc.)

In January of 2025, the CS department is transitioning the backend software used for interacting with modules from Environment Modules to LMOD (LMOD Homepage), and implementing EasyBuild (EasyBuild Homepage) for maintaining modules.

Modules are compiled using a toolchain such as gcc, the system default (i.e. what the server has available), or others. This means that modules compiled using a toolchain will not be available (i.e. won't be shown with module avail) until the toolchain has been loaded.

For example, openmpi will not show up in the module avail output until the appropriate GCC toolchain is loaded. Required modules can be found by using the module spider <module name>/<version> as shown below.

In-depth information about module usage and interaction can be found (here).

To list available modules

module avail

To load a default module (no version specified)

module load <module name>

To load a specific version, include the version suffix

module load <module name>/1.2.3

To search for modules and list required dependency modules to load certain modules

module spider <module name>/<version>

For example, to load python, first search for what python versions are available

module spider python
----------------------------
  python:
----------------------------
    Description:
      Python is a programming language that lets you work more quickly and integrate your systems more effectively.

     Versions:
        python/2.7.18
        python/3.12.3

Then, search for required modules to load first before loading a specific version of python

module spider python/3.12.3
----------------------------
  python: python/3.12.3
----------------------------
    ... output omitted ...
    You will need to load all module(s) on any one of the lines below before the "python/3.12.3" module is available to load.
      gcc/11.4.0
      gcc/14.2.0

Thus, gcc/11.4.0 (which is the default) is required to load python/3.12.3. Alternatively, gcc/14.2.0 also provides the module python/3.12.3, so either toolchain may be used depending on your needs

module load gcc/11.4.0
module load python/3.12.3

Alternatively, you can load the required module and the module itself on one line

module load gcc/11.4.0 python/3.12.3

To load the default versions, simply omit the version from the module

module load gcc python

To show all currently loaded modules

module list

To show information about a module

module whatis <module name & version>

To unload a module

• Note, some module load multiple dependencies as shown with a module list command, which are not unloaded automatically. It's recommended to purge (unload all) modules instead

module unload <module name & version>

To purge (unload all) loaded modules

module purge

Before submitting a job, it is recommended to unload all loaded modules using module purge before and during the job launch, and then load them in the job script or at the command line for an interactive job.

This ensures that no unexpected modules are carried forward into your job from your shell's environment variables.

#!/bin/bash

#SBATCH --gres=gpu:1
#SBATCH --mem=16000
#SBATCH -t 04:00:00
#SBATCH -p gpu
#SBATCH --mail-type=begin,end
#SBATCH --mail-user=<computingID>@virginia.edu

module purge
module load gcc python

python3 <my python program>

For most Python related packages (i.e. pip install …), it is often more applicable to utilize a virtual environment. This can be done with Conda or venv. The former requires loading an miniforge module, and the latter requires the python3 module.

After loading and using this module, your ~/.bashrc file will be updated to source the base environment each time you log in.

After logging into portal, load the module and configure your login shell (altering the file ~/.bashrc) to source the base environment to allow for conda activate commands

abc1de@portal01:~$ module load miniforge
abc1de@portal01:~$ conda init bash

// after logging out and back in
(base) abc1de@portal01:~$ conda create -n mynewenvironment

This will by default create an environment named mynewenvironment in ~/abc1de/.conda/envs/.

You can also specify a path where an environment should be created

(base) abc1de@portal01:~$ conda create -n mynewenvironment --prefix /p/myprojectdirectory/condaenvs

Packages can be specifed when creating an environment

(base) abc1de@portal01:~$ conda create -n mynewenvironment matplotlib=3.5 numpy=1.21

Environments can be created using a .yml file as well

(base) abc1de@portal01:~$ conda env create -f /<path>/env.yml

To list available environments

(base) abc1de@portal01:~$ conda env list

OR

(base) abc1de@portal01:~$ conda info --envs

To activate an environment (if the name is shown with conda env list)

(base) abc1de@portal01:~$ conda activate mynewenvironment

To activate an environment by path

(base) abc1de@portal01:~$ conda activate /<path>/mycustompathenv

After logging into portal, load the python module

abc1de@portal01:~$ module load python

To create a python3 venv envrionment

abc1de@portal01:~$ python3 -m venv /<path>/myvenv

To activate a python3 venv environment

abc1de@portal01:~$ source /<path>/myvenv/bin/activate

Commands such as pip3 can now be used within the envrionment

abc1de@portal01:~$ which pip3
/<path>/myenv/bin/pip3

abc1de@portal01:~$ pip3 install <package name>

A Jupyter Notebook interface can be loaded using a virtual environment (as described above). This is best done using a NX virtual desktop. Once you've logged into your NX virtual desktop, load python3 or miniforge as a software module:

abc1de@labsrv03~:$ module load miniforge

Then, load Jupyter Notebook:

abc1de@labsrv03~:$ jupyter notebook

Follow the link given to you by the Notebook Server to access the interface:

[W 12:52:23.489 NotebookApp] Loading JupyterLab as a classic notebook (v6) extension.
[I 12:52:23.492 NotebookApp] Serving notebooks from local directory: /u/abc1de
[I 12:52:23.492 NotebookApp] Jupyter Notebook 6.5.4 is running at:
[I 12:52:23.492 NotebookApp] http://localhost:8888/?token=eb9345040d71bbeb1eddc75fb88504f98e25beb207907f6d
[I 12:52:23.492 NotebookApp]  or http://127.0.0.1:8888/?token=eb9345040d71bbeb1eddc75fb88504f98e25beb207907f6d
[I 12:52:23.492 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 12:52:23.634 NotebookApp] 
    
    To access the notebook, open this file in a browser:
        file:///u/<youruserid>/.local/share/jupyter/runtime/nbserver-20880-open.html
    for example...
        file:///u/abc1de/.local/share/jupyter/runtime/nbserver-20880-open.html

Apptainer is the supported software for using containers throughout the CS environment. See our page on (Apptainer) for more information.