Available Software on HPC3

Examples in this guide use the following color schema:

very important message || links to documents and sites || command name || what you need to type

1. Overview

HPC3 serves researchers from all corners of the UCI campus. At the heart of the value that RCIC adds to HPC3, is wide range of application software that is pre-compiled and ready for use. There are literally hundreds of domain-specific, community-supported, applications maintained on the cluster.

Some software is quick and easy to compile, install, and make available to users. Other applications have numerous (often undocumented) software requirements, unique build methods, and conflicting requirements when compared to other applications. The size of the problem is quite large, and grows with each new application.

IMPORTANT: HPC3 operating system was upgraded from CentOS 7 to Rocky Linux 8 on August 30, 2022. Please see DETAILED INFO about modules update for Linux 8

RCIC uses a multi-factor approach to provide a stable and flexible environment.

  • Most software is accessed only after loading the appropriate environment module

  • Nearly all installed software is packaged as an RPM with encoded dependencies.

  • Adoption of a declarative, repeatable build methodology (yaml2rpm), designed by RCIC that generates re-usable RPMS that can installed on any compatible CentOS system.

  • A Software Map (PDF) shows a snapshot of the collections of software, software modules they provide, and build dependencies. Users of HPC3 need to login to see the most recent software versions and availability. NOTE: current software map reflects upcoming module changes

For the most part, cluster users only need to know (or discover) the already-available environment module and load it prior to using their application.

2. Modules difference

There are a few meanings for modules

  • Language modules are collections of related variables, functions and subroutines that perform a set of specific programming tasks. Simply put they are files consisting Perl/Python/R code. To access a language module or search what is available, you need to use its language: Perl/Python/R.

  • Environment modules are used to activate a specific software that a user wants to use. See below how to identify and use them.

3. Environment Modules

Environment modules are one way to control which versions of software are active (Lua modules provides similar functionality, but it not installed on HPC3). Typically, a user only needs to know which module(s) is (are) needed to gain access to their application(s). Modules are quite simple in concept.

loading a module modifies environment variables (e.g., PATH for executables or LD_LIBRARY_PATH for shared object libraries and others). It is used to activate the software.

unloading a module reverses the action of load: unsets the environment variables set by loading. It is used to deactivate the software.

3.1. Using modules

Suppose you want access to gcc version 8.4.0, the following shows which version of gcc is active prior to module loading, after module load, and after the unloading.

[user@login-x:~]$ module list  (1)
No Modulefiles Currently Loaded.
[user@login-x:~]$ gcc --version | grep ^gcc (2)
gcc (GCC) 8.5.0 20210514 (Red Hat 8.5.0-10)
[user@login-x:~]$ module load gcc/8.4.0 (3)
[user@login-x:~]$ module list
Currently Loaded Modulefiles:
  1) gcc/8.4.0
[user@login-x:~]$ gcc --version | grep ^gcc
gcc (GCC) 8.4.0
[user@login-x:~]$ module unload gcc/8.4.0 (4)
[user@login-x:~]$ gcc --version | grep ^gcc
gcc (GCC) 8.4.0
1 determine which modules are loaded
2 print the version of active gcc
3 make version 8.4.0 active
4 unload the module and restore

3.2. Available modules

A very large fraction of software applications on HPC3 have a module associated with it.

Nearly all modules have specific version numbers. If not specified, the latest found is used. You should include the version number when loading a module. This will ensure that you always get the version you intend.

Modulefiles are tcl scripts that, when executed, affect your unix environment variables. We try to broadly classify software by what they do so that it is a bit easier to find a module you are interested in. The following shows the partial output of running module avail command and has just the first line after each category (there are 100s of modules not shown here).

Sample output of module avail on HPC3, Categories highlighted in red
[user@login-x:~]$ module avail
--------------------------- /usr/share/Modules/modulefiles ---------------------------
dot         module-git  module-info modules     null        use.own

---------------------------------- /etc/modulefiles ----------------------------------

--------------------- /opt/rcic/Modules/modulefiles/AI-LEARNING ----------------------
pytorch/1.5.1  pytorch/1.11.0  tensorflow/2.0.0  tensorflow/2.8.0  tensorRT/

----------------------- /opt/rcic/Modules/modulefiles/BIOTOOLS -----------------------
bamtools/2.5.1   deeptools/3.5.0  kallisto/0.48.0   qiime2/2020.8  star/2.7.8a

