Terminal multiplexing: tmux vs Zellij vs Screen

De eerste keer dat het me beet zat ik halverwege een database migratie over SSH. Trein een tunnel in, WiFi knipperde, verbinding weg. Het proces aan de andere kant ging mee. Ik staarde naar een dode prompt en vroeg me af hoeveel van de migratie nou eigenlijk gecommit was.

Een terminal multiplexer had me gered. Het proces draait door op de server of ik nou verbonden ben of niet, dus een weggevallen verbinding wordt een non-event. Ik verbind opnieuw, attach weer, en het werk staat exact waar ik het achterliet. Die eigenschap alleen al is de setup-kosten waard, en daarom behandel ik een multiplexer als basislaag op elke machine die ik aanraak.

Ik zeg er meteen bij waar ik vandaan kom, want dat kleurt alles hieronder. Ik ben terminal-first, keyboard-first, en ik draai al jaren tmux. Die bias is reëel. Ik heb wel serieus tijd doorgebracht in alle drie de grote opties, dus ik kan eerlijk zijn over waar elk z’n sterke kant heeft.

Wat is een terminal multiplexer?

Een multiplexer zit tussen je shell en je terminal emulator. Hij bezit de sessie, en je terminal venster is slechts een kijkgat erop. Maak het kijkgat los en de sessie tikt vrolijk door op zichzelf. Die ene laag indirectie geeft je vier dingen:

• Sessie persistentie: Detach, later opnieuw verbinden, alles draait nog
• Scherm splits: Meerdere panes in één venster
• Window beheer: Schakel tussen workspaces
• Remote pariteit: Zelfde interface of je nu lokaal bent of naar een bak aan de andere kant van het land SSH’t

flowchart LR
    Term["Terminal Emulator"] --> Mux["Multiplexer"]
    Mux --> Shell1["Shell 1"]
    Mux --> Shell2["Shell 2"]
    Mux --> Shell3["Shell 3"]

Voordat ik de drie doorloop, dit is waar ik ze echt op beoordeel. Niet op aantal features, want elk van ze kan een scherm splitsen. Wat dag in dag uit telt is: hoe waarschijnlijk de tool al geïnstalleerd staat als ik op een vreemde bak land, hoeveel config ik moet schrijven voor hij bruikbaar is, of ik commando’s kan ontdekken zonder spiekbriefje, en hoe ver ik hem kan scripten. Performance speelt nauwelijks mee; ze zijn allemaal licht genoeg op moderne hardware. Houd die vier criteria in je achterhoofd terwijl ik ga.

GNU Screen: het origineel

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

Basis gebruik

# 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 zich heeft is dat het er al is. Op een gehardende bak, een vendor appliance, een rescue shell, een of andere oeroude Solaris machine die een klant vergeten was dat-ie bestond: Screen is vaak de enige multiplexer die aanwezig is en je kunt niets anders installeren. Het is stabiel juist omdat niemand het in jaren heeft aangeraakt, en het doet z’n attach/detach werk zonder gedoe.

De prijs verschijnt op het moment dat je meer wilt dan dat. Er is geen visuele feedback, de keybindings zijn cryptisch, de splits zijn “regions” in plaats van echte panes, en scrollback binnen een split is een puinhoop als je een log probeert door te lezen. Niets daarvan maakt uit voor een snelle detach. Alles ervan maakt uit als Screen je daily driver is, en daarom kiest bijna niemand het meer als zodanig.

Dus ik hou Screen achter de hand voor precies één situatie: een server die ik niet beheer waar ik geen software kan installeren en ik gewoon een proces m’n verbinding wil laten overleven. Voor al het andere grijp ik naar iets nieuwers.

tmux: de standaard

tmux is waar de meeste mensen naar grepen toen ze meer wilden dan Screen kon geven. Meer features, een betere interface, en actieve ontwikkeling. Het is ook degene waar ik echt in leef, dus lees de rest met dat in gedachten.

Basis gebruik

# 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

De standaard tmux ervaring is oprecht onhandig, en dit is het eerlijke nadeel. Out of the box is de prefix Ctrl-b, zijn de splits onintuïtief, en vecht je tegen het spiergeheugen dat je in Screen opbouwde. tmux betaalt je wel terug voor het config werk. Hier een praktische ~/.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"

