1. Open your browser and go tohttps://khpc.kisr.edu.kw/ood/
2. The IKARUS login page loads. Enter your SSH username and password provided by IKARUS administration.
3. If it is your first time, you are asked to add Two-Factor Authentication to an authenticator app of your choice. Otherwise, enter the current code from your authenticator app.
4. Click "Log In".
5. On success you are redirected to the IKARUS Portal dashboard.

The navigation bar is present on every page of the portal. It contains six menus:

The main body of the dashboard shows the My Interactive Sessions panel: cards for all your active or recently completed interactive app sessions. From here you connect to running sessions, check their status, and delete completed ones.

A Delete All Sessions button clears all completed/failed session records in one click, keeping the dashboard tidy.

1. In the top bar click Files → Home Directory. The file browser opens to your home directory.
2. The path bar at the top shows your current location. Click any segment to jump there, or type a path and press Enter.
3. Click a folder name in the listing to enter it. Use the ← back button or path bar to navigate up.

Show Hidden Files

Toggle Show Dotfiles in the toolbar to reveal files beginning with . (such as .bashrc and application config files).

Filter / Search

Use the Filter box in the toolbar to narrow the file listing by name within the current directory.

Method 1: Drag and Drop

1. Navigate to the destination directory in the file browser.
2. Drag one or more files from your local file manager and drop them into the portal file browser window.
3. A progress indicator appears. Wait until each file shows 100% before navigating away.

Method 2: Upload Button

1. Navigate to the destination directory.
2. Click "Upload" in the toolbar.
3. Select files in the file picker that appears. Uploads begin immediately.

1. Navigate to the directory containing the files you want.
2. Check the checkbox to the left of each file or folder you want to download.
3. Click "Download" in the action toolbar that appears at the top. Files are saved to your browser's downloads folder.

New Directory

1. Navigate to where you want the new folder.
2. Click "New Dir" in the toolbar.
3. Type the name and press Enter.

New File

1. Navigate to the target directory.
2. Click "New File" in the toolbar.
3. Type the filename (including extension, e.g. job.sh) and press Enter.

Actions on Existing Files

Check the checkbox next to any file or directory to reveal the action toolbar:

The built-in web editor lets you edit job scripts, configuration files, and any text file directly in the browser.

1. Check the checkbox next to the file, then click "Edit" or click the filename directly for text files.
2. The editor opens in a new browser tab with syntax highlighting (detected from the file extension).
3. Make your changes, then press "Ctrl+S" (or click Save) to save back to the cluster.
4. Close the tab when done.

Click Jobs → Active Jobs in the navigation bar. Click Refresh to update, or enable Auto-refresh to poll automatically.

Filtering

Use the Filter field to search by name, user, or ID. Toggle Your Jobs to show only your own activity.

1. Find your job. Confirm the "User" column matches your username.
2. Click the red trash icon to the right of the row.
3. Confirm in the dialog that appears.
4. The job moves to CANCELLED state and is removed from the queue.

Access via Jobs → Job Composer. The page shows saved jobs on the left and a detail/editor panel on the right.

1. Click + New Job then choose "From Default Template".
2. A new job entry appears. Click it to open the detail panel.
3. Click "Open Editor" in the detail panel. The script opens in a new tab.
4. Write your #SBATCH directives and commands. Save with "Ctrl+S".
5. Close the editor tab and return to the Job Composer.

1. Select the job from the list.
2. Optionally change the "Submit Directory", click the folder icon to browse.
3. Click the green "Submit" button.
4. On success a banner shows the assigned "Job ID". Monitor in Jobs → Active Jobs.

Save as Template

1. Select a working job, then click "Copy to Templates" (star icon).
2. Give it a descriptive name (e.g. Python 8-core 32G Res) and save.

Create from Template

1. Click + New Job → From Template.
2. Select your template. A copy is created and you can edit specific parameters before submitting.

1. Click Clusters → IKARUS Shell Access in the navigation bar.
2. A new tab opens with a full terminal emulator. You are automatically logged in as your IKARUS user on clavis.
3. Prompt confirms connection:

[hpcdemo@clavis2 ~]$ 