---------------------- /opt/rcic/Modules/modulefiles/CHEMISTRY -----------------------
amber/19.11/gcc.8.4.0   gromacs/2022.1/gcc.8.4.0-openmpi.4.1.2

---------------------- /opt/rcic/Modules/modulefiles/COMPILERS -----------------------
clang/11.1.0   intel-tbb/20190605   mpich/3.4/gcc.8.4.0   openmpi/4.1.1/gcc.system

---------------------- /opt/rcic/Modules/modulefiles/ENGINEERING ---------------------
ansys/2019R2  ansys/2020R2  gaussian/16  sas/94M7  vasp/5.4.4  vasp/6.1.2

---------------------- /opt/rcic/Modules/modulefiles/GENOMICS ------------------------
bbmap/38.87   bracken/2.6.0   dendropy/4.5.2   igv/2.8.9   megahit/1.2.9   rMATS/4.1.0

---------------------- /opt/rcic/Modules/modulefiles/IMAGING -------------------------
afni/20.3.01  ants/2.2.0  freesurfer/6.0.1  freesurfer/7.2.0  mrtrix3/3.0.2

---------------------- /opt/rcic/Modules/modulefiles/LANGUAGES -----------------------
anaconda/2020.07  java/1.8.0  julia/1.7.1  miniconda3/4.12.0  python/3.10.2 stata/16

---------------------- /opt/rcic/Modules/modulefiles/LIBRARIES -----------------------
eigen/3.3.7  freetype/2.10.2   hdf4/4.2.15   libpng/1.6.37   proj/9.0.0   ucx/1.8.0

----------------------- /opt/rcic/Modules/modulefiles/PHYSICS ------------------------
marc/2020  mentat/2020  opensees/3.3.0  opensees/3.4.0

----------------------- /opt/rcic/Modules/modulefiles/STATISTICS ----------------------
aria2/1.36.0   jags/4.3.0

------------------------ /opt/rcic/Modules/modulefiles/TOOLS -------------------------
bazel/0.26.1   hdf5/1.13.1/gcc.11.2.0   protobuf/3.19.4

3.3. Searching for modules

You might not know the name of a particular module or versions available. You can use module keyword or module avail <partialname> to find some information. Keyword will find the keyword if it shows up anywhere in the module definition:

[user@login-x:~]$ module keyword hmmer
--------------------------- /opt/rcic/Modules/modulefiles/BIOTOOLS ---------------------------
         hmmer/3.3: Category------- BIOTOOLS
         hmmer/3.3: Name----------- hmmer
         hmmer/3.3: Version-------- 3.3
         hmmer/3.3: Description---- HMMER 3.3 is used for searching sequence databases ...
         hmmer/3.3:                 sequence alignments. It implements methods using   ...
         hmmer/3.3: Load modules--- gcc/8.4.0
         hmmer/3.3: Prerequisites-- rcic-module-support
repeatmasker/4.1.0: Category------- BIOTOOLS
repeatmasker/4.1.0: Name----------- repeatmasker
repeatmasker/4.1.0: Version-------- 4.1.0
repeatmasker/4.1.0: Description---- RepeatMasker 4.1.0 is a program that screens DNA ...

The above partial output shows in the first column found module names (with their associated versions) that contain a keyword, and in the second column shows the text line of the module file where a keyword was found.

To turn on case insensitive module parameter evaluation, add -i switch to your commands. The following shows that there are two versions of bwa module available, bwa/0.7.17 and bwa/0.7.8:

[user@login-x:~]$ module keyword -i BWA
bwa/0.7.8: Name------------ bwa
bwa/0.7.8: Version--------- 0.7.8
bwa/0.7.17: Name------------ bwa
bwa/0.7.17: Version--------- 0.7.17

You can look for partial words on just the module name (case sensitive). The following example looks for hdf modules available on HPC3:

[user@login-x:~]$ module avail hdf
---------------------- /opt/rcic/Modules/modulefiles/LIBRARIES ----------------------

