On this page

SSH and VS Code Guide for ELIC Users

This step-by-step guide will help you understand what SSH is, what a remote server is, and how to use Visual Studio Code (VS Code) to connect to one.

This tutorial also introduces Linux shell basics, some essential commands, and good practices for safely working in the terminal.

It’s written for complete beginners - no prior Linux or SSH knowledge required.

This page is open source, powered by the Forge

Technical considerations

What is a Remote Server?

A server is simply another computer - often a Linux machine - that runs 24/7, possibly located elsewhere (in your company, a data center, or the cloud).

You can connect to it from your own computer and use it to:

Host websites or applications
Store and process data
Run code continuously

When we say remote machine or remote server, we just mean “another computer you access over the Internet or local network.”

What is SSH?

SSH stands for Secure Shell.

It’s a secure way to connect to another computer and run commands there — as if you were sitting in front of it.

When you connect with SSH, everything you type and see is encrypted.

Example SSH command:

ssh user@server-address

Once connected, you can:

Browse files on the remote machine
Run scripts or code
Use development tools remotely

What is Visual Studio Code (VSCode)?

VSCode is a free, open-source code editor made by Microsoft. It can run on Windows, macOS, and Linux.

With the Remote - SSH extension, VSCode can:

Connect to a remote machine via SSH
Open and edit files directly on that machine
Run and debug code as if it were local

What is a Terminal

A terminal (called CLI or Command Line Interface) is where you enter commands from the keyboard and gives them to the operating system to perform, instead of using GUI (Graphical User Interface) with mouse, windows, etc.

To open a terminal:

Windows: Use Windows Terminal, PowerShell, or WSL (Windows Subsystem for Linux)
Linux: Press Ctrl+Alt+T or search for Terminal in your applications
macOS: Press Cmd+Space, type Terminal, and open it

What are Git and GitHub

Git is a distributed version control system used to manage source code and track changes during software development.

GitHub is a web-based platform for version control and collaboration, primarily using Git. It allows you :

to store your project code online
to create a secure backup and enabling access from any computer
to track changes to your code over time, saving different versions of your project, which is known as “committing”. This means you can revert to a previous working version if you make a mistake

Access

CISM account

The initials CISM stand for “Calcul Intensif et Stockage de Masse”, or high-performance computing and mass storage. It was created in 2004 at UCLouvain. The CISM operates the scientific computing clusters and the scientific data storage systems installed at UCLouvain.

In order to connect to the server, a CISM account is required. To create one, you first need to be connected to the UCLouvain network, i.e. via the wireless network or a computer in a didactic room.

Visit the following web address
Submit your @student.uclouvain.be email adress via the form.
Follow the link that you will nearly instantly receive by email.
Fill in the form with the following details:

Setting	Value
Supervisor email	your teaching assistant `@uclouvain.be` email
Intended usage	Interactive computing only
Institution	ELI > ELIC

Submit the form for validation by an administrator.

Install Visual Studio Code

Windows

Install Visual Studio Code

Go to the VSCode installer web link
Download the Windows Installer (.exe)
Run it and check:
- Add to PATH
- Register as default editor for supported file types
Finish the installation and start VSCode.

Check if SSH works on your computer

Windows now includes an SSH client by default.

You can test it by opening a PowerShell or Command Prompt window and typing:

ssh

If you see usage instructions, it’s installed !

If not, you can install the OpenSSH Client:

Open Settings -> Apps -> Optional Features
Click Add a feature
Search for OpenSSH Client and install it.

macOS

brew install --cask visual-studio-code

Linux (Debian/Ubuntu)

sudo apt update
sudo apt install wget gpg
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /usr/share/keyrings/
sudo sh -c 'echo "deb [arch=amd64 signed-by=/usr/share/keyrings/packages.microsoft.gpg] \
https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install code

Install the “Remote - SSH” extension

Open VSCode
Go to the Extensions panel (or press Ctrl+Shift+X)
Search for Remote - SSH
Install the one published by Microsoft

Create an SSH configuration file

You can save your SSH connection settings in a config file so you don’t have to remember IP addresses or usernames.

Windows