• Navigate the filesystem and manage files
• Load environment modules (module avail, module load)
• Submit and monitor SLURM jobs (sbatch, squeue, scancel)
• Start an interactive compute session with srun
• Compile code and run quick tests
• Transfer files with scp or rsync

squeue -me                                    # your jobs only
sbatch my_job.sh                              # submit a batch job
srun --partition=Res --cpus-per-task=4 \
     --mem=8G --time=01:00:00 bash -l        # interactive compute session
module avail                                  # list available modules
du -sh /NFS/scratch/homes/${USER}            # check disk usage

1. Click Interactive Apps in the header and select the application you want.
2. A launch form appears. Fill in the resource fields.
3. Click "Launch".
4. You are redirected to the My Interactive Sessions dashboard. A session card appears.
5. Wait for the card to show "Running" (blue header).
6. Click "Connect to [App Name]" to open the application in a new tab.

Reconnecting to a Running Session

If you close the app tab, the session continues running. Return to the IKARUS Portal dashboard, find your Running session card, and click "Connect" again.

Ending a Session

1. Quit the application normally (e.g. File → Quit in MATLAB, close the Jupyter tab).
2. Return to the IKARUS Portal dashboard. The session card should show "Completed".
3. Click the "Delete" (trash) button on the card.

Delete All Sessions Button

Removes all completed and failed session cards at once. Running sessions must be deleted individually after ending the application.

Multiple Sessions

You can run multiple interactive sessions simultaneously (e.g. JupyterLab and a Desktop session at the same time), subject to your resource quota.

1. Click Connect to Desktop on the session card. The desktop opens via noVNC in a new tab.
2. An XFCE desktop is shown. Right-click the desktop for a context menu, or use the panel at the top.
3. Open a Terminal Emulator (Applications → Terminal Emulator, or right-click → Open Terminal). Load modules and launch any application from here.
4. Launch GUI apps with an ampersand to keep the terminal free: matlab &, paraview &

noVNC Controls

1. After connecting, JupyterLab opens. The left panel shows a file browser rooted at your home directory. The right panel shows the Launcher.
2. Click a kernel tile in the Launcher (e.g. Python 3) to open a new notebook, or use File → Open from Path to open an existing .ipynb file.
3. Write code in cells and press Shift+Enter to run. Output appears directly below.
4. Use the file browser (left panel) to navigate directories and open additional files.

Available Kernels

IKARUS provides six shared pre-configured kernels accessible to all users from /NFS/shared/libraries/jupyter/kernels/. These appear in the JupyterLab Launcher automatically; no installation or configuration required.

Installing Packages

# In a notebook cell: installs to your home directory
!pip install --user package_name

# For R:
install.packages("ggplot2")

1. After connecting, RStudio opens with four panels: Source (top-left), Console (bottom-left), Environment/History (top-right), Files/Plots/Help (bottom-right).
2. Use the Console for interactive R commands, or open/create .R scripts in the Source panel.
3. Set your working directory: setwd("/NFS/scratch/homes/username/my_project"), or use File → New Project.
4. Browse cluster files in the Files tab (bottom-right).

Installing R Packages

install.packages("ggplot2")
install.packages(c("dplyr", "tidyr", "data.table"))

Packages install to your personal R library in your home directory and persist across sessions.

1. After connecting, the MATLAB desktop opens in VNC: Command Window, Workspace, and file browser are visible.
2. Use the Command Window for interactive commands, or open .m files in the MATLAB Editor.
3. Set your working directory: cd('/NFS/scratch/homes/username/my_project')
4. Run scripts with the green Run button or by typing the script name.

Parallel Computing

% Create a local parallel pool using the cores you requested
parpool('local', 8);

% Use parfor for parallelised loops
parfor i = 1:100
    result(i) = my_function(i);
end

1. After connecting, ParaView opens in VNC with its Pipeline Browser, Properties panel, and 3D render view.
2. Open data: File → Open. Supported formats include VTK, EnSight, OpenFOAM, netCDF, HDF5, Exodus, CGNS, and more.
3. Click Apply in the Properties panel to load and render the data.
4. Use the Pipeline Browser to add filters (Clip, Threshold, Contour, Warp, Streamlines…).
5. Navigate the 3D view: left-drag to rotate, middle-drag to pan, scroll to zoom.

