Visualization Nodes¶

What are Visualization Nodes?¶

Visualization nodes are specialized compute nodes designed for GPU-accelerated interactive visualization and rendering tasks. Unlike standard GPU nodes which are intended for batch computation, visualization nodes provide a full graphical desktop environment accessible remotely via VNC, making them suitable for running GUI-based applications and interactive visualizations directly on the cluster.

Not for heavy computation

Visualization nodes are intended for visualization and interactive sessions only. Do not use them for training deep learning models, running simulations, or other compute-intensive workloads — use the GPU or CPU partitions for those. Visualization nodes are a shared resource and should be kept available for users who need interactive access.

Typical use cases include:

Interactive 3D visualization of large datasets
Live monitoring of long-running jobs on compute nodes via real-time plots
Inspecting trained model behaviour in reinforcement learning environments
Running GUI-based scientific software without transferring large datasets to a local machine

Hardware

Visualization nodes are equipped with an NVIDIA L4 GPU (23 GB VRAM), optimized for graphics workloads.

Partition

Visualization nodes use the VIZ partition. Always specify --partition=VIZ in your job scripts.

Submitting Batch Jobs¶

Visualization nodes accept standard SLURM batch jobs for non-interactive workloads such as offscreen rendering. This is the same workflow as submitting to any other partition — simply specify --partition=VIZ.

Example batch job script

#!/bin/bash
#SBATCH --job-name=viz_job
#SBATCH --partition=VIZ
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --gres=gpu:1
#SBATCH --time=01:00:00
#SBATCH --output=viz_%j.out

python my_script.py

Submit job

sbatch viz_job.sh

Connecting to a Visualization Node¶

For interactive use, visualization nodes are accessed through a VNC session managed by TurboVNC. Two commands are available for managing your session: viz-connect and viz-kill.

Requirements¶

Install TigerVNC Viewer on your local machine before connecting:

https://tigervnc.org/

Starting a Session¶

Start VNC session

viz-connect

This will first show available visualization nodes and prompt you to select one:

============================================================
              VNC Visualization Service (PERUN)
============================================================
User        : your_username
Login node  : login01
Checking availability of visualization nodes...
------------------------------------------------------------
[1] viz01
     Active sessions : 0
[2] viz02
     Active sessions : 0
------------------------------------------------------------
Select visualization node [1/2]:

Enter 1 or 2 to select a node. Prefer a node with fewer active sessions. After selecting, you will see the connection instructions:

============================================================
Starting VNC session
------------------------------------------------------------
User       : your_username
Node       : viz01
Port       : 5903
============================================================

Desktop 'TurboVNC: viz01:3 (your_username)' started on display viz01:3

============================================================
Connection instructions (from your local machine)
------------------------------------------------------------
1. Create SSH tunnel:
    ssh -L 5903:viz01:5903 your_username@login01.perun.tuke.sk -N
2. Start your VNC client (TigerVNC Viewer):
    localhost:5903
3. Authentication:
    Password: your PERUN password
============================================================

Connecting¶

Open a new terminal on your local machine and run the SSH tunnel command from the output above. The terminal will appear to hang — this is expected, leave it running.
Open TigerVNC Viewer, enter localhost:5903 (or whichever port was assigned) in the VNC server field, and click Connect.
Enter your PERUN username and password when prompted.

You will be connected to a remote desktop running on the visualization node.

Opening a Terminal¶

The desktop environment may not show a terminal on the taskbar. Use the keyboard shortcut Alt+F2 to open a run dialog, type xfce4-terminal, and press Enter.

Ending a Session¶

End VNC session

viz-kill

Always clean up

Run viz-kill when you are done. Leaving sessions running unnecessarily occupies node resources.

Example: Interactive 3D Visualization with PyVista¶

PyVista is a Python library for 3D mesh and volume visualization built on top of VTK. It provides an interactive viewer where you can rotate, zoom, and inspect 3D objects — which requires a display and is best suited for visualization nodes.

Installation¶

Install PyVista

pip install pyvista

Interactive Example¶

Connect to the visualization node via VNC first, then open a terminal and run:

visualize.py

Interactive 3D visualization

import pyvista as pv

mesh = pv.examples.download_bunny()
mesh.plot()

This opens an interactive window displaying the Stanford Bunny mesh. You can rotate and zoom using the mouse. This works because the visualization node provides a GPU-backed display — the same script on a standard GPU node will not open an interactive window.

Example: Real-Time Plot Monitoring¶

A common HPC workflow is running a long computation on a compute node while monitoring its progress interactively on a visualization node. For example, a training job writing metrics to a file can be watched live without waiting for the job to finish.

The visualization node is used only for the live plot — the actual computation should always run on a CPU or GPU compute node.

Installation¶

Install dependencies

pip install matplotlib

Simulation Script¶

simulate.py — in a real scenario this would be your compute job running on a CPU or GPU node, writing results to a shared file. For testing purposes you can run it on the visualization node directly.

Simulation writing output

import time, random, csv

with open('data.csv', 'w') as f:
    writer = csv.writer(f)
    i = 0
    while True:
        writer.writerow([i, random.gauss(0, 1)])
        f.flush()
        i += 1
        time.sleep(0.1)

Live Plot Script¶

plot.py — run this on the visualization node inside your VNC session:

Live updating plot

import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import csv

fig, ax = plt.subplots()

def update(frame):
    ax.clear()
    try:
        with open('data.csv') as f:
            rows = list(csv.reader(f))
            if rows:
                x = [int(r[0]) for r in rows]
                y = [float(r[1]) for r in rows]
                ax.plot(x, y)
                ax.set_title('Live Simulation Output')
    except:
        pass

ani = animation.FuncAnimation(fig, update, interval=200)
plt.show()

To test locally, run simulate.py in one terminal on the visualization node and plot.py in another inside your VNC session. In a real workflow, simulate.py would be replaced by your compute job running on a GPU or CPU node, writing output to a shared path that plot.py reads from. The plot updates every 200ms as new data is written to the file.

Example: Reinforcement Learning Environment Rendering¶

Gymnasium (formerly OpenAI Gym) provides standard reinforcement learning environments with visual rendering support. Rendering these environments requires a display, making visualization nodes the appropriate choice.

A typical use case is visually inspecting how a trained model behaves in an environment — for example, loading a model trained on a GPU compute node and running it through a few episodes to see how it performs. Training itself should always be done on GPU compute nodes, not on visualization nodes.

Installation¶

Install Gymnasium

pip install gymnasium
pip install "gymnasium[classic-control]"

Example¶

cartpole.py

CartPole environment rendering

import gymnasium as gym

env = gym.make("CartPole-v1", render_mode="human")
obs, info = env.reset()

for _ in range(1000):
    action = env.action_space.sample()
    obs, reward, terminated, truncated, _ = env.step(action)
    env.render()
    if terminated or truncated:
        env.reset()

env.close()

Run this inside your VNC session. A window will open showing the CartPole simulation in real time.