Was ist Zellij?

Zellij ist ein moderner Terminal-Workspace, geschrieben in Rust. Er positioniert sich als Next-Generation-Alternative zu tmux und GNU Screen. Das Kernkonzept lautet „Batteries included" – also sofort einsatzbereit. Du erhältst leistungsstarke Terminal-Multiplexing-Funktionen ohne aufwendige Konfiguration.

Warum brauchst du Zellij?

Wenn du regelmäßig mit dem Terminal arbeitest – sei es für Entwicklung, DevOps oder Systemadministration – kennst du sicher folgende Situationen:

  • Du führst mehrere Dienste gleichzeitig aus (Frontend, Backend, Datenbank) und musst ständig zwischen verschiedenen Fenstern wechseln.
  • Nach einer SSH-Verbindung zu einem Remote-Server werden alle Prozesse unterbrochen, sobald die Verbindung abbricht.
  • Du möchtest einen komplexen Arbeitszustand speichern und beim nächsten Mal direkt dort weitermachen.
  • Für die Teamarbeit musst du Terminal-Sessions teilen, um gemeinsam zu debuggen oder Code zu reviewen.

Die klassischen Lösungen sind tmux oder GNU Screen. Doch beide haben eine steile Lernkurve. Die Standardkonfiguration ist spartanisch. Viele erweiterte Funktionen erfordern manuell geschriebene Konfigurationsdateien.

Zellij zielt darauf ab, genau diese Schmerzpunkte zu lösen:

Feature tmux Zellij
Lernkurve Steil, viele Shortcuts auswendig lernen Flach, integrierte Hilfe und Standard-Layouts
Schwebende Panels ❌ Nicht unterstützt ✅ Nativ unterstützt
Gestapelte Panels ❌ Nicht unterstützt ✅ Nativ unterstützt
Web-Client ❌ Drittanbieter-Tools nötig ✅ Eingebaut
Session-Wiederherstellung ⚠️ Plugin erforderlich (tmux-resurrect) ✅ Nativ unterstützt
Plugin-System Shell-Skripte WebAssembly (Rust/jede Sprache)
Layout-Automatisierung Shell-Skripte schreiben KDL-deklarative Konfiguration
Programmiersprache C Rust

Zellij vs. tmux: Die wichtigsten Unterschiede

  1. Benutzerfreundlichkeit: Zellij bietet standardmäßig eine intuitive Benutzeroberfläche (Statusleiste, Tabs). Bei tmux musst du erst konfigurieren, um Ähnliches zu erreichen.
  2. Schwebende Panels: Zellij erlaubt es, Panels über anderen Panels „schweben" zu lassen. Ideal für Überwachungsbefehle wie top oder htop, während du parallel andere Arbeiten erledigst.
  3. Web-Client: Zellij hat einen eingebauten Webserver. Du kannst deine Terminal-Session über den Browser aufrufen – ganz ohne Zusatztools.
  4. Session-Resurrection: Schließe Zellij und öffne es später wieder. Alle Panels, Befehle und der Verlauf werden wiederhergestellt. Sogar nach einem Neustart des Systems.
  5. Plugin-Ökosystem: Zellij-Plugins basieren auf WebAssembly. Du kannst sie in Rust, Go, C oder jeder anderen Sprache schreiben, die zu WASM kompiliert werden kann. Das ist sicherer.

Zellij installieren

Zellij läuft unter Linux, macOS und Windows (WSL). Hier sind die gängigsten Installationsmethoden:

Methode 1: Offizielles One-Click-Installations-Skript (empfohlen)