Open File Explorer
Go to your user folder:
```
C:\Users\yourWindowsUserName\
```
Inside it, open (or create) a folder called .ssh (note the dot at the beginning - .ssh)

Inside that folder, create a file called:

config

(no extension - just config)

Now edit the file in VSCode or Notepad and add the following :

Host *
  ServerAliveInterval 60
  User yourCISMuserName
  ForwardX11 yes
  IdentityFile C:\Users\yourWindowsUserName\.ssh\id_ed25519

Host gwcism
  HostName gwcism.cism.ucl.ac.be

Host cyclone
  HostName cyclone.elic.ucl.ac.be
  ProxyJump gwcism
Host coriolis
  HostName coriolis.elic.ucl.ac.be
  ProxyJump gwcism
Host meteor
  HostName meteor.elic.ucl.ac.be
  ProxyJump gwcism

replace yourWindowsUserName with your own PC Windows username

replace yourCISMuserName with your CISM username

Create your SSH key by opening a PowerShell or Command Prompt window and typing:

ssh-keygen -t ed25519

and always press Enter until the key is displayed.

Now copy the public key to your servers :

type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh gwcism "mkdir -p ~/.ssh 2> /dev/null && cat > ~/.ssh/authorized_keys"

type $env:USERPROFILE\.ssh\id_ed25519.pub | ssh coriolis "mkdir -p ~/.ssh 2> /dev/null && cat > ~/.ssh/authorized_keys"

macOS - Linux

Open a terminal and do:
```
cd
ssh-keygen -t rsa
```
(always press Enter after the last command)

Create a config file:

touch ~/.ssh/config

Now edit the file in VSCode or Vim and add the following :

Host *
  ServerAliveInterval 60
  User yourCISMuserName
  ForwardX11 yes
  IdentityFile ~/.ssh/id_rsa

Host gwcism
  HostName gwcism.cism.ucl.ac.be

Host cyclone
  HostName cyclone.elic.ucl.ac.be
  ProxyJump gwcism
Host coriolis
  HostName coriolis.elic.ucl.ac.be
  ProxyJump gwcism
Host meteor
  HostName meteor.elic.ucl.ac.be
  ProxyJump gwcism

replace yourCISMuserName with your CISM username

Copy the public key to your servers:

ssh-copy-id -i  ~/.ssh/id_rsa.pub gwcism
ssh-copy-id -i  ~/.ssh/id_rsa.pub coriolis

Connect to a Remote Server with VSCode

Open VS Code.
Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Remote-SSH: Connect to Host...
```
You should see your entry (e.g. cyclone) from the SSH config file.
Click it to connect.
VS Code will open a new window (with a green bar at the bottom showing the remote host name).

The first time, it may take a minute to install the VSCode Server on your remote machine.

Browse and edit remote files

Once connected:

Open the Explorer sidebar to see your remote folders.
You can open, edit, or create files directly.
Drag files from your local computer into the remote Explorer to upload them.
Right-click files → Download… to bring them back to your computer.

You can also use the built-in Terminal (Ctrl+`) to run Linux commands remotely.

Beginner’s guide to the Linux Command Line

Introduction to the shell (terminal):

A very short intro on the Linux terminal here
A longer intro on the Linux terminal here

Basic Shell commands

Here are essential commands to navigate and manage files:

Command	Description	Example
`pwd`	Show current directory	`pwd` → `/home/user`
`ls`	List files and folders	`ls -l` (detailed)
`cd`	Change directory	`cd Documents`
`mkdir`	Create a folder	`mkdir myfolder`
`touch`	Create an empty file	`touch file.txt`
`cp`	Copy files	`cp file.txt file_copy.txt`
`mv`	Move or rename files	`mv file.txt archive/`
`rm`	Delete files	`rm file.txt`
`rm -r`	Delete files and/or folder recursivel	`rm -r myfolder/`
`cat`	View file content	`cat file.txt`

Tip: Use ls -a to see hidden files (starting with .).

Paths

Some facts about paths to directories and files:

When you connect to a Linux server, you land in your HOME directory.
The absolute path of your HOME directory is: /home/elic/MY_LOGIN. Anywhere in the file tree, execute the cd command to return the HOME directory.
Absolute paths are always written with respect to the root of the file tree, i.e. /.
A typical absolute path to a file would be: /home/elic/MY_LOGIN/lsdtt/data/dem-analysis/mnt-ambleve-10m.tif. Notice the / at the beginning of the path, indicating that it is an absolute path, i.e. starting from the root.
A typical relative path to a file - if you are located in your HOME directory - is dem-analysis/mnt-ambleve-10m.tif. Note that there is no / at the beginning of the path.
Relative paths are always expressed relatively to the current directory.
To know the current directory, use the pwd command (print working directory).

Viewing and searching files

less file.txt → Scroll through a file interactively
head file.txt → See the first 10 lines
tail file.txt → See the last 10 lines
grep "pattern" file.txt → Search for a word or phrase

Example:

grep "error" logs.txt

File Permissions

Every file and folder has permissions:

r → read
w → write
x → execute

Check permissions with:

ls -l

-rw-r--r--.  1 pbarriat grpelic     73368 Mar 10  2021  sphere.jpg
drwxr-xr-x.  2 pbarriat grpelic        19 Dec  4  2019  src
-rw-r--r--.  1 pbarriat grpelic 217480548 Jan 29  2018  tas_regular.nc
drwxr-xr-x.  2 pbarriat grpelic         2 Oct 11  2019  Templates
-rw-r--r--.  1 pbarriat grpelic       903 Dec  2  2024  ten_minute_script.R
-rwxr-xr-x.  1 pbarriat grpelic    806896 Dec  2  2020  test.exe
-rw-r--r--.  1 pbarriat grpelic       341 Mar 10  2021  test.m
-rw-r--r--.  1 pbarriat grpelic      1891 Oct  6  2022  test.py
-rw-r--r--.  1 pbarriat grpelic       579 Jul 17  2023  test_R.R
-rwxr-xr-x.  1 pbarriat grpelic       230 Jul 23  2018  test.sh
-rw-r--r--.  1 pbarriat grpelic        19 Sep 28  2023  test_vscode.py
drwxr-xr-x. 10 pbarriat grpelic        31 Sep 12 11:40  tmp

Change permissions:

chmod u+x script.sh    # Make a script executable by the owner

Good practices for the Shell

Working on the terminal can be difficult in the beginning.

Start in your home directory (~)

Avoid working in system directories unless necessary.
Use pwd command

One difficulty is to always know where you are located in the file tree. Use pwd command to print the current directory.
Over use ls command

Use ls (list) or ll (long list) commands to print the content of the current directory. Use it often!
Use Tab completion

Type the first letters and press Tab to autocomplete filenames and directory names. Press Tab key again to get a list of possibilities, if there are several ones.
Use History

Press Up and Down arrows of the keyboard to navigate in the history of commands that you already executed.
Check before deleting

rm is permanent - use ls first to confirm.
Use man pages

Example: man ls shows all options for ls.
Keep backups

Copy important files before modifying.
Combine commands safely

Example: ls | grep "file" filters results.
Use clear folder and file names

Avoid spaces; use _ or - instead.

Tip: practice these commands daily in your home directory. Start small and explore safely - the shell is very powerful!

Useful Shortcuts

Shortcut	Action
`Ctrl+C`	Stop a running command
`Ctrl+D`	Log out or exit shell
`Ctrl+L`	Clear terminal screen
`Up/Down arrow`	Browse command history
`Tab`	Autocomplete filenames or commands

Troubleshooting

“Remote Host Identification Has Changed”

The Remote Host Identification Has Changed warning appears when your SSH client detects a mismatch between the server’s current public key and the one stored in your local known_hosts file. This can happen for legitimate reasons such as a server rebuild, OS reinstall, IP change, or SSH key regeneration.

Or it could indicate a potential man-in-the-middle attack

How to fix it safely ?

Verify the server is trusted (confirm you’re connecting to the correct server)
Remove the old key entry:
```
ssh-keygen -R <hostname_or_IP>
```
This removes the old key from ~/.ssh/known_hosts.
After removal, reconnect via SSH: you’ll be prompted to accept the new host key.

Confirm with yes only if you trust the server.

