tmux vs Zellij: Terminal Multiplexers Compared

tmux vs Zellij: Terminal Multiplexers Compared

Terminal multiplexers let you split your terminal into panes, manage multiple sessions, and keep processes running after you disconnect. For decades, tmux was the only serious option (sorry, GNU Screen). Then Zellij showed up, written in Rust, with a philosophy of being discoverable out of the box.

Both are excellent. Here's how to decide between them.

tmux: The Veteran

tmux has been the standard terminal multiplexer since ~2009. It replaced GNU Screen for most developers and has an enormous ecosystem of plugins, configurations, and community knowledge.

Configuration

tmux is configured via ~/.tmux.conf using its own command language. The learning curve is real -- the configuration syntax is unlike anything else you use daily.

# ~/.tmux.conf

# Change prefix from Ctrl+B to Ctrl+A
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# Start windows and panes at 1, not 0
set -g base-index 1
setw -g pane-base-index 1

# Enable mouse support
set -g mouse on

# Vi-style pane navigation
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# Better splits (and open in current directory)
bind | split-window -h -c "#{pane_current_path}"
bind - split-window -v -c "#{pane_current_path}"

# Increase scrollback
set -g history-limit 50000

# True color support
set -g default-terminal "tmux-256color"
set -ag terminal-overrides ",xterm-256color:RGB"

# Faster escape time (important for Neovim)
set -sg escape-time 0

Session Management

tmux sessions persist in the background. You can detach, close your terminal, and reattach later. This is essential for remote work -- SSH into a server, start a tmux session, and your work survives network disconnections.

tmux new -s project      # Create named session
tmux ls                  # List sessions
tmux attach -t project   # Reattach
# Ctrl+A d               # Detach (with prefix remap above)

Plugin Ecosystem

TPM (tmux Plugin Manager) brings plugin support:

# Install 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'    # Save/restore sessions
set -g @plugin 'tmux-plugins/tmux-continuum'    # Auto-save sessions
set -g @plugin 'catppuccin/tmux'                # Theme

run '~/.tmux/plugins/tpm/tpm'

Key plugins: tmux-resurrect saves your session layout across restarts. tmux-continuum auto-saves every 15 minutes. tmux-yank fixes clipboard integration.

Zellij: The Modern Alternative

Zellij launched in 2021 with a clear thesis: terminal multiplexers shouldn't require reading a manual before you can do anything. It's written in Rust and targets users who want tmux-like functionality without tmux's learning curve.

Configuration

Zellij uses KDL (KDL Document Language) for configuration. It also ships with a setup wizard (zellij setup --dump-config) that generates a commented config file.

// ~/.config/zellij/config.kdl

theme "catppuccin-mocha"
default_shell "zsh"
pane_frames false
default_layout "compact"

keybinds {
    shared_except "locked" {
        bind "Ctrl g" { SwitchToMode "locked"; }
    }
    normal {
        bind "Alt h" { MoveFocus "Left"; }
        bind "Alt j" { MoveFocus "Down"; }
        bind "Alt k" { MoveFocus "Up"; }
        bind "Alt l" { MoveFocus "Right"; }
    }
}

Discoverability

Zellij's biggest selling point is its status bar. By default, it shows available keybindings at the bottom of the screen, updating based on your current mode. You never have to memorize bindings -- they're always visible.

It uses a modal system (similar to Vim): Normal mode for typing, Pane mode for pane management, Tab mode for tab management, Resize mode for resizing, and so on. Press Ctrl+P to enter Pane mode, then n for new pane, x to close, h/j/k/l to navigate.

Layouts

Zellij layouts are defined in KDL files and are more powerful than tmux's layout system:

// ~/.config/zellij/layouts/dev.kdl
layout {
    pane size=1 borderless=true {
        plugin location="tab-bar"
    }
    pane split_direction="vertical" {
        pane command="nvim" size="60%"
        pane split_direction="horizontal" {
            pane command="zsh"
            pane command="zsh"
        }
    }
    pane size=1 borderless=true {
        plugin location="status-bar"
    }
}

Start with a layout: zellij --layout dev

Plugin System

Zellij plugins are WebAssembly modules, which means they can be written in any language that compiles to WASM (Rust, Go, C, etc.). The built-in plugins include the tab bar and status bar. Community plugins are growing but the ecosystem is much smaller than tmux's.

Comparison Table

When to Use tmux

Choose tmux if you:

• Work on remote servers frequently (tmux is installed or installable everywhere)
• Already have a tmux config you've refined over years
• Need the mature plugin ecosystem (resurrect, continuum, etc.)
• Work on teams where tmux is the standard (pair programming via shared sessions)
• Want maximum stability and minimal resource usage
• Use Alacritty or another terminal without built-in splits

tmux is the safe, proven choice. The learning curve is front-loaded, but once you have your config dialed in, it's incredibly reliable.

When to Use Zellij

Choose Zellij if you:

• Are new to terminal multiplexers and don't want to memorize keybindings
• Value discoverability and a guided UI
• Want rich layout files for project-specific setups
• Prefer a modern config format over tmux's custom syntax
• Are interested in WASM-based plugins
• Use floating panes heavily

Zellij is the better starting point for new users. The status bar hints eliminate the "how do I do X?" problem that plagues tmux beginners.

Can You Use Both?

Yes, but don't nest them. Some developers use tmux for remote servers (where it's universally available) and Zellij locally (where they control the install). Just don't run Zellij inside tmux or vice versa -- nested multiplexers create keybinding conflicts and confusion.

The Verdict

If you're starting fresh and work primarily on your local machine, try Zellij first. Its discoverability means you'll be productive in minutes rather than hours. If you SSH into servers regularly, need team session sharing, or want the largest ecosystem of plugins and community knowledge, tmux remains the better choice.

Both tools solve the same core problem well. The difference is philosophy: tmux is a power tool that rewards investment. Zellij is an approachable tool that respects your time upfront.