tmux vs Zellij vs Screen: Pick Your Multiplexer

Three Multiplexers Walk Into a Server

You SSH into a remote box and need to run two things simultaneously without opening a second terminal. Maybe you want to detach, walk away, and reconnect tomorrow without losing your session. Maybe you just want your terminal to feel less like a single hallway and more like a proper room with doors.

Terminal multiplexers are the answer. They let you split your terminal into panes, manage multiple sessions, detach from the box and come back later — all without installing something that needs a database and a Kubernetes cluster to run.

The three main options are screen, tmux, and zellij. You’ve probably heard of all three. You’ve definitely used at least one. And if you’ve ever spent four hours reading man tmux instead of doing actual work, this article is for you.

Here’s the honest rundown.

Screen: The Elder Statesman Nobody Asked For

GNU Screen has been around since 1987. That’s not a typo. It predates the Berlin Wall coming down. It’s on practically every Linux server in existence because it ships with most distros by default and has been in package repos since forever.

Screen is perfectly functional. It does the core job: you can create multiple windows, detach from a session, and reattach later. That’s it. That’s the pitch.

# Start a new named session
screen -S mysession

# Detach: Ctrl+A then D
# Reattach
screen -r mysession

# List sessions
screen -ls

# Create a new window inside screen: Ctrl+A then C
# Switch windows: Ctrl+A then N (next) or P (previous)
# Split horizontally: Ctrl+A then S
# Move to the new pane: Ctrl+A then Tab

Notice anything? The prefix key is Ctrl+A. That’s also the keybind for “go to the beginning of the line” in bash. So every time you want to go to the start of a command, you accidentally detach from your session or create a new window. It’s a small but deeply irritating paper cut that never fully heals.

Screen’s config file (~/.screenrc) exists, but configuring it feels like writing COBOL. The status bar is essentially nonexistent by default. Copy mode works but feels like defusing a bomb. There’s no mouse support in any version you’ll encounter in the wild. And splitting panes — while technically supported — is so underpowered compared to tmux that most people don’t bother.

When should you use screen?

When it’s the only thing installed. You’re on a barebones VPS, a coworker’s server, a client’s ancient Ubuntu 16.04 box — and there’s no tmux, no zellij, no package manager that works right. Screen is there. Screen is always there. Like that coworker who shows up to every meeting but never says anything useful. Reliable in the most minimal sense of the word.

tmux: The Workhorse With Ugly Defaults

tmux is what most sysadmins and developers reach for today. It’s been around since 2007, has a massive ecosystem of plugins and dotfile configs, and once you’ve set it up the way you want, it’s genuinely excellent.

The key word there is “once you’ve set it up.”

Out of the box, tmux looks like this: a thin green status bar at the bottom, no obvious indication of what any keybind does, and a prefix key of Ctrl+B that nobody’s muscle memory likes for the first three weeks.

But configure it, and you get a genuinely powerful tool.

Making tmux Not Terrible

Here’s a practical ~/.tmux.conf that makes tmux usable without requiring a PhD:

# Change prefix from Ctrl+B to Ctrl+A (yeah, same as screen)
# Or use Ctrl+Space if you want to avoid the bash conflict entirely
unbind C-b
set-option -g prefix C-Space
bind-key C-Space send-prefix

# Start window numbering at 1 (not 0)
set -g base-index 1
setw -g pane-base-index 1

# Reload config without restarting
bind r source-file ~/.tmux.conf \; display "Config reloaded"

# Split panes with | and -
bind | split-window -h
bind - split-window -v
unbind '"'
unbind %

# Switch panes with Alt+Arrow (no prefix needed)
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Mouse support
set -g mouse on

# Increase scrollback buffer
set -g history-limit 50000

# Modern terminal colors
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",xterm-256color:Tc"

# Status bar — cleaner look
set -g status-style 'bg=#1a1b26 fg=#c0caf5'
set -g status-left '#[fg=#7aa2f7,bold] #S '
set -g status-right '#[fg=#9ece6a] %H:%M #[fg=#7aa2f7] %d %b '
set -g window-status-current-style 'fg=#ff9e64,bold'

# Renumber windows when one is closed
set -g renumber-windows on

# Don't rename windows automatically
set-option -g allow-rename off

Apply it:

tmux source ~/.tmux.conf

Now your tmux has mouse support, sane splits, a status bar that doesn’t look like it was designed in 1994, and pane navigation that doesn’t require memorizing a chord sequence.

Essential tmux Workflow

# Create a named session
tmux new -s work

# Detach: prefix then D
# Reattach
tmux attach -t work

# List sessions
tmux ls

# New window: prefix then C
# Rename window: prefix then ,
# Kill window: prefix then &

# New pane (with our config): prefix then | or -
# Close pane: exit (or prefix then X)

# Enter copy mode: prefix then [
# Search: / (in copy mode)
# Copy: Space to start, Enter to copy
# Paste: prefix then ]

The Plugin Problem

tmux has a plugin ecosystem via TPM (tmux Plugin Manager). The most popular plugins are tmux-sensible (applies sane defaults), tmux-resurrect (saves and restores sessions across reboots), and tmux-continuum (auto-saves sessions every few minutes).

These are genuinely useful. But now you’re managing a plugin manager, a plugin config, and a runtime dependency chain — for a terminal multiplexer. Whether that’s worth it is a personal call.

If you’ve been using tmux for years, none of this is news and your config is probably already better than mine. If you’re starting fresh, keep reading.

Zellij: The New Kid Who Actually Did Their Homework