For Windows (PowerShell/WSL):

Navigate to %USERPROFILE%\.ssh\ and edit known_hosts to remove the line for the affected IP/hostname.
Or use the command: ssh-keygen -R <IP>

Important: Only remove the key if you are certain the server is legitimate. Never ignore this warning when connecting to a server you don’t control: this could expose you to a man-in-the-middle attack.

ELIC environment

The research conducted in the Earth and Climate pole (ELIC) aim at understanding the functioning of the Earth system, with focus on its climate component, and human-environment interactions.

ELIC is part of Earth and Life Institute (ELI) at UCLouvain.

ELIC workstations

In ELIC, there are several remote servers available for students and researchers. Each server is a Linux machine that you can connect to in order to:

Run simulations or data analysis
Develop code
Store or share files with collaborators

However, for security reasons, these servers are not directly reachable from the Internet.
This means that if you are working from home or any external network, you cannot SSH directly into them.

The Gateway machine (Jump Host)

To protect the internal network, access from outside goes through a special computer called a gateway (also known as a jump host).

Think of the gateway as a secure checkpoint between your computer and the internal servers: - You first connect to the gateway. - Then, from the gateway, you connect to the target server.

Example:

# Step 1: Connect to the gateway from home
ssh yourname@gwcism.cism.ucl.ac.be

# Step 2: From the gateway, connect to a specific server
ssh yourname@meteor.elic.ucl.ac.be

So the connection path looks like this:

Your laptop  >  Gateway  >  Internal Server

When you’re on the UCLouvain Wi-Fi

If you’re already on the UCLouvain’s internal Wi-Fi network, you are already inside the secure network, so the gateway is not required.

In that case, you can connect directly:

ssh yourname@meteor.elic.ucl.ac.be

Automating Gateway Access

If you often connect through the gateway, you can simplify your workflow using your SSH config file (~/.ssh/config).

SSH will automatically go through the gateway for you.

We already did this in the section “Create an SSH configuration file” above.

List of machines

Machine	Cores	Memory	Access
aurora	18 - 2.6 GHz	128GB	CISM account in ELIC group
meteor	20 - 2.2 GHz	128GB	CISM account in ELIC group
coriolis	32 - 3.7 GHz	128GB	CISM account in ELIC group
cyclone	32 - 3.7 GHz	128GB	CISM account in ELIC group
vortex	32 - 4.0 GHz	256GB	CISM account in F.Massonnet group

List of gateways

Hostname	Restrictions
gwcism.cism.ucl.ac.be	none
gw.elic.ucl.ac.be	authentication with SSH key only
gwceci.cism.ucl.ac.be	authentication with CECI SSH key only - “Jump Host” only

Topology

Download topology here.

The “modules” environment system

On shared research servers or HPC (High-Performance Computing) clusters, many different software versions are installed side by side:
different versions of compilers (gcc, intel), MPI, Python, libraries, etc.

To manage this complexity, these systems use a tool called Environment Modules (also known as Lmod or simply module).

What is a module ?

A module is a small configuration file that sets up the right environment variables so that specific software can run correctly.
It changes things like: - Your $PATH (so the right executables are found) - Library paths (e.g., $LD_LIBRARY_PATH) - Compiler or MPI environment variables

Instead of manually editing your environment, you just load a module.

Why use modules ?

Modules let you: - Easily switch between different software versions - Avoid conflicts between tools (e.g., two MPI versions) - Reproduce the same environment as other users - Keep your shell environment clean and organized

Common `module` commands

Command	Description
`module avail` or `module av`	List all available modules on the system
`module list`	Show which modules are currently loaded
`module load <name>`	Load one or more modules
`module unload <name>`	Unload one or more modules
`module purge`	Unload all currently loaded modules
`module show <name>`	Display details about what a module changes

Example: loading a compiler and a tool

Let’s say you want to use gcc and python modules available on the system.

# List available modules
module avail

# Example output:
# --------------------- /opt/modulefiles ---------------------
# gcc/11.3.0    python/3.10.6    openmpi/4.1.5

# Load what you need
module load gcc/11.3.0
module load python/3.10.6

# Check which modules are now active
module list

