I. HPC Setup Without `sudo` — CUDA, CMake & `.bashrc` Configuration#

Overview: This guide covers three tasks on HPC clusters where you have no root access: installing the CUDA Toolkit to your home directory without sudo; installing CMake locally from a pre-built binary; and structuring your ~/.bashrc with a modular ~/.bashrc.d/ system for managing CUDA versions, libtorch, cuDNN, and custom paths.

1. Installing CUDA Without `sudo`#

CUDA only truly requires two things: the nvcc compiler and user-space libraries like libcudart. Both can be installed entirely inside your home directory:

1
$HOME/cuda

1) Check Your Linux Distribution and Architecture#

1
cat /etc/os-release

1
NAME="Rocky Linux"
2
VERSION="9.7 (Blue Onyx)"
3
ID="rocky"
4
...

1
uname -m

1
x86_64

2) Download the Runfile from NVIDIA#

Go to: https://developer.nvidia.com/cuda-downloads

Select your OS/architecture and choose the runfile (local) installer type.

CUDA download page

The downloaded file will be named something like:

1
cuda_12.9.1_575.57.08_linux.run

Note: To install an older CUDA version, visit the archive at https://developer.nvidia.com/cuda-toolkit-archive. Make sure the CUDA version you choose is less than or equal to the CUDA Driver version reported by nvidia-smi.

3) Install the Toolkit Only (No Driver)#

Make the runfile executable:

1
chmod +x cuda_*.run

Run the installer with driver installation disabled:

1
./cuda_12.9*.run \
2
  --silent \
3
  --toolkit \
4
  --toolkitpath=$HOME/cuda-12.9 \
5
  --no-drm \
6
  --no-man-page

Flag	Purpose
`—silent`	Non-interactive installation
`—toolkit`	Install CUDA Toolkit only
`—toolkitpath`	Target installation directory (user home)
No driver flag	Avoids any root requirement

4) Configure Environment Variables (Modular `.bashrc.d`)#

Create the directory:

1
mkdir -p ~/.bashrc.d

Create a CUDA config file:

1
nano ~/.bashrc.d/cuda.sh

Write the following:

1
# ===== Default CUDA =====
2
export CUDA_HOME=$HOME/cuda-12.9
3
export PATH=$CUDA_HOME/bin:$PATH
4
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
5

6
# ===== CUDA version switcher =====
7
use_cuda () {
8
    local ver=$1
9

10
    if [ ! -d "$HOME/cuda-$ver" ]; then
11
        echo "CUDA $ver not found in \$HOME"
12
        return 1
13
    fi
14

15
    export CUDA_HOME=$HOME/cuda-$ver
16
    export PATH=$CUDA_HOME/bin:$PATH
17
    export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
18

19
    echo "Switched to CUDA $ver"
20
    nvcc --version | head -n 1
21
}

Ensure ~/.bashrc loads all files in ~/.bashrc.d/ (add if not present):