BASH 
# Bash/Zsh
bash <(curl -L https://zellij.dev/launch)

# Fish
bash (curl -L https://zellij.dev/launch | psub)

# PowerShell
irm https://zellij.dev/launch.ps1 | iex

Das Skript erkennt automatisch dein Betriebssystem und deine Architektur. Es lädt die neueste Version von Zellij herunter und installiert sie.

Methode 2: Installation über Paketmanager

macOS (Homebrew):

BASH 
brew install zellij

Linux (Ubuntu/Debian):

BASH 
# APT-Repository hinzufügen
echo "deb [trusted=yes] https://dl.cloudsmith.io/public/zellij-org/releases/deb/debian any-version main" | sudo tee /etc/apt/sources.list.d/zellij.list
sudo apt update
sudo apt install zellij

Arch Linux:

BASH 
sudo pacman -S zellij

Fedora:

BASH 
sudo dnf install zellij

Methode 3: Kompilieren aus dem Quellcode

Falls du eine benutzerdefinierte Version benötigst:

BASH 
# Stelle sicher, dass die Rust-Toolchain installiert ist
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Repository klonen
git clone https://github.com/zellij-org/zellij.git
cd zellij

# Kompilieren und installieren
cargo install --path zellij

Installation überprüfen

BASH 
zellij --version

Die Ausgabe sollte ähnlich aussehen wie zellij 0.42.0.

Schnellstart: Deine erste Zellij-Session

Zellij starten

Führe im Terminal einfach Folgendes aus:

BASH 
zellij

Du siehst sofort eine neue Oberfläche. Oben befindet sich die Tab-Leiste, unten die Statusleiste. Standardmäßig erstellt Zellij einen Tab namens „main" und ein Terminal-Panel.

Grundlegende Bedienung

Alle Zellij-Shortcuts beginnen mit Strg + g (der sogenannte „Mode Key"). Hier sind die häufigsten Aktionen:

Aktion Shortcut Beschreibung
Neues Panel Strg+g → n Teilt das aktuelle Panel horizontal
Neues vertikales Panel Strg+g → h Teilt das aktuelle Panel vertikal
Panel wechseln Strg+g → Pfeiltasten Fokus zwischen Panels verschieben
Panelgröße anpassen Strg+g → r → Pfeiltasten Resize-Modus aktivieren
Neuer Tab Strg+g → t Erstellt einen neuen Tab
Tabs wechseln Strg+g → p / n Vorheriger/nächster Tab
Panel schließen Strg+g → x Aktuelles Panel schließen
Zellij beenden Strg+g → q Aktuelle Session verlassen

Tipp: Drücke Strg+g → ?, um jederzeit die vollständige Shortcut-Liste anzuzeigen.

Schwebende Panels

Schwebende Panels sind eines der Highlight-Features von Zellij. Ein Panel „schwebt" über anderen Panels und belegt keinen festen Platz im Raster.

Schwebende Panels aktivieren:

BASH 
# Shortcut: Alt + f

Oder über den Befehlsmodus:

BASH 
Strg+g → : → toggle_floating_panes

Typische Anwendungsfälle:

BASH 
# Führe htop in einem schwebenden Panel aus, um Systemressourcen zu überwachen
htop

# In einem anderen schwebenden Panel Logs verfolgen
tail -f /var/log/syslog

# Im Hauptpanel weiterhin Code schreiben oder andere Befehle ausführen

Schwebende Panels können verschoben und in der Größe angepasst werden. Du kannst sie sogar „anheften" (pin), damit sie immer im Vordergrund bleiben.

Gestapelte Panels

Gestapelte Panels ermöglichen es, mehrere Panels vertikal übereinander zu stapeln. Das spart horizontalen Bildschirmplatz.

Gestapeltes Panel erstellen:

BASH 
# Erstelle zuerst zwei normale Panels, dann:
Strg+g → : → toggle_stack

Zwischen gestapelten Panels wechseln:

BASH 
# Mit den Pfeiltasten nach oben/unten navigieren

Gestapelte Panels eignen sich besonders für: - Mehrere Editor-Puffer griffbereit halten - Mehrere Befehlsausgaben überwachen, ohne viel Bildschirmplatz zu verbrauchen - Arbeitsbereiche nach Aufgaben oder Kontext organisieren

Session-Management: Arbeitszustände speichern und wiederherstellen

Session-Manager

Zellij verfügt über eine leistungsstarke Session-Management-Funktion. Du kannst mühelos zwischen verschiedenen Arbeitsumgebungen wechseln.

Session-Manager öffnen:

BASH 
Strg+g → w

Es erscheint eine visuelle Auswahl aller Sessions. Du kannst: - Alle laufenden Sessions anzeigen - Neue Sessions mit benutzerdefinierten Namen erstellen - Zu Hintergrund-Sessions wechseln - Zuvor beendete Sessions wiederherstellen

Willkommensbildschirm

Beim ersten Start von Zellij kannst du den Willkommensbildschirm nutzen:

BASH 
zellij -l welcome

Der Willkommensbildschirm bietet eine Art „Startmenü". Dort kannst du: - Sessions visuell auswählen - Neue Sessions erstellen - Zuvor beendete Sessions wiederherstellen

Session-Resurrection

Dies ist eine der einzigartigsten Funktionen von Zellij: Selbst wenn du Zellij schließt oder deinen Computer neu startest, kannst du beim nächsten Öffnen deinen gesamten Arbeitszustand wiederherstellen. Dazu gehören:

  • Layout und Größe aller Panels
  • Die in jedem Panel ausgeführten Befehle
  • Der Scroll-Verlauf
  • Umgebungsvariablen und Arbeitsverzeichnisse

So stellst du eine Session wieder her:

BASH 
# Zellij normal starten und dann über den Session-Manager die gewünschte Session auswählen
zellij
Strg+g → w → Wähle die zuvor beendete Session

Oder direkt beim Start angeben:

BASH 
zellij attach <session-name>

Das ist extrem nützlich für lang laufende Tasks wie Kompilierungen, Tests oder Datenverarbeitung. Selbst bei unerwarteten Verbindungsabbrüchen oder Neustarts kannst du nahtlos weiterarbeiten.

Layout-Automatisierung: Definiere deine Entwicklungsumgebung

Mit dem Layout-System von Zellij kannst du deine gesamte Entwicklungsumgebung deklarativ mit KDL definieren. KDL ist ein menschenlesbares Konfigurationsformat.

Was ist ein Layout?

Ein Layout ist eine .kdl-Datei. Sie beschreibt: - Wie viele Tabs es gibt - Welche Panels sich in jedem Tab befinden - Welche Befehle in jedem Panel ausgeführt werden - Größe und Position der Panels - Ob schwebende oder gestapelte Panels verwendet werden

Einfaches Layout-Beispiel

Erstelle eine Datei namens my-project.kdl:

KDL 
layout {
    tab name="Backend" {
        pane split_direction="Vertical" {
            pane command="cargo" args=["run"]
            pane command="npm" args=["run", "dev"]
        }
    }
    tab name="Database" {
        pane command="psql" args=["-U", "postgres", "-d", "mydb"]
    }
}

Layout verwenden:

BASH 
zellij --layout my-project.kdl

Das führt automatisch Folgendes aus: 1. Zwei Tabs erstellen: „Backend" und „Database" 2. Im Tab „Backend" vertikal in zwei Panels aufteilen. Diese führen cargo run bzw. npm run dev aus. 3. Im Tab „Database" den PostgreSQL-Client starten.

Command Panes

Command Panes sind ein besonderes Feature von Zellij. Sie behandeln Befehle als „First-Class-Citizens" – nicht nur als einfache Terminalausgabe.

Eigenschaften: - Du siehst den Exit-Code des Befehls - Drücke Enter, um den Befehl erneut auszuführen - Befehle können im „suspendierten" Zustand gestartet und bei Bedarf manuell ausgelöst werden - Ideal zum Bauen, Testen oder Starten von Entwicklungsservern

Command Panes im Layout verwenden:

KDL 
layout {
    tab name="Dev" {
        pane command="cargo" args=["test"] start_suspended=true
        pane command="cargo" args=["build"] start_suspended=true
    }
}

start_suspended=true bedeutet, dass der Befehl nicht automatisch startet. Du musst Enter drücken, um ihn auszulösen. Das ist praktisch für ressourcenintensive Vorgänge wie vollständige Kompilierungen. So vermeidest du, dass sie bei jedem Layout-Start automatisch ausgeführt werden.

Editier-Panels

Zellij ermöglicht es, den gesamten Scroll-Puffer eines Panels direkt in deinem $EDITOR zu öffnen:

BASH 
# Im aktuellen Panel drücken:
Strg+s → e

Dein konfigurierter Editor (vim, neovim, emacs etc.) öffnet sich mit der kompletten Ausgabe des Panels. Du kannst: - Terminalausgaben durchsuchen, kopieren und整理 - Ausgaben als Dateien speichern - Sie mit Teammitgliedern teilen

Web-Client: Terminal im Browser aufrufen

Zellij hat einen eingebauten Webserver. Damit kannst du deine Terminal-Sessions direkt über den Browser aufrufen. Das bedeutet: - Keine Terminal-Installation nötig: Greife von jedem Gerät mit Browser auf deine Zellij-Session zu. - Remote-Zusammenarbeit: Teile Sessions mit Teammitgliedern für Pair Programming oder Debugging. - Nahtloses Wechseln: Wechsle frei zwischen Terminal und Browser. Der Session-Status bleibt synchron.

Web-Client aktivieren

Starte Zellij mit aktiviertem Webserver:

BASH 
zellij --server /tmp/zellij-server.sock

Oder aktiviere es in der Konfigurationsdatei:

KDL 
// ~/.config/zellij/config.kdl
plugins {
    path "/usr/lib/zellij/plugins"
}

keybinds {
    shared {
        bind "Alt w" { SwitchToMode "WebClient"; }
    }
}

Session aufrufen

Öffne im Browser:

http://localhost:8082

Du kannst: - Alle laufenden Sessions anzeigen - Bestimmte Sessions direkt über die URL aufrufen: http://localhost:8082/my-session - Nur-Lese-Token erstellen, damit andere deine Session sehen, aber nicht bedienen können

Remote-Zugriff

Zellij unterstützt den Remote-Zugriff auf Sessions über HTTPS:

BASH 
# Von einem anderen Rechner aus an eine Remote-Session anhängen
zellij attach https://my-server:8082/my-session

Dafür sind keine SSH-Tunnel oder Drittanbieter-Tools erforderlich. Ideal für: - Remote-Debugging - Pair Programming - Technischen Support

Plugin-System: Funktionen mit WebAssembly erweitern

Die gesamte Oberfläche von Zellij besteht aus Plugins. Dazu gehören: - Tab-Leiste (Tab Bar) - Statusleiste (Status Bar) - Session-Manager (Session Manager) - Willkommensbildschirm (Welcome Screen) - Dateiauswahl (Strider)

Eigene Plugins entwickeln

Zellij-Plugins basieren auf WebAssembly (WASM). Du kannst sie in jeder Sprache schreiben, die zu WASM kompiliert werden kann (Rust, Go, C etc.). Rust wird erstklassig unterstützt und verfügt über ein eigenes SDK.

Ein einfaches Rust-Plugin erstellen:

BASH 
# Zellij-Plugin-Scaffolding-Tool installieren
cargo install zellij-plugin-template

# Neues Projekt erstellen
zellij-plugin-template my-plugin

cd my-plugin

Die generierte Projektstruktur:

my-plugin/
├── Cargo.toml
├── src/
│   └── main.rs
└── plugin.yaml

Beispiel-Plugin-Code (src/main.rs):

RUST 
use zellij_sdk::{prelude::*, Command};

#[command(name = "my-plugin")]
fn main() {
    // Zellij-Ereignisse abonnieren
    subscribe(&[EventType::KeyPress(Key::Char('x'))]);

    loop {
        match std::io::stdin().read_line() {
            Ok(line) => {
                if line.contains("KeyPress") {
                    // Tastendruck verarbeiten
                    println!("Received key press!");
                }
            }
            Err(_) => break,
        }
    }
}

Kompilieren und installieren:

BASH 
# Zu WASM kompilieren
cargo build --target wasm32-wasip1 --release

# In das Zellij-Plugin-Verzeichnis kopieren
cp target/wasm32-wasip1/release/my_plugin.wasm ~/.local/share/zellij/plugins/

Plugin in der Konfiguration laden:

KDL 
// ~/.config/zellij/config.kdl
plugins {
    path "~/.local/share/zellij/plugins"
}

pane_templates {
    template name="my-plugin-pane" {
        plugin location="file:~/.local/share/zellij/plugins/my_plugin.wasm"
    }
}

Beliebte Community-Plugins

  • Strider: Dynamische Dateisystem-Navigation mit Fuzzy-Suche
  • Configuration Screen: Interaktive Konfigurationsverwaltung
  • Multiple Pane Select: Batch-Operationen für mehrere Panels

Weitere Community-Plugins findest du im Zellij-Plugin-Repository.

Erweiterte Skripting: CLI-Steuerung

Zellij stellt eine vollständige Steuerungsschnittstelle über CLI-Befehle bereit. So kannst du komplexe Terminal-Workflows aus Shell-Skripten oder externen Tools heraus bauen.

Blockierende Panels mit Bedingungen

BASH 
# Blockieren, bis der Befehl erfolgreich beendet wurde
zellij action new-pane --command "cargo test" --block-until-exit-success

# Blockieren, bis der Befehl mit Fehler beendet wurde
zellij action new-pane --command "npm run build" --block-until-exit-failure

# Blockieren, bis der Befehl beendet wurde (egal ob Erfolg oder Fehler)
zellij action new-pane --command "make" --block-until-exit

Fehlgeschlagene Befehle können interaktiv wiederholt werden, ohne dass das Skript seine Position verliert.

Echtzeit-Panel-Ausgabe streamen

BASH 
# Ausgabe eines beliebigen Panels in Echtzeit nach stdout streamen
zellij subscribe pane-id-123

# JSON-Format für strukturierte Verarbeitung verwenden
zellij subscribe pane-id-123 --json

Das ist nützlich, um Logs auf Remote-Servern zu überwachen oder automatisierte Pipelines zu erstellen.

Strukturierte Statusabfragen

BASH 
# Alle Panels auflisten (JSON-Format)
zellij list-panes --json

# Alle Tabs auflisten
zellij list-tabs --json

# Aktuelle Session-Informationen abrufen
zellij session-info

Diese Befehle lassen sich in CI/CD-Pipelines, Überwachungsskripte oder eigene Dashboards integrieren.

Praxisbeispiele: Entwickler-Workflows bauen

Beispiel 1: Full-Stack-Entwicklungsumgebung

Erstelle eine Layout-Datei fullstack-dev.kdl:

KDL 
layout {
    tab name="Frontend" {
        pane split_direction="Vertical" {
            pane command="npm" args=["run", "dev"]
            pane command="npm" args=["run", "storybook"]
        }
    }
    tab name="Backend" {
        pane split_direction="Horizontal" {
            pane command="cargo" args=["run"]
            pane command="cargo" args=["watch", "-x", "test"] start_suspended=true
        }
    }
    tab name="Database" {
        pane command="docker" args=["compose", "up"]
        pane command="psql" args=["-U", "postgres", "-d", "myapp"]
    }
    tab name="Monitoring" {
        pane floating=true command="htop"
        pane floating=true command="tail" args=["-f", "/var/log/app.log"]
    }
}

Starten:

BASH 
zellij --layout fullstack-dev.kdl

Dieses Layout erstellt automatisch: 1. Vier Tabs: Frontend, Backend, Datenbank und Monitoring 2. Im Frontend-Tab vertikale Aufteilung für Dev-Server und Storybook 3. Im Backend-Tab horizontale Aufteilung für App und Test-Watcher 4. Im Datenbank-Tab Docker Compose und PostgreSQL-Client 5. Im Monitoring-Tab schwebende Panels für htop und Log-Tracking

Beispiel 2: Remote-Server-Debugging

Angenommen, du musst ein Problem auf einem Remote-Server debuggen:

BASH 
# Per SSH zum Remote-Server verbinden
ssh user@remote-server

# Zellij-Session starten
zellij -s debugging-session

# Im ersten Panel Logs anzeigen
tail -f /var/log/app/error.log

# Neues Panel erstellen, Diagnosebefehle ausführen
Strg+g → n
dmesg | tail -20

# Schwebendes Panel erstellen, Systemressourcen überwachen
Strg+g → Alt+f
htop

# Web-Client aktivieren, damit Kollegen remote zuschauen können
# (Webserver muss vorher konfiguriert sein)

Teile dann deinem Kollegen die URL https://remote-server:8082/debugging-session mit. Er kann deine Terminal-Session in Echtzeit sehen und sogar mitarbeiten (wenn du Schreibrechte erteilst).

Beispiel 3: Data-Science-Workflow

Erstelle ein Layout für ein Data-Science-Projekt data-science.kdl:

KDL 
layout {
    tab name="Notebook" {
        pane command="jupyter" args=["lab", "--no-browser"]
    }
    tab name="Data Processing" {
        pane split_direction="Vertical" {
            pane command="python" args=["process_data.py"]
            pane command="watch" args=["-n", "5", "ls", "-lh", "output/"]
        }
    }
    tab name="Visualization" {
        pane command="python" args=["visualize.py"]
        pane floating=true command="eog" args=["output/chart.png"]
    }
}

Häufige Fragen und Fehlerbehebung

F1: Können Zellij und tmux gleichzeitig verwendet werden?

A: Ja, aber es wird nicht empfohlen, sie ineinander verschachtelt zu verwenden. Du kannst Zellij in tmux oder tmux in Zellij ausführen. Das führt jedoch zu Shortcut-Konflikten und Performance-Problemen. Entscheide dich besser für einen der beiden als primären Terminal-Multiplexer.

F2: Wie migriere ich meine tmux-Konfiguration zu Zellij?

A: Zellij hat keinen direkten tmux-Konfigurationskonverter. Aber du kannst: 1. Die Standard-Konfigurationsdatei von Zellij als Referenz nutzen. 2. Häufig genutzte tmux-Funktionen auf entsprechende Zellij-Funktionen abbilden. 3. Das Zellij-Layout-System anstelle von tmux-Skripten verwenden.

F3: Wie ist die Performance von Zellij?

A: Zellij ist in Rust geschrieben und bietet exzellente Performance. In den meisten Szenarien sind Speicherverbrauch und CPU-Auslastung vergleichbar mit tmux. In einigen Benchmarks schneidet Zellij sogar besser ab. Auch bei großen Sessions mit Dutzenden von Panels bleibt die Reaktionsgeschwindigkeit flüssig.

F4: Wie verwende ich die Maus in Zellij?

A: Zellij unterstützt Mausoperationen standardmäßig: - Klicke auf Panels, um den Fokus zu wechseln - Ziehe Panel-Grenzen, um die Größe anzupassen - Scrolle mit dem Mausrad durch den Verlauf - Klicke auf Tabs, um zu wechseln

Falls die Maus nicht funktioniert, prüfe, ob dein Terminal-Emulator die Mausunterstützung aktiviert hat. Oder bestätige in der Zellij-Konfiguration:

KDL 
// ~/.config/zellij/config.kdl
mouse_mode true

F5: Unterstützt Zellij Windows?

A: Ja, Zellij unterstützt Windows nativ (über WSL2 oder PowerShell). Du kannst das offizielle One-Click-Installations-Skript unter Windows verwenden:

POWERSHELL 
irm https://zellij.dev/launch.ps1 | iex

Fazit

Zellij ist ein moderner Terminal-Workspace. Er übernimmt die starken Funktionen von tmux und bietet gleichzeitig eine freundlichere Benutzererfahrung sowie innovative Features:

Kernvorteile: - ✅ Sofort einsatzbereit: Keine komplexe Konfiguration nötig, intuitive UI ab Werk - ✅ Schwebende/gestapelte Panels: Flexibles Panel-Management für Multitasking - ✅ Session-Resurrection: Vollständiger Arbeitszustand wird auch nach Neustart wiederhergestellt - ✅ Web-Client: Terminal über Browser aufrufen, Remote-Zusammenarbeit möglich - ✅ Plugin-System: Basierend auf WebAssembly, sicher und erweiterbar - ✅ Layout-Automatisierung: Entwicklungsumgebungen deklarativ mit KDL definieren - ✅ CLI-Skripting: Vollständige Steuerungsschnittstelle für Automatisierungs-Workflows

Geeignet für: - Entwickler: Müssen mehrere Dienste, Tests und Monitoring-Tools parallel ausführen - DevOps-Ingenieure: Verwalten Remote-Server und lang laufende Tasks - Data Scientists: Organisieren Jupyter Notebooks, Datenverarbeitung und Visualisierungs-Workflows - Teamarbeit: Teilen Terminal-Sessions für Pair Programming oder Debugging

Nächste Schritte: - Lies die offizielle Zellij-Dokumentation - Entdecke Community-Plugins - Tritt der Discord oder Matrix Community bei

Wenn du auf der Suche nach einer modernen Alternative zu tmux bist, ist Zellij definitiv einen Versuch wert. Die Lernkurve ist flach, die Funktionen sind leistungsstark. Deine Produktivität im Terminal wird sich deutlich steigern.