You might see:

Currently Loaded Modules:
  1) gcc/11.3.0
  2) python/3.10.6

Now when you run:

gcc --version
python --version

you’ll get the correct versions defined by those modules.

Cleaning up

If your environment becomes messy or you want to start fresh:

module purge

This removes all loaded modules and resets your environment.

You can then load only what you need again.

ELIC/CISM services

nextcloud: self-hosted alternative to services like Dropbox or Google Drive.
jupyterhub: interactive Python computing and data analysis
shiny: interactive R web applications for data visualization
UCLouvain forge: central Git service for UCLouvain
gogs: central Git service for ELIC

ELIC training

Next steps

Once you’re comfortable connecting via Linux and SSH, you can:

Install extensions in VSCode

Once you’re connected to your remote server with VS Code Remote - SSH, you can enhance your coding experience by installing language-specific extensions in your local environment and/or directly in the remote environment.

This allows you to:

Run and debug code both on the local and on the remote machine
Use linting, intelliSense and code completion
Keep your local VS Code lightweight while all the computation happens remotely

Example: installing the Python extension

Local VS Code

Open the Extensions sidebar (Ctrl+Shift+X)
Search for: Python and install “Python” (by Microsoft)

Remote-SSH - VS Code

When you connect to a remote host:

VS Code runs a lightweight VS Code Server on that machine.
Each extension you install (e.g. Python, Fortran, C++) is installed on the remote host, not your local computer.
Extensions run in the same environment where your code and compilers exist.

You’ll see a small indicator in the Extensions panel: > Installed on SSH: <hostname>

Connect to your remote host via Remote - SSH
Open the Extensions sidebar (Ctrl+Shift+X)
Search for: Python and install “Python” (by Microsoft)

Example: installing Fortran support

In the remote VS Code window, go to the Extensions sidebar.
Search for: Modern Fortran
Install the Modern Fortran extension (by Krvajal). Open a .f90 or .f95 file - syntax highlighting, autocomplete, and linting should activate.

To enable linting or compilation checks, ensure you have a compiler like gfortran loaded (see the Modules section above) on the remote system.

You can then configure build tasks in VS Code to compile and run Fortran programs directly.

Other useful language extensions

Language Recommended	Extension	Notes
Bash/Shell	ShellCheck	Syntax validation and linting
Python	Jupyter (by Microsoft)	Provides a web-based application called Jupyter Notebook
Any	Tabnine	code faster with AI code completions
Any	Regex Previewer	shows the current regular expression’s matches completions

Using Git integration in VS Code

Visual Studio Code includes powerful built-in Git integration that lets you manage your source control directly from the editor.

Prerequisites

Git installed on your system

To use git in VSCode, first make sure you have git installed on your computer: download here.

keep everything by default during the install process
GitHub/GitLab account
- github.com
- forge.uclouvain.be

Configure `git` in VSCode

Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Open User Settings JSON
```

Check if the following lines exist, or add them. For Linux:

{
   "terminal.integrated.profiles.linux": {
       "bash_login": {
           "path": "/usr/bin/bash",
           "args": ["-l"]
       }
   },
   "terminal.integrated.defaultProfile.linux": "bash_login"
}

or for Windows:

{
   "terminal.integrated.profiles.windows": {
       "GitBash_with_GitPath": {
           "path": "C:\\Program Files\\Git\\bin\\bash.exe",
           "args": ["--login"],
           "env": {
               "PATH": "C:\\Program Files\\Git\\bin;C:\\Program Files\\Git\\usr\\bin;${env:PATH}"
           }
       }
   },
   "terminal.integrated.defaultProfile.windows": "GitBash_with_GitPath"
}

Close and reopen VS Code
Open the Source Control panel (icon with branching tree)
Click Clone Repository
Enter this example as URL : https://forge.uclouvain.be/elic/learning.git > Accept all and “Trust” the folder

GitLab with 2FA enabled

The UCLouvain Forge is based on a 2FA UCLouvain account. So if you try to clone/push a repository and you get:

Cloning into 'learning-git'...
Username for 'https://forge.uclouvain.be': barriat
Password for 'https://barriat@forge.uclouvain.be': 
remote: HTTP Basic: Access denied. The provided password or token is incorrect or your account has 2FA enabled and you must use a personal access token instead of a password. See https://forge.uclouvain.be/help/topics/git/troubleshooting_git#error-on-git-fetch-http-basic-access-denied
fatal: Authentication failed for 'https://forge.uclouvain.be/elic/learning.git/'

You must create and use a token:

How to create an use a token

How to load Python module with VS Code via Remote-SSH

First, install the Python extension on your remote host via Remote-SSH (see section above)

Open VSCode.
Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Open User Settings JSON
```