Plugin manager (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

Sla sessies op en herstel ze:

# 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 waarde verdient is configureerbaarheid en scripting. Alles is aanpasbaar, het plugin ecosysteem dekt alles wat je zou willen, en de scripting is de echte prijs: ik kan een hele werkende sessie beschrijven in een shell script en die overal identiek opnieuw opbouwen. Dat sluit precies aan op hoe ik over infrastructuur denk, 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-belasting vooraf. Je krijgt geen mooie tmux gratis, je bouwt er een.

Zellij: de moderne optie

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

Basis gebruik

# Start nieuwe sessie
zellij

# Start benoemde sessie
zellij -s development

# Attach naar sessie
zellij attach development

# Lijst sessies
zellij list-sessions

Wat Zellij onderscheidt is dat-ie de keybindings laat zien terwijl je werkt. De status bar vertelt je wat beschikbaar is in de huidige mode, dus je vindt je weg door te kijken in plaats van te onthouden. Voor iedereen die ooit blanco naar een terminal heeft gestaard om de tmux split binding op te diepen, is dat een echte verbetering.

Standaard keybindings

Zellij gebruikt een modaal systeem:

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 adverteert z’n acties in de status bar, dus ontdekbaarheid zit ingebakken in plaats van erop geplakt.

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 wegwerp-commando zijn heerlijk. De haken zijn dat-ie jong is, dus het plugin ecosysteem is dun vergeleken met tmux, je moet hem zelf installeren, en als je van tmux komt vecht je spiergeheugen een week tegen je. Geen van die dingen is een dealbreaker. Het is de normale prijs van een nieuwere tool die nog geen vijftien jaar overal heeft gestaan.

Vergelijking

Mijn workflow

Dus op welke kwam ik echt uit? tmux, elke dag. Hier de setup achter die keuze.

Config filosofie

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

Sessie structuur

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)

Startup script

#!/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 boven Zellij?

Het eerlijke antwoord is grotendeels padafhankelijkheid. Jaren tmux spiergeheugen, een plugin setup (resurrect en continuum) die ik opnieuw zou moeten bouwen, gescripte sessies waar ik op leun, en het feit dat tmux op elke server staat die ik aanraak. Overstappen zou meer kosten dan het oplevert.

Ik wil duidelijk zijn dat ik hiermee niet zeg dat tmux in abstracto de betere tool is. Als ik vandaag vanaf nul zou beginnen, zonder spiergeheugen om te beschermen, zou ik Zellij serieus bekijken. De ontdekbaarheid is oprecht beter, en nieuwelingen het in een middag zien oppakken maakt de zaak vanzelf. Mijn keuze gaat over mijn context, niet over een oordeel over die van jou.

Aanbevelingen

Kies Screen als:

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

Kies tmux als:

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

Kies Zellij als:

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

Aan de slag

Week 1: leer de basis

Kies er één. Leer deze operaties:

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

Week 2: configureer

Maak het van jou:

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

Week 3: integreer

Bouw in je workflow:

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

Waarom dit ertoe doet

Een proces in leven houden door een weggevallen verbinding is de voor de hand liggende winst, en het is degene waar ik mee opende. De reden dat een multiplexer op elke machine staat die ik bezit gaat dieper dan dat. Hij verandert hoe het werk voelt. Elk project krijgt z’n eigen sessie, dus context leeft ergens persistent in plaats van in mijn hoofd. Windows en panes worden plekken, en na een tijdje weten mijn handen dat logs rechtsonder zitten en de editor in window één zonder dat mijn brein erbij betrokken raakt. Niets trekt me uit flow om een window te gaan zoeken.

Combineer een multiplexer met een editor en shell die je hebt afgesteld, en je krijgt een werkomgeving die identiek is op je laptop en op elke server waar je naar SSH’t. Die portabiliteit is voor mij het hele punt. Ik ben niet hulpeloos op een verse bak, want hetzelfde spiergeheugen werkt overal, en de config reist mee in een git repo die ik beheer in plaats van opgesloten te zitten in de instellingen van een of andere GUI.

De terminal is al low friction computing. Een goede multiplexer drukt de wrijving nog verder omlaag, totdat de tool zelf niet meer registreert en je gewoon aan het werk bent.