1. After connecting, QGIS opens in VNC with its map canvas, Layers panel (left), and toolbars.
2. Add data via Layer → Add Layer or drag files from the QGIS Browser panel. Supported: GeoTIFF, Shapefile, GeoPackage, WMS/WFS/WCS, PostGIS, and more.
3. Use the Processing Toolbox (Processing → Toolbox) for hundreds of spatial analysis algorithms.
4. Store your GIS data in /NFS/scratch/homes/username/ for best performance.

1. After connecting, VS Code opens in a new browser tab, identical to the desktop application.
2. Click File → Open Folder and navigate to your project at /NFS/scratch/homes/username/my_project.
3. Edit files from the Explorer panel (left sidebar) with full syntax highlighting and IntelliSense.
4. Open the Integrated Terminal (Ctrl+` or View → Terminal). This is a full shell on the compute node: load modules, run code, and submit jobs without leaving VS Code.

Recommended Extensions

Press Ctrl+Shift+X to browse and install. Extensions store in your home directory and persist across sessions:

• Python: IntelliSense, linting, debugging
• Jupyter: Run .ipynb notebooks inside VS Code
• R: R language support and LSP integration
• GitLens: Enhanced Git history, blame, and diff views
• Remote-SSH: Connect to the cluster from your local VS Code outside the portal

SIESTA does not accept file uploads through the launch form directly. Instead, you stage your files on the cluster first, then point the form at their paths:

1. Upload your .fdf input file and all pseudopotential files to your home directory using the file browser.
2. In the launch form, enter the full path to your .fdf file (e.g. /NFS/scratch/homes/username/my_calc/input.fdf).
3. Enter the full path to the directory containing your pseudopotential files. Everything in that directory is copied into the job's working directory automatically, so pseudopotentials and any other auxiliary files can live together.

1. After launching, the session runs SIESTA as a blocking MPI job for the duration of your calculation.
2. On completion, your output files (.out, .XV, and others) are written to a job-specific working directory under your home directory.
3. Retrieve your results via the file browser, or open a terminal in the VNC session to inspect them directly.

1. Stage your Delft3D output files on the cluster in advance, using the file browser.
2. After connecting, Quickplot opens directly in the VNC session.
3. Use Quickplot's own file open dialog to browse to and load your staged output file.
4. Use Quickplot's plotting tools to inspect structured or unstructured grid results.

1. Prepare your model folder on the cluster with all required files, using the file browser.
2. Fill in the launch form with your model folder path and desired resources, then launch.
3. A desktop session opens with a live terminal showing simulation progress.
4. On successful completion, Quickplot launches automatically for immediate visualisation.
5. If the simulation fails, an error terminal opens showing the end of the error log so you can diagnose the issue; the session stays open for inspection.

1. Upload your FVCOM input files (grid, forcing data, and casename.nml) to your home directory using the file browser.
2. Set Nprocs in your casename.nml to match Nodes × MPI tasks per node exactly.
3. Select the physics variant matching your simulation's requirements.
4. If using the Base variant, set any physics toggles you need. The app patches your casename.nml automatically before launch.
5. Choose a post-processing visualiser and optionally specify the output file to open automatically.
6. Launch. A live terminal opens showing simulation progress.
7. On success, your chosen visualiser opens automatically with the results. On failure, an error terminal opens showing the end of the error log.

• Run geogrid.exe once for your domain beforehand; the required geo_em.d01.nc (and additional domains if nested) must already be present in your run directory.
• namelist.input must be fully configured for your domain (grid spacing, dimensions, physics, and chemistry options). The app only sets the start date/time and interval automatically.
• namelist.wps must be configured for your domain and projection. The app sets the start date, interval, and met data source automatically.
• GRIB input files from your chosen global model must already be staged in your met data directory.

1. Complete the prerequisites above, staging your run directory and meteorological data via the file browser.
2. Fill in the launch form and submit.
3. The pipeline runs automatically: ungrib, then metgrid, then real.exe, then wrf.exe, in sequence.
4. Monitor progress via Active Jobs. There is no live desktop or terminal for this app.
5. When the job completes, retrieve your output files via the file browser.

Test Run

Choose a single source location, season, and year to run one simulation task interactively. A live terminal in the VNC session shows progress; on completion, trajectory plots open automatically.

Full Run

Submits a complete 200-task ensemble covering all source locations, seasons, and years. A monitoring terminal in the VNC session tracks task progress. Once the full ensemble and post-processing complete, QGIS opens automatically with the resulting hazard atlas loaded.

1. Log in to the portal at khpc.kisr.edu.kw/ood/
2. Click Tools in the top navigation bar.
3. Select the tool you want from the drop-down.

Use the same public tracking URI everywhere, whether inside a Slurm job script or from your own machine:

https://khpc.kisr.edu.kw/mlflow/

For any language or tool that respects environment variables, set MLFLOW_TRACKING_URI in your Slurm job script. MLFlow's autologging can automatically capture parameters and metrics for supported frameworks (scikit-learn, TensorFlow, PyTorch, XGBoost, LightGBM, Keras):

export MLFLOW_TRACKING_URI="https://khpc.kisr.edu.kw/mlflow/"
export MLFLOW_EXPERIMENT_NAME="batch_simulation_run"

python3 -c "import mlflow; mlflow.autolog()"

A pre-configured MLFlow Experiment template is available in the Job Composer. It sets MLFLOW_TRACKING_URI and a starting experiment name automatically. Click + New Job → From Template and select it to get started without writing the boilerplate yourself, then edit the script path and parameters for your own run.

MLFlow experiment names are global on the shared tracking server. Two researchers using the same experiment name will have their runs merged into the same experiment. Adopt a naming convention to avoid collisions:

1. Click Tools → MLFlow in the portal, or open khpc.kisr.edu.kw/mlflow/ directly.
2. Select an experiment from the left sidebar to see all its runs.
3. Click a run to see its logged parameters, metrics, and artifacts.
4. Use the comparison view to select multiple runs and compare metrics side-by-side.
5. Artifacts are served through MLFlow directly. Model files and plots can be downloaded from the browser.

Checking Your Disk Usage

du -sh /NFS/scratch/homes/${USER}           # total home directory usage
du -sh /NFS/scratch/homes/${USER}/*/        # breakdown by subdirectory
find /NFS/scratch/homes/${USER} -type f \
  -printf '%s %p\n' | sort -rn | head -20  # find largest files

Which partitions you can access depends on your account. The Interactive Apps launch forms automatically show only the partitions available to you.

The IKARUS Cluster Status panel is shown in two places, both displaying the same live information:

• Automatically on the portal dashboard, directly below the Recently Used Apps tiles, every time you log in.
• By clicking Clusters → System Status in the top navigation bar from anywhere in the portal.

The panel gives a quick, at-a-glance read of how busy the cluster currently is:

Host: hpc.kisr.edu.kw  ·  Port: 22  ·  Username: your KISR username

1. Download MobaXterm (Portable edition) from mobaxterm.mobatek.net.
2. Unzip and launch MobaXterm_Personal_*.exe.
3. Click Session → SSH. Set Remote host: hpc.kisr.edu.kw, Username: your KISR username, Port: 22.
4. Click OK and enter your password when prompted (input is hidden).
5. A successful login shows a prompt like:

[hpcdemo@clavis1 ~]$ 

1. Open Terminal (Mac: Applications → Utilities → Terminal).
2. Run the SSH command with X11 forwarding enabled:

$ ssh -Y hpcdemo@hpc.kisr.edu.kw

1. On first connection, type yes to accept the RSA fingerprint.
2. Enter your password when prompted (not displayed on screen).
3. On success you will see the shell prompt: [hpcdemo@clavis1 ~]$

Every file and directory has a 10-character permission string shown by ls -l. For example: drwxr-xr-x

Each permission letter:

• r (Read): view or copy the file, or list directory contents
• w (Write): modify the file, or create/delete files in a directory
• x (Execute): run the file as a program, or enter a directory
• –: permission not granted

Format: chmod [who][action][permission] file

chmod u+x script.sh                      # make script executable by owner
chmod a+x script.sh                      # executable by everyone
chmod u+rwx,g+rx file.sh                 # owner: full access; group: read+execute
chmod o-x *                              # remove execute from others on all files
chmod g-w sensitive.txt                  # remove group write permission
chmod 755 script.sh                      # octal: rwxr-xr-x
chmod 644 data.csv                       # octal: rw-r--r--

gzip / gunzip: Single File Compression

gzip filename.c                          # compress → filename.c.gz
gunzip filename.c.gz                     # decompress

tar: Archive and Compress Directories

tar -czvf archive.tar.gz my_project/    # create compressed archive of directory
tar -xzvf archive.tar.gz                # extract archive here
tar -xzvf archive.tar.gz -C /target/    # extract to a specific directory
tar -tzvf archive.tar.gz                # list contents without extracting
gzip -l archive.tar.gz                  # show compression ratio and sizes

All modules are stored at /NFS/shared/modules/ and are accessible on every node.

Modules loaded in your interactive terminal session are not inherited by batch jobs. Always include module load commands inside your submission script:

#!/bin/bash
#SBATCH --job-name=python_job
#SBATCH --partition=Res
#SBATCH --cpus-per-task=8
#SBATCH --mem=32G
#SBATCH --time=01:00:00

# Load modules here (inside the script)
module purge                             # start from a clean state
module load python/3.10
module load openmpi/4.1.5

# Your code
python3 my_script.py

sbatch: Submit a Batch Script

Submits a script to run asynchronously on compute nodes. Returns immediately with the assigned Job ID.

[hpcdemo@clavis2 ~]$ sbatch my_job.sh
Submitted batch job 568

srun: Interactive Session on a Compute Node

Requests resources and gives you a shell on a compute node. Blocks until resources are available.

[hpcdemo@clavis2 ~]$ srun --partition=Res --nodes=1 \
  --cpus-per-task=4 --mem=8G --time=01:00:00 bash -l

squeue: View the Queue

squeue                                                # all jobs across all users
squeue -me                                            # your jobs only
squeue -u hpcdemo                                     # jobs for a specific user
squeue -p Res                                         # jobs in the Res partition
squeue --start                                        # estimated start times for pending jobs
squeue -o "%.10i %.9P %.20j %.8u %.8T %.10M %.6D %R"  # custom output format

squeue State Codes

sacct: Job History and Accounting

Query completed and historical jobs from the SLURM accounting database.

sacct --user=$USER --starttime=today                           # your jobs from today
sacct --user=$USER --starttime=2025-08-01                      # since a specific date
sacct --jobs=568                                               # details for job 568
sacct --jobs=568 --format=JobID,State,ExitCode,Elapsed,MaxRSS  # custom fields

scancel: Cancel a Job

scancel 568                              # cancel job 568 (must be your job)
scancel -u $USER                         # cancel ALL your jobs
scancel -u $USER -t PENDING              # cancel only your pending jobs

sinfo: Cluster State

sinfo                                    # partition and node summary
sinfo -N -o "%-20N %-10c %-12m %-10P"    # per-node: name, CPUs, RAM(MB), partition
sinfo -p Res                             # show only the Res partition

sstat: Live Resource Usage of a Running Job

sstat --jobs=568                         # all resource stats for job 568
sstat --jobs=568 --format=JobID,AveCPU,AveRSS,MaxRSS

Job arrays submit the same script N times, each with a unique SLURM_ARRAY_TASK_ID. Useful for running the same analysis on many input files.

#!/bin/bash
#SBATCH --job-name=array_example
#SBATCH --partition=Res
#SBATCH --array=1-16               # creates 16 jobs, IDs 1..16
#SBATCH --cpus-per-task=1
#SBATCH --mem-per-cpu=4G
#SBATCH --time=00:30:00
#SBATCH --output=logs/job_%a.out   # %a = array task ID

module load python/3.10

# Use SLURM_ARRAY_TASK_ID to select input
INPUT_FILE="data/input_${SLURM_ARRAY_TASK_ID}.csv"
OUTPUT_FILE="results/output_${SLURM_ARRAY_TASK_ID}.csv"

echo "Processing task ${SLURM_ARRAY_TASK_ID}: ${INPUT_FILE}"
python3 process.py --input ${INPUT_FILE} --output ${OUTPUT_FILE}