Check if the following lines exist, or add them. For Linux:

{
   "terminal.integrated.profiles.linux": {
       "bash_login": {
           "path": "/usr/bin/bash",
           "args": ["-l"]
       }
   },
   "terminal.integrated.defaultProfile.linux": "bash_login"
}

or for Windows:

{
   "terminal.integrated.profiles.windows": {
       "GitBash_with_GitPath": {
           "path": "C:\\Program Files\\Git\\bin\\bash.exe",
           "args": ["--login"],
           "env": {
               "PATH": "C:\\Program Files\\Git\\bin;C:\\Program Files\\Git\\usr\\bin;${env:PATH}"
           }
       }
   },
   "terminal.integrated.defaultProfile.windows": "GitBash_with_GitPath",
   "terminal.integrated.profiles.linux": {
       "bash_login": {
           "path": "/usr/bin/bash",
           "args": ["-l"],
           "env": {
               "PATH": "/usr/local/bin:/usr/bin:/bin:${PATH}"
           }
       }
   },
   "terminal.integrated.defaultProfile.linux": "bash_login"
}

Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Remote-SSH: Connect to Host...
```
You should see your entry (e.g. coriolis) from the SSH config file.
Click it to connect. > The first time, it may takes one or two minutes to install the VSCode Server on your remote machine.
Open a terminal and type code ~/.bash_profile

Check if the following lines exist, or add them:

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

# Load modules automatically 
if command -v module &> /dev/null; then
  case "$(hostname -s)" in
      meteor|coriolis)
          module purge
          module load releases/2024a
          module load ELIC_Python/1-foss-2024a
          ;;
      cyclone|vortex)
          module purge
          module load releases/2025b
          module load ELIC_Python/1-foss-2025b
          ;;
      *)
          echo "Not a special server"
          ;;
  esac
fi

Save and close the file. Close remote connection and close the window.
Connect to the host again Remote-SSH: Connect to Host...
Once connected, open a terminal and type ml. In the result, you must see a long list of loaded modules, including ELIC_Python (the last one). > if not, something’s wrong with your setup. Go back and check carefully all the previous steps.

Open a terminal and type:

 which python

And copy the result line, something like

/opt/easybuild/soft/2024a/software/Python/3.12.3-GCCcore-13.3.0/bin/python

Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Open Remote Settings JSON
```
Check if the following line exist, or add it:
```
{
 "python.defaultInterpreterPath": "/opt/easybuild/soft/2024a/software/Python/3.12.3-GCCcore-13.3.0/bin/python"
}
```
Path may change according the machine and the module used. So take the result from step 14 here.
It’s over: now your remote setup is ready to use a “full” ELIC Python environment.

How to load R module with VS Code via Remote-SSH

Follow the instructions in the section above until step 9, then:

Check if the following lines exist, or add them:

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

# Load modules automatically 
if command -v module &> /dev/null; then
  case "$(hostname -s)" in
      meteor|coriolis)
          module purge
          module load releases/2024a
          module load ELIC_Python/1-foss-2024a
          ;;
      cyclone|vortex)
          module purge
          module load releases/2025b
          module load ELIC_R/1-foss-2025b
          ;;
      *)
          echo "Not a special server"
          ;;
  esac
fi

Save and close the file. Close remote connection and close the window.
Connect to the host again Remote-SSH: Connect to Host...
Once connected, open a terminal and type ml. In the result, you must see a long list of loaded modules, including ELIC_R (the last one). > if not, something’s wrong with your setup. Go back and check carefully all the previous steps.

Open a terminal and type:

 which R

And copy the result line, something like

