Terminal multiplexing: tmux vs Zellij vs Screen

De eerste keer dat het me beet zat ik halverwege een databasemigratie over SSH. Trein een tunnel in, wifi weg, verbinding weg, en het proces aan de andere kant ging mee. Ik zat naar een dode prompt te kijken en had geen idee hoeveel van die migratie nou gecommit was.

Een multiplexer had me dat uur gescheeld. Het proces draait door op de server, of ik nou verbonden ben of niet, dus een weggevallen verbinding kost me een reconnect en verder niks. Ik attach opnieuw en het werk staat waar ik het achterliet. Dáárom gaat een multiplexer op elke machine die ik aanraak, nog voor de editor en de dotfiles.

Eén ding vooraf. Ik draai al jaren tmux en ben niet van plan daarmee te stoppen, dus lees de rest met dat in je achterhoofd. In Screen en Zellij heb ik ook serieus tijd gestoken, genoeg om te weten waar ze tmux verslaan, en dat zeg ik dan ook gewoon.

Wat een terminal multiplexer doet

Een multiplexer zit tussen je shell en je terminalemulator. Hij bezit de sessie, en je terminalvenster is een kijkgat erop. Sluit het kijkgat en de sessie draait gewoon door. Die ene laag indirectie levert je vier dingen op:

• Sessiepersistentie: detach, later opnieuw verbinden, alles draait nog
• Schermsplits: meerdere panes in één venster
• Windowbeheer: schakelen tussen workspaces
• Remote-pariteit: dezelfde interface, of je nou lokaal zit of via SSH op een bak aan de andere kant van het land

Voor ik de drie doorloop, dit is waar ik ze op beoordeel. Niet op het aantal features, want alle drie kunnen ze een scherm splitsen. Vier dingen tellen voor mij dag in dag uit. Hoe groot de kans is dat de tool al geïnstalleerd staat als ik op een vreemde bak beland. Hoeveel config ik moet schrijven voor hij bruikbaar is. Of ik een commando kan vinden zonder spiekbriefje. En hoe ver ik hem kan scripten. Performance speelt nauwelijks mee; alle drie zijn ze licht genoeg voor alles wat dit decennium gebouwd is.

GNU Screen, het origineel

Screen bestaat sinds 1987. Het staat overal geïnstalleerd, en het ziet eruit alsof het in 1987 ontworpen is.

Basisgebruik

# Start nieuwe sessie
screen

# Start benoemde sessie
screen -S development

# Detach (vanuit screen)
Ctrl-a d

# Lijst sessies
screen -ls

# Reattach
screen -r development

# Split horizontaal
Ctrl-a S

# Split verticaal
Ctrl-a |

# Schakel tussen regions
Ctrl-a Tab

# Maak nieuw window
Ctrl-a c

# Schakel windows
Ctrl-a n  # volgende
Ctrl-a p  # vorige
Ctrl-a 0  # window 0

Wat Screen voor heeft is dat het er al staat. Een gehardende bak, een vendor appliance, een rescue shell, die Solaris-machine waarvan een klant vergeten was dat-ie bestond. Daar is Screen vaak de enige multiplexer die er is, en een andere installeren kan niet. Het is stabiel omdat niemand er in jaren aan gezeten heeft, en attachen en detachen is het enige wat ik er ooit van vraag.

De prijs komt zodra je meer wilt. Geen visuele feedback, cryptische keybindings, splits die “regions” heten in plaats van echte panes, en scrollback binnen een split is een puinhoop als je een log wilt doorlezen. Voor een snelle detach kan me dat niks schelen. Als daily driver zou het me allemaal schelen, en daarom kiest bijna niemand Screen daar nog voor.

Dus Screen hou ik achter de hand voor één situatie. Een server die ik niet beheer, waar ik niks mag installeren, en een proces dat m’n verbinding moet overleven. Al het andere krijgt iets nieuwers.

