Skip to content is UTHPC centre's JupyterHub.

JupyterHub is a multi-user Jupyter server that provides a web-based login and spawns your own single-user server with JupyterLab.

Getting started

JuputerHub is available not only within UT network, but also from the rest of the Internet at with your UT credentials. To use JuputerHub, you have to have UTHPC account.

To start your single-user server, you have to choose a profile. Currently, there are 5 available options:

Profile CPU cores Memory Time limit Notes
Default 1 8 GB 6 h runs on main partition
Default AMD 1 8 GB 6 h runs on amd partition
Large memory 2 32 GB 24 h
Multicore 8 16 GB 24 h
GPU 2 40 GB 6 h 1 GPU
Testing 1 8 GB 2 h

Your single-user server spins up a job in Slurm queue on the UTHPC cluster and it might take sometime to start depending on the resource availability. The started single-user server stays up until either you stop it manually or the time limit kicks in.


Closing the tab doesn't close the server.


If you have finished your job, please, stop your server to free up resources for other users and incur extra costs. Note that selecting ’Logout’doesn't free up resources as it keeps your server running (see Stopping a single-user server section).

As Slurm manages the resources for your single-user server. Be aware if you go over the memory limit, your server is automatically killed without warning. You can view the error messages in the corresponding error file ~/> (’xxx’ represents a Slurm job id).

Stopping a single-user server

Use ’Stop My Server’ button in ’Hub Control Panel’ to shut down your server. Navigate to ’FileHub Control Panel’. It takes a bit of time to shut down your running server.


Default software and kernels

It has preinstalled Python 3.10.1 and R 3.6.3 kernels.

Installing Packages for R/Python Kernels


You can install R or Python kernels through either Jupyter's Terminal or the original terminal with SSH.

Jupyter users share both R and Python kernels, which is why it's not allowed to install add-on packages directly into kernels. However, you can install packages in your local $HOME directory.

For Python packages, please refer to the section below: Adding a Custom Python/Conda Environment . Once your custom Conda/Python kernel is created, you can proceed to install packages into the virtual environment.

Installing R Packages

  1. Open the Terminal and create a library directory, then close the terminal.
    mkdir -p ~/local/R_libs
  2. Open a Notebook with a selected R kernel, and install packages to the created directory. NB! If the installation returns a non-zero exit code, consider either installing from HPC or contacting
    install.packages("<r_package>", lib="~/local/R_libs/")
  3. Use the package, call the function library and specify the same lib option:
    library("<r_package>", lib="~/local/R_libs/")
  1. Log in to Rocket with ssh <your_HPC_username>

  2. Load the appropriate module for the selected R kernel: | Kernel | Module | | --- | --- | | R 3.6.3 | any/R/3.6.3 | | R 4.3 | r/4.3.1 |

    module load <R_module>
  3. Create a library directory:

    mkdir -p ~/local/R_libs

  4. Open an R console and install the package. **NB!* Some R packages require extra modules to be loaded. If you encounter a non-zero exit, it might be necessary to load extra modules or contact

    ### Open R
    ### Issue a simple install command
    install.packages("<r_package>", lib="~/local/R_libs")
    ### Issue a GitHub install command
    install.packages("remotes", lib="~/local/R_libs")       # Install the remotes package
    library("remotes", lib="~/local/R_libs")                # Load the remotes package
    remotes::install_github('<github_r_package>', lib="~/local/R_libs") # Install a GitHub package

  5. Verify that the package was installed correctly:

    library("<r_package>", lib="~/local/R_libs/")

Add a custom python/conda environment

Step 1 - activate your environment


If you haven't got an environment yet, read though on how to create a python/conda environment by following our Python/Conda env guide .

#python env
source <user_env>/bin/activate

#conda env
conda activate <user_env>

Having activated the env, installs all necessary packages. Then set the env onto your JupyterLab.

Step 2 - install ipykernel to your python/conda environment

#python env
python -m pip install ipykernel

#conda env
conda install ipykernel

python -m ipykernel install --user --name=<user_env>
After doing step 3, you can load your env as a specific kernel.

Step 4 - load your environment or kernel

Customize kernels

In order for to work in custom kernel, you have to modify a kernel file of your environment.

  1. On machine, your $HOME has your environment kernel file called kernel.json, which is usually located in ~/.local/share/jupyter/kernels/<your env name>/kernel.json or can be found with jupyter-kernelspec list command

  2. Secondly, activate your python/conda env then activate the required modules, after that echo $PATH, $LIBRARY_PATH, $LD_LIBRARY_PATH with the following command:

    echo $PATH
    echo $LIBRARY_PATH
    Copy the output from the previous commands into your clipboard.

  3. Finally, open kernel.json and copy this snippet into kernel.json and substitute <your env bin path> with paths obtained in the step 2 into kernel.json file:

    "env": {
        "PATH": "<your env PATH from step 2>",
        "LD_LIBRARY_PATH": "<your env LD_LIBRARY from step 2>",
        "LIBRARY_PATH": <your env LIBRARY_PATH from step 2>"
    If necessary, add a comma at the end of the previous line and ensure } is present, as JSON requires structure.

  4. Save the file and restart Jupyter if you have it running already.

At the end, your kernel.json should look something like:

 "argv": [
 "display_name": "user_env",
 "language": "python",
 "metadata": {
  "debugger": true
 "env": {
  "PATH": "/gpfs/space/home/user/.conda/envs/user_env/bin:/gpfs/space/software/jupyterhub/python/jupyter/bin:/gpfs/software/soft/rocket/linux-centos7-x86_64/gcc-9.2.0/openssl-1.1.1g-pikmcqfnphdwr5n32225b7rf4fpksnr2/bin:/sbin:/bin:/usr/sbin:/usr/bin",
  "LD_LIBRARY_PATH": "/gpfs/space/home/user/.conda/envs/user_env/lib:/gpfs/space/software/jupyterhub/python/jupyter/lib"
  "LIBRARY_PAHT": "/gpfs/space/home/user/.conda/envs/user_env/lib:/gpfs/space/software/jupyterhub/python/jupyter/lib"

Problems and requests

This service is currently in beta and under development. If you notice problems or would like any more extensions or features, then please write to .

Please provide the following details:

  • Error details from the jupyter.xxxxxx.log> file.
  • Slurm job id.


Server spawning stuck without error.

Simple fix is to refresh your page (’Ctrl’ + ’R’).

Custom plugins for JupyterHub.

You can install these into your custom python/conda environment.

Accidentally closing browser with running Jupyter.

A Jupyter session is automatically saved and survives an accidental browser/tab closure as long as time limit allows. Just re logging into .

Server has died.

This may happen if resource usage exceeds the limits, thus Slurm kills your server. Check the ~/jupyter.xxxxxx.err> log file to be sure.

Server seems inaccessible / Can't get to the control panel to restart it.

In JupyterLab, ’FileHub Control Panel’. If you can't get there, you can change the URL path to /hub/home

’Spawner pending’ upon you request to start.

Wait a bit and return to JupyterHub home page and see if the server has started. Clicking the button twice might cause issues.

See also