/opt/easybuild/soft/2025b/software/R/4.5.2-gfbf-2025b/bin/R

Press Ctrl+Shift+P to open the Command Palette.
Type:
```
Open Remote Settings JSON
```

Check if the following line exist, or add it:

{
"r.rpath.linux": "/opt/easybuild/soft/2025b/software/R/4.5.2-gfbf-2025b/bin/R",
"r.rterm.linux": "/opt/easybuild/soft/2025b/software/R/4.5.2-gfbf-2025b/bin/R"
}

Path may change according the machine and the module used. So take the result from step 14 here.

It’s over: now your remote setup is ready to use a “full” ELIC R environment.

How to launch Jupyter from a terminal on remote ELIC machine

This guide will walk you through:

Connecting to a remote server via SSH
Loading the appropriate software module (using EasyBuild’s module system)
Starting a Jupyter Notebook server
Creating a secure SSH tunnel to access the notebook in your local browser

SSH into the Remote Server

From your local terminal:

ssh your_username@meteor.elic.ucl.ac.be

Replace your_username with your actual login.

Load the required module

Load the required Python/Jupyter module:

module load releases/2024a
module load ELIC_Python/1-foss-2024a

Use module av to list available modules. Adjust names/versions accordingly.

Launch Jupyter Notebook on the Remote Server

Start Jupyter without opening a browser and bind to localhost only:

jupyter notebook --no-browser --port=8888

This will output a link containing a token, e.g.:

http://localhost:8888/?token=abcd1234...

Leave this terminal open!

Create an SSH tunnel from your local machine

On your local machine, open a new terminal and run:

ssh -N -f -L 8888:localhost:8888 your_username@meteor.elic.ucl.ac.be

This forwards your local port 8888 to the remote server’s port 8888.

Access the Notebook in your local browser

Now, in your local browser, go to:

http://localhost:8888/?token=abcd1234...

Use the token printed by the remote jupyter notebook command.

Tips

If port 8888 is in use, replace it with another free port (e.g. 8890) in both steps 4 and 5.
You can create a virtual environment and install packages via pip or use preinstalled modules.
Use screen, tmux, or nohup if you want Jupyter to persist after logout.

To stop everything

Press Ctrl+C in the Jupyter terminal to stop the server (Remote Server).
Close the SSH tunnel terminal (Local Machine).

SSH and VS Code Guide for ELIC Users

Technical considerations

What is a Remote Server?

What is SSH?

What is Visual Studio Code (VSCode)?

What is a Terminal

What are Git and GitHub

Access

CISM account

Install Visual Studio Code

Windows

Install Visual Studio Code

Check if SSH works on your computer

macOS

Linux (Debian/Ubuntu)

Install the “Remote - SSH” extension

Create an SSH configuration file

Windows

macOS - Linux

Connect to a Remote Server with VSCode

Browse and edit remote files

Beginner’s guide to the Linux Command Line

Introduction to the shell (terminal):

Basic Shell commands

Paths

Viewing and searching files

File Permissions

Good practices for the Shell

Useful Shortcuts

Troubleshooting

“Remote Host Identification Has Changed”

ELIC environment

ELIC workstations

The Gateway machine (Jump Host)

When you’re on the UCLouvain Wi-Fi

Automating Gateway Access

List of machines

List of gateways

Topology

The “modules” environment system

What is a module ?

Why use modules ?

Common module commands

Example: loading a compiler and a tool

Cleaning up

ELIC/CISM services

ELIC training

Next steps

Install extensions in VSCode

Example: installing the Python extension

Local VS Code

Remote-SSH - VS Code

Example: installing Fortran support

Other useful language extensions

Using Git integration in VS Code

Prerequisites

Configure git in VSCode

GitLab with 2FA enabled

How to load Python module with VS Code via Remote-SSH

How to load R module with VS Code via Remote-SSH

How to launch Jupyter from a terminal on remote ELIC machine

SSH into the Remote Server

Load the required module

Launch Jupyter Notebook on the Remote Server

Create an SSH tunnel from your local machine

Access the Notebook in your local browser

Tips

To stop everything

Common `module` commands

Configure `git` in VSCode