Zellij is a Rust-based terminal multiplexer that launched its 1.0 in 2022. It’s designed with “discoverability” as a first-class principle, which is a fancy way of saying: the keybinds are shown on screen by default.

Open Zellij for the first time and the bottom of your terminal shows you exactly what keys do what, in the current mode. No manual required. No spending thirty minutes on YouTube to figure out how to resize a pane.

This sounds small. It is not small. It’s the difference between a tool that welcomes you and a tool that hazes you.

# Install on most distros
# Arch/Manjaro
sudo pacman -S zellij

# Via cargo
cargo install zellij

# Quick start — just run it
zellij

# Attach to a named session
zellij attach mysession

# List sessions
zellij list-sessions

# Kill a session
zellij kill-session mysession

Zellij Config

The config lives at ~/.config/zellij/config.kdl and uses KDL (a document language that looks like a reasonable JSON alternative). You don’t need to touch it much because the defaults are already good, but here’s a minimal tweaked version:

// Default shell
default_shell "zsh"

// Theme
theme "tokyo-night-dark"

// Copy command (for systems without wl-copy / pbcopy)
copy_command "xclip -selection clipboard"

// On exit, keep the session alive
// (useful if you accidentally close the terminal)
session_serialization true

// Mouse support — on by default, but explicit is nice
mouse_mode true

// Scroll buffer size
scroll_buffer_size 50000

// Simplified mode — hides the status bar hints after a few seconds
// (once you know the keys)
simplified_ui false

// Pane frame shows pane titles — keep it on
pane_frames true

// Default layout: "default" gives you one pane with the tab bar
// "compact" is leaner — no status bar at all
default_layout "default"

Generate a default config to start from:

zellij setup --dump-config > ~/.config/zellij/config.kdl

What Zellij Gets Right

Layouts as code. You can define a layout file that opens with a specific set of panes pre-configured. Start your dev session and automatically get your editor pane, a server log pane, and a git pane — without any scripting or tmux-session-restore plugins.

layout {
    pane split_direction="vertical" {
        pane size="60%" focus=true
        pane split_direction="horizontal" {
            pane size="50%"
            pane size="50%"
        }
    }
    pane size=1 borderless=true {
        plugin location="zellij:tab-bar"
    }
    pane size=2 borderless=true {
        plugin location="zellij:status-bar"
    }
}

Launch it:

zellij --layout dev

Mode-based UI. Zellij has modes: Normal, Locked, Pane, Tab, Resize, Move, Search, Session. Each mode shows you what keys are valid in it. It’s like having a tutorial baked into the UI permanently. Annoying for experts, invaluable for beginners, and honestly — even experts forget the occasional keybind.

Floating panes. You can pop a floating terminal window inside Zellij, do something quick, dismiss it, and return to what you were doing. tmux can kind of do this with popup windows, but it’s a workaround, not a feature.

The muscle memory tax. Here’s the honest part nobody likes admitting: if you’ve been using tmux for three years, switching to Zellij has a real cost. Your fingers know Ctrl+B for everything. They will type it anyway. For weeks. It will work wrong. You will swear. This is not Zellij’s fault — it’s your brain’s, but the brain wins in the short term.

If you’re starting fresh, Zellij’s defaults make way more sense than tmux’s. If you’re a tmux veteran, the question is whether the quality-of-life improvements are worth the muscle memory reset. For most people in that camp, the answer is “maybe when I rebuild my next dev machine.”

Side-by-Side Comparison

The Decision Tree

You’re on a random remote server you don’t control: Use whatever’s installed. That’s probably screen. Learn Ctrl+A D to detach and screen -r to reattach and you’ll survive.

You’re a tmux veteran with an existing config: Stay with tmux unless you have a specific reason to switch. Your muscle memory is a real investment. Keep a tidy ~/.tmux.conf and consider tmux-resurrect if session persistence matters to you.

You’re setting up a new machine or new workflow from scratch: Use Zellij. The onboarding experience is dramatically better, the defaults are sensible, layouts-as-code are genuinely useful, and you’ll spend your first weekend configuring your workflow instead of fighting keybind documentation.

You want the same experience everywhere, including servers you don’t own: tmux is still the right answer here because it’s installable on practically anything and your config is portable. Zellij requires a more modern setup.

You just need to keep something running after logout: Both screen and tmux handle detach/reattach fine. nohup or systemd --user units are also worth knowing for pure background processes.

The Honest Take

Screen is the legacy option that earns its place by being universal. Knowing it at a survival level (screen -r, detach, new window) is a legitimate skill for anyone who works on other people’s servers.

tmux is mature, configurable, and has a decade of battle-hardened community knowledge behind it. If your .tmux.conf is already dialed in, there’s no pressing reason to migrate. But don’t recommend tmux to a newcomer and tell them the defaults are fine. They’re not.

Zellij is what tmux would look like if it were designed today, for people who don’t want to spend a Sunday reading dotfile blogs. The discoverable UI, built-in layouts, and floating panes are genuine improvements, not just aesthetic choices. If you’re recommending a multiplexer to someone who’s never used one, Zellij is the right answer now.

The real mistake is staying on screen because that’s what you learned first. Or staying on tmux because changing is uncomfortable. Your terminal setup is supposed to serve you, not the other way around.

Your 2 AM self, trying to reattach to a session on a production box, will appreciate whichever one you actually know well. Pick one. Learn it properly. And maybe — just maybe — keep a single Ctrl+A D reflex in the back of your head for when you end up on someone else’s dusty Ubuntu server at 1:47 AM with nothing but screen standing between you and a dropped connection.