tmux, de standaard

tmux is waar de meeste mensen heen gingen zodra ze meer wilden dan Screen geeft. Meer features, een betere interface, actieve ontwikkeling. Het is ook de tool waar ik in leef.

Basisgebruik

# Start nieuwe sessie
tmux

# Start benoemde sessie
tmux new -s development

# Detach
Ctrl-b d

# Lijst sessies
tmux ls

# Attach
tmux attach -t development

# Split horizontaal
Ctrl-b "

# Split verticaal
Ctrl-b %

# Navigeer panes
Ctrl-b Pijltjestoetsen

# Resize panes
Ctrl-b Ctrl-Pijltjestoetsen

# Maak window
Ctrl-b c

# Schakel windows
Ctrl-b n  # volgende
Ctrl-b p  # vorige
Ctrl-b 0  # window 0

# Kill pane
Ctrl-b x

Configuratie

Kale tmux is onhandig, en dat is het terechte verwijt. Out of the box is de prefix Ctrl-b, zijn de split-bindings " en %, die niemand raadt, en vechten je Screen-gewoontes tegen je. tmux betaalt het configwerk wel terug. Hier een ~/.tmux.conf die het ergste van de defaults fikst:

# Betere prefix
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Start windows en panes bij 1, niet 0
set -g base-index 1
setw -g pane-base-index 1

# Hernummer windows wanneer er een sluit
set -g renumber-windows on

# Makkelijke splits (intuïtiever)
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Vim-stijl pane navigatie
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Resize panes met vim toetsen
bind -r H resize-pane -L 5
bind -r J resize-pane -D 5
bind -r K resize-pane -U 5
bind -r L resize-pane -R 5

# Muis ondersteuning (optioneel, sommigen verkiezen keyboard-only)
set -g mouse on

# Verhoog scrollback
set -g history-limit 50000

# Wacht niet op escape sequences
set -sg escape-time 0

# Status bar
set -g status-style 'bg=#333333 fg=#ffffff'
set -g status-left '#[fg=#00ff00][#S] '
set -g status-right '%H:%M %d-%b'

# Herlaad config
bind r source-file ~/.tmux.conf \; display "Config herladen"

Pluginmanager (TPM)

Installeer TPM voor plugins:

# Installeer TPM
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# In .tmux.conf
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'  # Sla sessies op/herstel
set -g @plugin 'tmux-plugins/tmux-continuum'  # Auto-save sessies

# Initialiseer TPM (onderaan .tmux.conf)
run '~/.tmux/plugins/tpm/tpm'

Druk prefix + I om plugins te installeren.

Sessiebeheer

Sessies opslaan en herstellen:

# Met tmux-resurrect plugin
prefix + Ctrl-s  # Opslaan
prefix + Ctrl-r  # Herstellen

# Handmatige sessie scripts
# ~/.tmux/dev-session.sh
tmux new-session -d -s dev -n editor
tmux send-keys -t dev:editor 'nvim' C-m
tmux new-window -t dev -n server
tmux send-keys -t dev:server 'npm run dev' C-m
tmux new-window -t dev -n git
tmux attach -t dev

Waar tmux z’n geld verdient is configureerbaarheid en scripting. Alles is aanpasbaar en het plugin-ecosysteem dekt alles wat je zou willen. De scripting zou ik het meest missen. Ik kan een hele werkende sessie in een shellscript beschrijven en die identiek opbouwen op elke machine. Dat is dezelfde gewoonte die ik bij infrastructuur heb, waar de config opgeschreven en reproduceerbaar is in plaats van één keer in elkaar geklikt en vergeten. De ruil is de leercurve en de config die je vooraf schrijft. Een comfortabele tmux krijg je niet cadeau, die schrijf je zelf.

Zellij, de moderne optie

Zellij is de nieuwkomer. Geschreven in Rust, en gebouwd rond het idee dat je niks uit je hoofd hoeft te leren om hem te gebruiken.

