Skip to content

Docs CSC now features an automatic Finnish translation. Click here for more information.

Warning!

Puhti and Mahti will be decommissioned after Roihu becomes available. Users should clean up unnecessary files and move any required data by the end of August 2026. See the Roihu data preparation instructions for details.

Puhti scratch is very full: keep only active data there and move or delete everything else. No new Puhti scratch quota will be granted.

Getting started with Roihu

Roihu not yet available for use

Roihu is not yet available for use and cannot be added as a service yet in MyCSC.

You can use this tutorial to familiarize yourself with moving to Roihu and getting started before it becomes available end of June 2026.

This guide assumes familiarity with CSC supercomputers such as Puhti, Mahti or LUMI.

If you are new to CSC systems, start with the getting started with supercomputing guide.

To access Roihu, you need a CSC user account and a project with the Roihu service enabled. Read more about CSC accounts and projects.

Key differences compared to Puhti and Mahti

Before you begin, note the following important differences:

  • SSH authentication requires short-lived certificates (24h)
  • Separate login nodes and CPU architectures for CPU (x86) and GPU (ARM) environments
  • Software built on CPU nodes cannot be used on GPU nodes (and vice versa)
  • Disk quota extensions are not automatically transferred from earlier projects on Puhti/Mahti

These differences affect most workflows, so read the sections below carefully.

Add Roihu as a service

Before you start using Roihu, you need to enable it as a service for your project in MyCSC.

Project managers

If you already have a computational project, for example for Mahti or Puhti, you can add Roihu there as a service.

If you do not have a computing project yet, apply for one in MyCSC following the instructions for creating a new project.

Adding Roihu as a service:

  1. Go to my.csc.fi and log in e.g. with your HAKA identification
  2. Go to the "Profile" section, and in the bottom right corner, check that your Level of identity assurance (LoA) is medium or high
  3. Go to the "Projects" section, and open your project.
  4. In the right-side Services tab, click the "+ Add services" option.
  5. Choose Roihu, click Next and confirm this option.

Note that it may take a few minutes for Roihu to become accessible for you, and the other project members.

What if I need more disk quota on Roihu?

The default disk quotas are more restrictive on Roihu, than on Mahti and Puhti.

Capacity Number of files
home 15 GiB 150 000 files
projappl 15 GiB 150 000 files
scratch 250 GiB 500 000 files

After adding the Roihu service for your project, you can apply for a disk quota increase for the project in MyCSC.

  1. In MyCSC, go to your project where you have Roihu enabled.
  2. In the "Services" tab, find Roihu and click Configure.
  3. In "Quota settings", specify how much quota you require, and justify your request in the text box.

See the "increasing disk quotas" section for details and the maximum disk quotas you can apply for.

Project members

After your project manager has applied for the Roihu service, you will get an email titled "Roihu supercomputer for your use".

Next, accept the terms of service for Roihu, with the following instructions:

  1. Go to my.csc.fi and log in e.g. with your HAKA identification
  2. Go to the "Profile" section, and in the bottom right corner, check that your Level of identity assurance (LoA) is medium or high
  3. Go to the "Projects" section, and open your project.
  4. In the right-side Services tab, click open Roihu
  5. Accept the terms of service.

After adding Roihu to your project, you can connect to the system. Note that there may be a short delay of a few minutes before you can connect.

Connecting

Connect to Roihu using either:

SSH client

To connect via SSH:

  1. Set up SSH keys (same as Puhti/Mahti)
  2. New: Sign your public key and download a certificate

For platform-specific instructions, see:

Read detailed instructions for managing SSH keys and certificates.

Separate CPU and GPU environments

Roihu has different CPU architectures on Roihu-CPU (x86) and Roihu-GPU (ARM). Therefore, there are separate login nodes for building programs and submitting jobs to their respective nodes:

  1. roihu-cpu.csc.fi
  2. roihu-gpu.csc.fi

Connecting example (Roihu-CPU):

# Replace <username> with the name of your CSC user account.

ssh <username>@roihu-cpu.csc.fi

Importantly:
- Software compiled on Roihu-CPU nodes only works on Roihu-CPU nodes
- Software compiled on Roihu-GPU nodes only works on Roihu-GPU nodes
- This also applies to Python environments

All login nodes still share the same file system, so your files are accessible from all of them.

Roihu web interface

The simplest way to connect to Roihu is to use the web interface.

  1. Go to www.roihu.csc.fi.
  2. Log in using your HAKA, Virtu or CSC user account. Multi-factor authentication (MFA) is required.

Migrating research data

If you need to transfer data from Puhti or Mahti to Roihu, we require that you:

  1. Review your data carefully – only move what you really need
  2. Check your available disk space on Roihu (for example, using the csc-workspaces command)
  3. Transfer data directly from Puhti or Mahti to Roihu.

Note that previous extended disk quotas on Puhti or Mahti will not be automatically moved to Roihu. Quota extensions on Roihu must be separately applied for and properly motivated.

Read the detailed instructions in the Roihu data migration guide.

Installing software

Before installing anything, check if the software is already available:

If the software is not available as a module, choose one of the following approaches depending on your needs:

Compiling C/C++/Fortran code

HPC software written using programming languages, such as C, C++, or Fortran need to be compiled before installing.

For instructions on the available compilers and preferred options, see the instructions for compiling software on:

Containers

Roihu supports Apptainer/Singularity containers for container installations. In most cases, ready-made Docker containers can be easily converted into an Apptainer image. Another option is to build your own container from scratch. You can build containers on top of Roihu base containers, which have the same software stack as is available via the module system natively. Base containers are built on top of Rocky Linux 9.

Base containers are available:

  • satama.csc.fi/r_installation_spack/core-cpu-gcc-15.2.0:v2026_03

Build definition file:

container.def
Bootstrap: docker
From: satama.csc.fi/r_installation_spack/core-cpu-gcc-15.2.0:v2026_03

%post
    # Activate module environment and load default modules.
    . /opt/activate.sh
    # Build your application here:

%runscript
    . /opt/activate.sh
    exec "$@"

When building the containers, set the Apptainer cache directory to $TMPDIR to avoid filling your home directory quota.

export APPTAINER_CACHEDIR=$TMPDIR
apptainer build --fakeroot container.sif container.def

Now, you can run commands inside the container with the environment active as follows:

apptainer run container.sif mycmd

Base containers are available:

  • satama.csc.fi/r_installation_spack/core-gpu-gcc-15.2.0-cuda-13.1.1:v2026_03
  • satama.csc.fi/r_installation_spack/core-gpu-gcc-14.3.0-cuda-12.9.1:v2026_03
  • satama.csc.fi/r_installation_spack/core-gpu-gcc-13.4.0-cuda-12.6.3:v2026_03

Build definition file:

container.def
Bootstrap: docker
From: satama.csc.fi/r_installation_spack/core-gpu-gcc-14.3.0-cuda-12.9.1:v2026_03

%post
    # Activate module environment and load default modules.
    . /opt/activate.sh
    # Build your application here:

%runscript
    . /opt/activate.sh
    exec "$@"

When building the containers, set the Apptainer cache directory to $TMPDIR to avoid filling your home directory quota.

export APPTAINER_CACHEDIR=$TMPDIR
apptainer build --fakeroot container.sif container.def

Now, you can run commands inside the container with the environment active as follows:

apptainer run --nv container.sif mycmd

Base containers for machine learning/AI are available.

These containers are built on Rocky Linux 9.7 with Python 3, MPI and CUDA installed via RPM packages. This approach produces a container that is not identical to Roihu's host system, but may be easier to extend in some cases than the normal base containers.

  • satama.csc.fi/r_installation_aida/ml-base:rocky9.7_gcc12_py3.12_cuda12.9
  • satama.csc.fi/r_installation_aida/ml-base:rocky9.7_gcc12_py3.12_cuda13
  • satama.csc.fi/r_installation_aida/pytorch-base:2.10_cuda13_roihu - ml-base image with basic PyTorch 2.10 packages added
  • satama.csc.fi/r_installation_aida/pytorch:2.10_cuda13_roihu - full PyTorch installation (same as CSC module)
  • satama.csc.fi/r_installation_aida/vllm:0.19.1_cuda12.9_roihu - vLLM container (same as CSC module)

Build definition file:

container.def
Bootstrap: docker
From: satama.csc.fi/r_installation_aida/ml-base:rocky9.7_gcc12_py3.12_cuda13

%post
    # Build your application here:

When building the containers, set the Apptainer cache directory to $TMPDIR to avoid filling your home directory quota.

export APPTAINER_CACHEDIR=$TMPDIR
apptainer build --fakeroot container.sif container.def

Now, you can run commands inside the container. For example, to launch python3:

apptainer exec --nv --bind=$(csc-common-bind) container.sif python3

More details on working with containers in CSC's computing environment can be found from the links below:

Spack

Spack is a flexible package manager that can be used to install software on supercomputers and Linux and macOS systems. The basic module tree including compilers, MPI libraries and many of the available software on CSC supercomputers have been installed using Spack. Spack is similar to the EasyBuild package manager extensively used on LUMI.

CSC provides user Spack modules on Roihu, that can be used to build software on top of the available compilers and libraries. It is also possible to install different customized versions of packages available in the module tree for special use cases.

See here for a short tutorial on how to install software on Roihu using Spack.

Python/R environments

Best practice guidelines on installing your own Python and R packages can be found in the Python, R and Tykky container wrapper pages below.

Running your first job

Roihu uses Slurm, similarly to Puhti and Mahti.

Basic workflow:

  1. Create a job script where you
    • Define the resources for your job (time, memory, cores)
    • Load the required modules
    • Launch your executable
  2. Submit your batch job to the queuing system
  3. Wait for the job to finish, and look for its output

See the relevant documentation below for detailed information:

  1. Available batch job partitions
  2. Creating a batch job script
  3. Example job scripts
  4. Submit a batch job
  5. Performance checklist

For common Slurm error messages, see our FAQ on Why does my batch job fail?.

More information