1
if [ -d ~/.bashrc.d ]; then
2
    for rc in ~/.bashrc.d/*; do
3
        [ -f "$rc" ] && . "$rc"
4
    done
5
fi

Reload the environment:

1
source ~/.bashrc

5) Verify the Installation#

Check the compiler:

1
nvcc -V

If a CUDA version string is printed, the toolkit is installed correctly.

Check GPU availability:

1
nvidia-smi

Note: This is a critical and often overlooked distinction. If nvidia-smi runs successfully, the server already has a GPU driver installed and you can use the GPU. If it fails, the GPU driver is missing — without sudo you cannot install the driver yourself, meaning CUDA can only be used for compilation, not for GPU execution.

2. Installing CMake Locally (No Root)#

1) Download the Official Pre-built Installer#

The official binary installer requires no source compilation, no gcc or make, installs quickly, and is compatible with most Linux environments.

1
cd ~
2
wget https://github.com/Kitware/CMake/releases/download/v3.29.6/cmake-3.29.6-linux-x86_64.sh

2) Install to Your User Directory#

1
bash cmake-3.29.6-linux-x86_64.sh --skip-license --prefix=$HOME/.local

Flag	Purpose
`—skip-license`	Skip the interactive license confirmation
`—prefix=$HOME/.local`	Install into the user-level software directory (Linux convention)

3) Add to `PATH` and Verify#

1
echo 'export PATH=$HOME/.local/bin:$PATH' >> ~/.bashrc
2
source ~/.bashrc
3
cmake --version

3. `.bash_profile` — Auto-load `.bashrc` on Login#

1
# Load aliases and functions from .bashrc
2
if [ -f ~/.bashrc ]; then
3
    . ~/.bashrc
4
fi

This ensures .bashrc is sourced automatically on every SSH login session.

4. `.bashrc` Section-by-Section Walkthrough#

1) System Initialization#

Loads the system-level bash configuration (modules, colors, completions, etc.):

1
if [ -f /etc/bashrc ]; then
2
    . /etc/bashrc
3
fi

2) User `PATH` Initialization#

Adds user program directories to PATH without creating duplicates:

1
# Only add if not already present (prevents duplicate PATH entries)
2
if ! [[ "$PATH" =~ "$HOME/.local/bin:$HOME/bin:" ]]
3
then
4
    # Prepend user-level bin dirs so locally installed tools take priority
5
    PATH="$HOME/.local/bin:$HOME/bin:$PATH"
6
fi
7

8
# Export so child processes (Python, bash, etc.) inherit this PATH
9
export PATH

3) The `.bashrc.d` Modular Config System#

Splits shell configuration into separate, focused files. Recommended when managing multiple CUDA versions, multiple Conda environments, multi-project research, or many custom aliases.

1
# Load all user config modules from ~/.bashrc.d/
2
if [ -d ~/.bashrc.d ]; then
3
    for rc in ~/.bashrc.d/*; do
4
        # Only source regular files (not directories or other types)
5
        if [ -f "$rc" ]; then
6
            # Source the file — equivalent to: source "$rc"
7
            # Makes aliases, functions, and exports take effect immediately
8
            . "$rc"
9
        fi
10
    done
11
fi

4) PATH and Library Configuration#

CUDA 12.6 Environment#

1
# ===== CUDA 12.6 =====
2
export CUDA_HOME=$HOME/cuda-12.6
3
export PATH=$CUDA_HOME/bin:$PATH
4
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

Sets the default CUDA version to 12.6.

libtorch Headers and Library Paths#

1
# ===== libtorch — PyTorch's official C++ API and runtime =====
2
export CPATH=$HOME/libtorch/include:$HOME/libtorch/include/torch/csrc/api/include:$CPATH
3
export LIBRARY_PATH=$HOME/libtorch/lib:$LIBRARY_PATH
4
export LD_LIBRARY_PATH=$HOME/libtorch/lib:$LD_LIBRARY_PATH

Enables calling PyTorch from C++.

Use Case	Keep?
Writing C++/CUDA code with libtorch	✔ Required
Python-only PyTorch usage	❌ Can be removed

cuDNN Paths#

Only needed for C++ builds, custom CUDA kernels, or TensorRT:

1
# ===== cuDNN =====
2
export CPATH=$HOME/cudnn/include:$CPATH
3
export LIBRARY_PATH=$HOME/cudnn/lib:$LIBRARY_PATH
4
export LD_LIBRARY_PATH=$HOME/cudnn/lib:$LD_LIBRARY_PATH

CUTLASS#

1
# ===== CUTLASS =====
2
export CUTLASS=$HOME/cutlass

Custom Command Paths#

1
# ===== PATH: tells the shell where to find executables =====
2
export PATH=$HOME/.local/bin:$PATH
3
export PATH="$HOME/bin:$PATH"

💡 One-line Takeaway
On a no-root HPC cluster: install CUDA with --toolkitpath=$HOME/cuda-X.Y --no-drm, install CMake with --prefix=$HOME/.local, and keep your shell config clean by splitting everything into ~/.bashrc.d/ modules — remember that CUDA without a GPU driver can compile but not run.

I. HPC Setup Without sudo — CUDA, CMake & .bashrc Configuration#

1. Installing CUDA Without sudo#