Basisgebruik

# Start nieuwe sessie
zellij

# Start benoemde sessie
zellij -s development

# Attach naar sessie
zellij attach development

# Lijst sessies
zellij list-sessions

Wat Zellij anders maakt is dat-ie de keybindings laat zien terwijl je werkt. De statusbar zet neer wat er in de huidige mode kan, dus je vindt je weg door te kijken in plaats van te onthouden. Op een bak zonder m’n eigen config twijfel ik na al die jaren nog steeds welke van " en % welke kant op splitst. Bij Zellij heb ik dat moment nooit gehad.

Standaard keybindings

Zellij werkt modaal:

Ctrl-p → Pane mode
  n: nieuwe pane
  d: sluit pane
  h/j/k/l: navigeer

Ctrl-t → Tab mode
  n: nieuwe tab
  x: sluit tab
  h/l: navigeer
  r: hernoem

Ctrl-n → Resize mode
  h/j/k/l: resize

Ctrl-s → Scroll mode
  j/k: scroll
  d/u: pagina omlaag/omhoog

Ctrl-o → Session mode
  d: detach
  w: sessie manager

Ctrl-q → Quit

Elke mode zet z’n acties in de statusbar, dus zoeken hoef je nooit.

Configuratie

~/.config/zellij/config.kdl:

// Thema
theme "catppuccin-mocha"

// Standaard layout
default_layout "compact"

// Keybindings
keybinds {
    normal {
        // Vim-achtige pane navigatie
        bind "Alt h" { MoveFocus "Left"; }
        bind "Alt j" { MoveFocus "Down"; }
        bind "Alt k" { MoveFocus "Up"; }
        bind "Alt l" { MoveFocus "Right"; }
    }
}

// Opties
pane_frames false  // Geen borders tussen panes
simplified_ui true  // Schonere status bar
default_shell "zsh"
scrollback_editor "/usr/bin/nvim"

Layouts

Definieer herbruikbare layouts in ~/.config/zellij/layouts/:

// dev.kdl
layout {
    pane split_direction="vertical" {
        pane {
            command "nvim"
        }
        pane split_direction="horizontal" {
            pane {
                command "lazygit"
            }
            pane
        }
    }
}

Start met layout:

zellij --layout dev

Plugins

Zellij ondersteunt WebAssembly plugins:

// In config.kdl
plugins {
    tab-bar { path "tab-bar"; }
    status-bar { path "status-bar"; }
    strider { path "strider"; }  // Bestandsbrowser
    compact-bar { path "compact-bar"; }
}

Zellij’s defaults zijn verstandig, de layouts zijn herbruikbaar, en floating panes voor een snel wegwerpcommando zijn heerlijk. De haken zijn er wel, maar klein. Hij is jong, dus het plugin-ecosysteem is dun naast dat van tmux. Je moet hem zelf installeren. En kom je van tmux, dan vecht je spiergeheugen een week tegen je. Dat is de normale prijs van een tool die nog geen vijftien jaar op elke server heeft gestaan.

Vergelijking

Mijn workflow

Dus waar kwam ik op uit? tmux, elke dag. Hier de setup daarachter.

Configfilosofie

# Minimaal, keyboard-first
# Ctrl-a als prefix (makkelijker dan Ctrl-b)
# Vim-stijl navigatie
# Geen muis (houdt handen op toetsenbord)
# Minimale status bar

Sessiestructuur