------------------------ /opt/rcic/Modules/modulefiles/TOOLS ------------------------
hdf5/1.10.5/gcc.8.4.0                   hdf5/1.13.1/gcc.11.2.0
hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3     hdf5/1.13.1/gcc.11.2.0-openmpi.4.1.2
hdf5/1.10.5/gcc.system                  hdf5/1.13.1/gcc.system
hdf5/1.10.5/gcc.system-openmpi.4.1.1    hdf5/1.13.1/gcc.system-openmpi.4.1.1
hdf5/1.10.5/intel.2020u1                hdf5/1.13.1/intel.2022.2
hdf5/1.10.5/intel.2020u1-openmpi.4.0.3  hdf5/1.13.1/intel.2022.2-openmpi.4.1.2

Here is an example that explains how to search for cmake. The first command shows available versions. The second command a search for a keyword shows that modules foundation also provide cmake. Follow up with module display to find more info:

[user@login-x:~]$ module avail cmake
----------------- /opt/rcic/Modules/modulefiles/TOOLS ---------------------------
cmake/3.20.5  cmake/3.22.1

[user@login-x:~]$ module keyword cmake
cmake/3.22.1: Category------- TOOLS
cmake/3.20.5: Name----------- cmake
cmake/3.20.5: Version-------- 3.20.5
cmake/3.22.1: Name----------- cmake
cmake/3.22.1: Version-------- 3.22.1
foundation/v7: Name----------- foundation
foundation/v7: Version-------- v7
foundation/v8: Name----------- foundation
foundation/v8: Version-------- v8

[user@login-x:~]$ module display foundation/v8
module-whatis   {Category------- TOOLS}
module-whatis   {Name----------- foundation}
module-whatis   {Version-------- v8}
module-whatis   {Description---- This module provides access to up-to-date versions of commonly}
module-whatis   {                used tools for building software including cmake v.3.22.1,}
module-whatis   {                curl v.7.81.0, git v.2.34.1, git-lfs v.3.0.2, ninja v.1.10.2,}
module-whatis   {                and swig v.4.0.2.}
module-whatis   {Prerequisites-- rcic-module-support}
setenv          foundationPREFIX /opt/foundation/v8
setenv          foundationCPPFLAGS -I/opt/foundation/v8/include
setenv          foundation__LDFLAGS {-L/opt/foundation/v8/lib -Wl,-rpath,/opt/foundation/v8/lib}
prepend-path    GEM_PATH /opt/foundation/v8/share/gems
prepend-path    PATH /opt/foundation/v8/bin
prepend-path    MANPATH /opt/foundation/v8/share/man
prepend-path    LD_LIBRARY_PATH /opt/foundation/v8/lib
prepend-path    PKG_CONFIG_PATH /opt/foundation/v8/lib/pkgconfig

Note, foundation modules provide other software in addition to cmake, while cmake modules provide just cmake software. For most people using cmake modules is what is needed. Each foundation module provides one version of cmake (see module display).

To find more details about how to execute module commands see a manual page for module:

[user@login-x:~]$ man module

3.4. Module Naming

you will notice in the available modules listing that module names have four different forms:

Table 1. Formats of module file names
Naming schema Example

1 name


2 name/version


3 name/version/compiler.compiler_version


4 name/version/compiler.compiler_version-mpi.mpi_version



5 name/version/compiler.compiler_version-cuda.cuda_version


1 simple module with only a name without version. Reserved for system installed few basic modules.

2 python module for a specific version of python.

3 boost version compiled with a specific compiler version.

4 hdf5 version 1.10 built with in the Intel compiler version 2020u1 and openmpi version 4.0.3, and a second line shows a version built with the gcc compiler version 8.4.0.

5 namd module built with gcc compiler and is cuda enabled. Note, when a module lists cuda in its name this means a module provides a software that needs to be run on GPU-enabled nodes (any of GPU partitions).

The naming schema makes it more apparent what version is available and what are key differences among different versions. This also shows the potential combinatorial number of variants of any software. We do not attempt to build every variant of compiler x mpi for these kinds of software. We build what is needed.

3.5. Prerequisite modules

RCIC has built additional code to automatically load and unload prerequisite modules. Our goal is that if you want an application and it has several other software modules that must be loaded, then they will be added automatically when loading and removed automatically when unloading. Here are three examples:

  1. Loading module with a few prerequisites

    [user@login-x:~]$ module list
    No Modulefiles Currently Loaded.
    [user@login-x:~]$ module load hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3
    [user@login-x:~]$ module list
    Currently Loaded Modulefiles:
    1) java/1.8.0  2) gcc/8.4.0 3) openmpi/4.0.3/gcc.8.4.0 4) hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3
    [user@login-x:~]$ module unload hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3
    [user@login-x:~]$ module list
    No Modulefiles Currently Loaded.
  2. Loading module with many prerequisites

    [user@login-x:~]$ module list
    No Modulefiles Currently Loaded.
    [user@login-x:~]$ module load unicycler/0.4.8
    [user@login-x:~]$ module list
    Currently Loaded Modulefiles:
     1) java/1.8.0      7) htslib/1.10.2       13) bowtie2/2.4.1
     2) pilon/1.23      8) samtools/1.10       14) edirect/2020
     3) gcc/8.4.0       9) gsl/2.6/gcc.8.4.0   15) openmpi/4.0.3/gcc.8.4.0
     4) python/3.8.0   10) bcftools/1.10.2     16) boost/1.66.0/gcc.8.4.0
     5) SPAdes/3.14.0  11) perl/5.30.0         17) ncbi-blast/2.10.0
     6) racon/1.4.13   12) intel-tbb/20190605  18) unicycler/0.4.8
    [user@login-x:~]$ module unload unicycler/0.4.8
    [user@login-x:~]$ module list
    No Modulefiles Currently Loaded.
  3. Module loading/unloading with pre-loaded prerequisites

    Our modifications to modules has "smart" unloading where when a prerequisite is already loaded, unloading the higher-level module will leave the prerequisite intact. Here’s the Example 1 but with gcc/8.4.0 already loaded by the user.

    [user@login-x:~]$ module list
    No Modulefiles Currently Loaded.
    {pronmpt} module load gcc/8.4.0 (1)
    [user@login-x:~]$ module list
    Currently Loaded Modulefiles:
      1) gcc/8.4.0
    [user@login-x:~]$ module load hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3 (2)
    [user@login-x:~]$ module list
    Currently Loaded Modulefiles:
      1) gcc/8.4.0                             3) hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3
      2) openmpi/4.0.3/gcc.8.4.0
    [user@login-x:~]$ module unload hdf5/1.10.5/gcc.8.4.0-openmpi.4.0.3 (3)
    [user@login-x:~]$ module list (4)
    Currently Loaded Modulefiles:
      1) gcc/8.4.0
    1 manually preload gcc/8.4.0 as a prereq
    2 load hdf5 as in the simple example
    3 unload hdf5
    4 check that gcc is still loaded
Always unload modules in the reverse order of loading. Last-loaded should be first unloaded. Not doing this can result in an expected or broken environment

3.6. Modules limitations

Caveat emptor - Environment modules do their job, but have limitations. You can easily render your environment into a completely broken mess if you randomly unload modules. For example, the complex example automatically loaded 16 prerequisite modules. Nothing prevents you from doing a module unload gcc/8.4.0. You won’t see any errors or complaints until you attempt to run unicycler. Needed libraries will not be available. Please heed the tip above

Some modules overwrite environment variables, clang is an example of this. Clang requires llvm and gcc, but overwrites the CC environment variable. If you you preload gcc and then load clang, that will work just fine. However, if you then unload clang, the CC environment variable will NOT be restored to CC=gcc. Instead the environment variable will no longer be defined.

When a module changes an environment variable, it does not record the previous version of it.

3.7. Module details

There are two commands that are useful to find out about modules:

3.7.1. module whatis

module whatis gives you some information from specified modulefile. RCIC-authored modules follow a uniform formatting and it is best illustrated by the example:

Example module whatis output
[user@login-x:~]$ module whatis hdf5/1.10.5/gcc.8.4.0
hdf5/1.10.5/gcc.8.4.0: Category------- TOOLS (1)
hdf5/1.10.5/gcc.8.4.0: Name----------- hdf5
hdf5/1.10.5/gcc.8.4.0: Version-------- 1.10.5
hdf5/1.10.5/gcc.8.4.0: Description---- HDF5 is a data model, library, and file format for storing and managing data. It supports (2)
hdf5/1.10.5/gcc.8.4.0:                 an unlimited variety of datatypes, and is designed for flexible and efficient I/O and for
hdf5/1.10.5/gcc.8.4.0:                 high volume and complex data. HDF5 is portable and is extensible, allowing applications to
hdf5/1.10.5/gcc.8.4.0:                 evolve in their use of HDF5. The HDF5 Technology suite includes tools and applications for
hdf5/1.10.5/gcc.8.4.0:                 managing, manipulating, viewing, and analyzing data in the HDF5 format.
hdf5/1.10.5/gcc.8.4.0:                 Environment var: HDF5_HOME = /opt/apps/hdf5/1.10.5/gcc/8.4.0
hdf5/1.10.5/gcc.8.4.0: Load modules--- java/1.8.0 (3)
hdf5/1.10.5/gcc.8.4.0:                 gcc/8.4.0
hdf5/1.10.5/gcc.8.4.0: Prerequisites-- java8-module (4)
hdf5/1.10.5/gcc.8.4.0:                 gcc_8.4.0-module
hdf5/1.10.5/gcc.8.4.0:                 rcic-module-support
hdf5/1.10.5/gcc.8.4.0:                 hdf5_1.10.5_gcc_8.4.0
1 Name, Category, Version for this particular module
2 A long description of what this software does
3 Prerequisite modules that will be loaded, if not already present
4 RPM Package requirements to have this module installed

3.7.2. module display

module display shows additional information, including the full path of the modulefile and the environment variables changes the modulefile will make when loaded.

Example module display output
[user@login-x:~]$ module display hdf5/1.10.5/gcc.8.4.0

module-whatis	 Category------- TOOLS
module-whatis	 Name----------- hdf5
module-whatis	 Version-------- 1.10.5
module-whatis	 Description---- HDF5 is a data model, library, and file format for storing and managing data. It supports
module-whatis	                 an unlimited variety of datatypes, and is designed for flexible and efficient I/O and for
module-whatis	                 high volume and complex data. HDF5 is portable and is extensible, allowing applications to
module-whatis	                 evolve in their use of HDF5. The HDF5 Technology suite includes tools and applications for
module-whatis	                 managing, manipulating, viewing, and analyzing data in the HDF5 format.
module-whatis	                 Environment var: HDF5_HOME = /opt/apps/hdf5/1.10.5/gcc/8.4.0
module-whatis	 Load modules--- java/1.8.0
module-whatis	                 gcc/8.4.0
module-whatis	 Prerequisites-- java8-module
module-whatis	                 gcc_8.4.0-module
module-whatis	                 rcic-module-support
module-whatis	                 hdf5_1.10.5_gcc_8.4.0
prereq	 java/1.8.0 (1)
prereq	 gcc/8.4.0
setenv		 HDF5_HOME /opt/apps/hdf5/1.10.5/gcc/8.4.0 (2)
setenv		 hdf5PREFIX /opt/apps/hdf5/1.10.5/gcc/8.4.0
setenv		 hdf5CPPFLAGS -I/opt/apps/hdf5/1.10.5/gcc/8.4.0/include
setenv		 hdf5__LDFLAGS -L/opt/apps/hdf5/1.10.5/gcc/8.4.0/lib -Wl,-rpath,/opt/apps/hdf5/1.10.5/gcc/8.4.0/lib
prepend-path	 PATH /opt/apps/hdf5/1.10.5/gcc/8.4.0/bin (3)
prepend-path	 MANPATH /opt/apps/hdf5/1.10.5/gcc/8.4.0/share/man
prepend-path	 LD_LIBRARY_PATH /opt/apps/hdf5/1.10.5/gcc/8.4.0/lib
prepend-path	 PKG_CONFIG_PATH /opt/apps/hdf5/1.10.5/gcc/8.4.0/lib/pkgconfig
prepend-path	 -d   CPPFLAGS -I/opt/apps/hdf5/1.10.5/gcc/8.4.0/include
prepend-path	 -d   LDFLAGS -L/opt/apps/hdf5/1.10.5/gcc/8.4.0/lib -Wl,-rpath,/opt/apps/hdf5/1.10.5/gcc/8.4.0/lib
1 Specification of pre-requisite modules
2 Environment vars set
3 PATH-like variable that are augmented with additional information.

4. User installed sw and environment modules

You don’t need to create a new environment module if you are installing a language module package for Python, R, or Perl, or adding packages with conda. Simply use respective Python/R/Perl/conda module (use module avail command to see what is installed) to access the desired language and follow your package installation instructions. Please see the install guides that explain how to create conda environments, and to install R, Python and Perl packages:

R packages

Python packages with pip

Bulding Conda local environments

Perl CPAN modules

Create Singularity container