Development sessie:
├── Window 1: editor (nvim)
├── Window 2: terminal (algemene commando's)
├── Window 3: git (lazygit)
└── Window 4: servers (split panes voor logs)

Homelab sessie:
├── Window 1: k9s (Kubernetes)
├── Window 2: monitoring (Prometheus/Grafana toegang)
└── Window 3: logs (Loki queries)

Startupscript

#!/bin/bash
# ~/.local/bin/dev

SESSION="dev"

# Check of sessie bestaat
tmux has-session -t $SESSION 2>/dev/null

if [ $? != 0 ]; then
    # Maak sessie
    tmux new-session -d -s $SESSION -n editor
    tmux send-keys -t $SESSION:editor 'nvim' C-m

    tmux new-window -t $SESSION -n term

    tmux new-window -t $SESSION -n git
    tmux send-keys -t $SESSION:git 'lazygit' C-m

    tmux new-window -t $SESSION -n servers
    tmux split-window -h -t $SESSION:servers
fi

# Attach
tmux attach -t $SESSION

Waarom tmux en niet Zellij

Het antwoord is vooral padafhankelijkheid. Jaren tmux-spiergeheugen, een pluginsetup (resurrect en continuum) die ik opnieuw zou moeten bouwen, gescripte sessies waar ik op leun, en tmux dat op elke server staat die ik aanraak. Overstappen kost me meer dan het oplevert.

Dat zegt iets over mijn situatie, en ik zou het jammer vinden als het als oordeel over Zellij gelezen wordt. Zou ik vandaag vanaf nul beginnen, zonder spiergeheugen om te beschermen, dan bekeek ik Zellij serieus. Commando’s aflezen van de statusbar wint het van onthouden, en ik heb mensen die nog nooit een multiplexer hadden gebruikt er in een middag productief in zien worden. Zit er in jouw context minder tmux dan in de mijne, dan kan het antwoord zomaar omslaan.

Aanbevelingen

Wanneer Screen de juiste keuze is

• Je werkt op servers die je niet beheert
• Je iets nodig hebt dat zeker geïnstalleerd is
• Simpele attach/detach voor lange processen

Wanneer tmux de juiste keuze is

• Je maximale customization wilt
• Je plugin ondersteuning nodig hebt
• Je tijd investeert in configuratie
• Je op veel machines werkt

Wanneer Zellij de juiste keuze is

• Je nieuw bent met multiplexers
• Je direct goede UX wilt
• Je moderne tooling verkiest
• Je ontdekbaarheid waardeert

Aan de slag

Week 1, de basis

Kies er één. Leer deze operaties:

• Maak/attach/detach sessie
• Split panes
• Navigeer tussen panes
• Maak windows
• Navigeer tussen windows

Week 2, maak het van jou

• Verander prefix toets (tmux/Screen)
• Stel comfortabele keybindings in
• Configureer status bar
• Stel scrollback grootte in

Week 3, bouw het in je workflow

• Maak sessie scripts
• Stel sessie persistentie in
• Integreer met editor/shell

Waarom dit ertoe doet

Een proces een weggevallen verbinding laten overleven is de voor de hand liggende winst, en daar opende ik mee. De reden dat een multiplexer op elke machine van mij blijft staan is dat-ie verandert hoe het werk voelt. Elk project krijgt z’n eigen sessie, dus de context leeft ergens persistent in plaats van in m’n hoofd. Windows en panes worden plekken. Na een tijdje weten m’n handen dat de logs rechtsonder zitten en de editor in window één, zonder dat m’n brein erbij geroepen wordt. Niks trekt me uit m’n flow om een window te gaan zoeken.

Zet een multiplexer naast een editor en een shell die je hebt afgesteld en je hebt dezelfde werkomgeving op je laptop en op elke server waar je naar SSH’t. Die portabiliteit is voor mij het hele punt. Op een verse bak ben ik niet hulpeloos, want dezelfde toetsen werken overal, en de config reist mee in een git-repo die ik beheer in plaats van vast te zitten in de instellingen van een of andere GUI.

De terminal is al low friction computing, en een multiplexer haalt er nog meer wrijving uit. De volgende keer dat een tunnel m’n verbinding opeet, attach ik aan de andere kant opnieuw en pak ik de migratie op waar die was.

• CLI
• Desktop