Users can install additional software and add environment module for it either for themselves or for their groups. There are a few basic steps:

  1. Compile and install your desired software in your user/group designated area. Make sure that for group access the directories and files permissions are set correctly. Note, the software installation and a module file installation are two separate tasks and the installation location of a module file is different from the location where the software is installed. Verify that the software is working according to the instructions.

    DO NOT install your software in $HOME/modulefiles/
  2. Create an environment module file for your new software. The environment module file is a text file in a specific format that provides information about the software and sets needed environment for using it.

    • We suggest to use one of the available system modules files as a template. Run command module display for one of the available modules, the output shows the full path to the module file which can be copied and modified according to your needs. In addition, take a look at this modulefile-template file that can be used as a template. In general, you will need to specify:

      • software description, name and version

      • environment variables your software needs, for example PATH, LD_LIBRARY_PATH

      • modules that you used to compile your softare (if any)

    • Please follow the naming schema for the module file name and choose where to put it:

      • If you install the new software and its module for yourself, we suggest to use $HOME/modulefiles/ directory to store your new module files. It is searched by module commands by default and in this case your job is done and no extra steps are needed.

      • If you install for the group, see If you install for the group instructions below.

  3. Verify your installed module file is working. Run module avail command. If your environment module file is installed correctly then your new module name will show at the end of the output.

    If no valid module files are present in $HOME/modulefiles/, the module name will NOT be shown when running module commands, or will produce an error. Review steps above and correct any errors.
  4. If you install for the group. You need to enable module commands to look at your new environment module file. This is done via adding pathnames to the text file $HOME/.usermodulepath. Initially, this file does not exist, simply create it using your favorite text editor using the following rules:

    • you can put multiple paths, type each path on a separate line

    • comment lines start with a #. Here is an example $HOME/.usermodulespath file:

      Example User-defined paths to search for additional modules
      [user@login-x:~]$ cat $HOME/.usermodulespath
      # Put a directory path per line to search for additional modules

      Let say, you (1) installed a new version of gcc software 8.4.1 for the group in /dfs3/panteater-lab/project1/sw/ and (2) created a directory /dfs3/panteater-lab/modulefiles/ to hold the module files. This directory can be used for any other module files that will be installed for the group. (3) Now, you need to create a /dfs3/panteater-lab/modulefiles/gcc/ directory where you will add a module file named 8.4.1 that defines your new module for your installed gcc version 8.4.1.

    • After you modify the contents of the file $HOME/.usermodulespath, for the changes to take effect please start a new bash shell:

      [user@login-x:~]$ . ~/.bashrc
      If you expect other users to use your publicly available module file, they will need to create $HOME/.usermodulespath file with the same contents as yours.
    • If your installed module file is correct you can run module commands to display and load your module as shown below:

      Loading a user-defined module
      [user@login-x:~]$ module list
      No Modulefiles Currently Loaded.
      [user@login-x:~]$ module avail
          .... truncated
      ------------------------ /opt/rcic/Modules/modulefiles/TOOLS -------------------------
      fftw/3.3.8                             netcdf-c/4.7.0/intel.2020u1
      --------------------------- /dfs3/panteater-lab/modulefiles ---------------------------
      [user@login-x:~]$ module load gcc/8.4.1
      [user@login-x:~]$ module list
      Currently Loaded Modulefiles:
        1) gcc/8.4.1
      [user@login-x:~]$ module unload gcc/8.4.1

5. Software Stack

The deployed software stack is generally added to on weekly basis. This is in response to a near-continuous stream of requests. If you want to request new software, please see the howto.

The complete stack is fairly complex and captures dependencies. For the most part, we build RPMs (the native package format for CentOS/RedHat systems). Exceptions generally fall around very large footprint software like the Intel Compiler, MATLAB, and (e.g., FreeSurfer).

Why RPMS? For us, it’s one extra step that comes a wide variety of benefits.

  • The package manager (yum) will not allow two different RPMs to claim ownership of the same file (or have conflicting permissions on a shared directory path).

  • Dependencies, when properly encoded, help ensure that removal of a particular package won’t leave other software in a "broken" state.

  • Ease of transitioning to container definitions. One of our goals is to allow users to easily take away subsets of the HPC3 software stack in the form of a singularity or Docker container.

  • It only takes a little bit of work to enable multiple versions of same software to be co-installed.

  • Use native OS tools for admins/users to get information about installed software.