Zellij: The Modern Alternative to tmux (2026)

Posted: April 14, 2026 to Technology.

Zellij is a Rust-based terminal multiplexer designed around discoverability, ease of use, and a WebAssembly plugin system. If you have ever struggled with tmux keybindings, spent hours configuring .tmux.conf, or wished for a terminal multiplexer that shows you what keys do instead of making you memorize them, Zellij was built for you. This guide covers everything from installation to advanced layout files, plugin development, and real-world workflows for cybersecurity assessments and AI model training. At Petronella Technology Group, we have deployed Zellij across our engineering team for daily security research, infrastructure management, and distributed AI workloads.

Terminal multiplexers let you run multiple terminal sessions inside a single window, split your screen into panes, create tabs, and persist sessions across disconnections. They are essential for remote server work, long-running processes, and any workflow that involves monitoring several things at once. Tmux has dominated this space for over a decade, but its steep learning curve and cryptic keybindings have always been a barrier. Zellij takes a fundamentally different approach to the problem.

What Is Zellij

Zellij (pronounced “zellige,” after the intricate Moroccan mosaic tilework) is a terminal workspace manager written in Rust. It launched in 2021 and has matured rapidly, reaching version 0.41+ by 2026 with a stable feature set and an active contributor community. The project is maintained by Aram Drevekenin and a growing team of open-source contributors.

At its core, Zellij does what tmux and GNU Screen do: it multiplexes a single terminal into multiple panes and tabs, persists sessions so they survive disconnections, and provides keybindings for navigating between splits. Where Zellij diverges is in how it approaches each of these features.

The most immediately noticeable difference is the status bar. When you launch Zellij, a bar at the bottom of your terminal shows you exactly which keys are available and what they do. Press Ctrl+p to enter pane mode, and the status bar updates to show pane-specific actions: split directions, close, move, resize. You never need to memorize an obscure prefix-key combination because the interface tells you what is available at every moment.

Under the hood, Zellij is built on a client-server architecture where the server manages sessions and the client connects to render the UI. This is similar to tmux, but Zellij adds a WebAssembly (WASM) plugin runtime that lets you extend the multiplexer with sandboxed plugins written in any language that compiles to WASM. The built-in status bar, tab bar, and file manager are all WASM plugins themselves, which means the core architecture practices what it preaches about extensibility.

Zellij also introduces floating panes, a concept absent from tmux entirely. Floating panes overlay your current layout without disrupting it, giving you a quick scratchpad terminal, a temporary command runner, or a monitoring window that you can dismiss and recall without rearranging your workspace.

Why Zellij Over tmux

Tmux is excellent software. It has been battle-tested for over 15 years, every Linux distribution ships it, and countless tutorials cover its usage. We are not arguing that tmux is broken or obsolete. We are arguing that Zellij solves specific usability problems that tmux does not address, and for teams onboarding new engineers or running complex multi-tool workflows, those differences matter.

Discoverable Keybindings

Tmux requires you to press a prefix key (default Ctrl+b) before every command. Want to split horizontally? Ctrl+b %. Vertically? Ctrl+b ". New tab? Ctrl+b c. Navigate panes? Ctrl+b o. There is no on-screen indication of what keys are available, and the defaults are not mnemonic. You either memorize them or keep a cheat sheet open.

Zellij uses a mode-based system instead. The default mode shows a minimal status bar. Press Ctrl+p to enter pane mode, and the bar shows: n new, d down, r right, x close, f fullscreen. Press the letter, and the action happens. Press Esc or Enter to return to normal mode. Every mode displays its available actions, so new users can be productive within minutes instead of days.

No Prefix Key Required

The prefix key in tmux means every multiplexer command requires two keypresses. In fast-paced work (cycling between panes during an active security scan, checking GPU utilization while a training job runs), that extra keypress adds friction. Zellij eliminates the prefix by using modes. You enter a mode, execute one or more actions, and return to normal. If you prefer the tmux style, Zellij supports a locked mode where keybindings do not conflict with terminal applications.

Built-in Session Management

Tmux sessions persist, but managing them requires remembering session names and typing tmux attach -t name. Zellij includes a built-in session manager plugin (session-manager) that lists all active and detached sessions in a visual picker. You can switch between sessions, rename them, and create new ones without leaving the multiplexer. Run zellij ls from outside to list sessions, or use the session manager inside Zellij for a richer experience.

WebAssembly Plugin System

Tmux is extended through shell scripts and external tools. You can write complex tmux configurations that call external programs, but the integration is always at the shell level. Zellij embeds a WASM runtime that loads plugins as sandboxed modules with defined APIs for interacting with the multiplexer. Plugins can render UI elements, respond to events, create panes, and communicate with each other. Because they run as WASM, they are language-agnostic (Rust, Go, C, AssemblyScript) and sandboxed from the host system.

Floating Panes

Tmux has no concept of floating panes. Every pane occupies a fixed position in the layout tree, and popup windows (added in tmux 3.2) are limited in functionality. Zellij floating panes are full terminal sessions that overlay your tiled layout. Toggle them with Ctrl+p w (pane mode, then w for floating). You can have multiple floating panes, move them, resize them, and they persist across tab switches. This is invaluable for quick commands: checking nvidia-smi, running a one-off curl, or tailing a log file without disrupting your carefully arranged workspace.

First-class Layout System

Tmux layouts are either automatic (even-horizontal, even-vertical, main-horizontal, main-vertical, tiled) or manually arranged by splitting panes. Reproducing a specific layout requires scripting with tmux split-window, tmux send-keys, and careful geometry calculations. Zellij layouts are declared in KDL files with a clear, human-readable syntax. You define tabs, panes, their sizes, and even the commands they run, then load the layout with zellij --layout my-layout.kdl. The layout system is powerful enough to encode entire project workflows as reusable templates.

Installation

Cargo (Rust Toolchain)

If you have Rust installed, cargo provides the latest release directly from crates.io:

cargo install zellij

This compiles from source, which takes a few minutes. The binary lands in ~/.cargo/bin/, which should be in your PATH.

Package Managers

# Arch Linux
sudo pacman -S zellij

# Homebrew (macOS and Linux)
brew install zellij

# NixOS (declarative)
# In configuration.nix or home.nix:
environment.systemPackages = [ pkgs.zellij ];

# Nix (imperative)
nix-env -iA nixpkgs.zellij

# Fedora (COPR)
sudo dnf copr enable varlad/zellij
sudo dnf install zellij

# Ubuntu/Debian (via binary release or cargo)
# Not in official repos as of 2026; use binary release or cargo

Binary Releases

Pre-built binaries for Linux (x86_64, aarch64) and macOS are available on the Zellij GitHub releases page. Download the archive, extract the binary, and place it in a directory on your PATH:

wget https://github.com/zellij-org/zellij/releases/latest/download/zellij-x86_64-unknown-linux-musl.tar.gz
tar xzf zellij-x86_64-unknown-linux-musl.tar.gz
sudo mv zellij /usr/local/bin/

Verify the installation with zellij --version. Launch your first session by simply typing zellij.

Configuration Deep Dive

Zellij configuration lives at ~/.config/zellij/config.kdl. Like Niri (covered in our Wayland compositor guide), Zellij uses KDL (KDocument Language) for its configuration format. KDL is a structured, human-readable language designed for configuration files, sitting between the simplicity of TOML and the expressiveness of YAML without the indentation sensitivity.

Generate a default configuration file as a starting point:

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

Core Settings

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

// Default shell
default_shell "fish"

// Copy behavior
copy_command "wl-copy"
copy_on_select true

// Scrollback buffer (lines per pane)
scroll_buffer_size 50000

// Mouse support
mouse_mode true

// Simplified UI (hides mode indicators for experienced users)
simplified_ui false

// Mirror session (all connected clients see the same view)
mirror_session true

// Pane frames (borders around panes)
pane_frames true

// Auto-create layouts directory
auto_layout true

// Session serialization (persist layout on exit)
session_serialization true

// Idle timeout for status bar hints (milliseconds)
scrollback_lines_to_serialize 10000

Custom Keybindings

Zellij keybindings are organized by mode. Each mode has its own set of keys, and you can rebind any of them. Here is a keybinding configuration that optimizes for keyboard-driven workflows:

keybinds {
    // Normal mode: available without entering any special mode
    normal {
        bind "Alt h" { MoveFocusOrTab "Left"; }
        bind "Alt l" { MoveFocusOrTab "Right"; }
        bind "Alt j" { MoveFocus "Down"; }
        bind "Alt k" { MoveFocus "Up"; }
        bind "Alt n" { NewPane; }
        bind "Alt t" { NewTab; }
        bind "Alt f" { ToggleFloatingPanes; }
        bind "Alt 1" { GoToTab 1; }
        bind "Alt 2" { GoToTab 2; }
        bind "Alt 3" { GoToTab 3; }
        bind "Alt 4" { GoToTab 4; }
        bind "Alt 5" { GoToTab 5; }
    }

    // Pane mode: Ctrl+p to enter
    pane {
        bind "h" { NewPane "Left"; }
        bind "l" { NewPane "Right"; }
        bind "j" { NewPane "Down"; }
        bind "k" { NewPane "Up"; }
        bind "x" { CloseFocus; }
        bind "f" { ToggleFocusFullscreen; }
        bind "w" { ToggleFloatingPanes; }
        bind "e" { TogglePaneEmbedOrFloating; }
        bind "r" { SwitchToMode "RenamePane"; PaneNameInput 0; }
    }

    // Tab mode: Ctrl+t to enter
    tab {
        bind "h" { GoToPreviousTab; }
        bind "l" { GoToNextTab; }
        bind "n" { NewTab; }
        bind "x" { CloseTab; }
        bind "r" { SwitchToMode "RenameTab"; TabNameInput 0; }
        bind "s" { ToggleActiveSyncTab; }
    }

    // Resize mode: Ctrl+n to enter
    resize {
        bind "h" { Resize "Increase Left"; }
        bind "l" { Resize "Increase Right"; }
        bind "j" { Resize "Increase Down"; }
        bind "k" { Resize "Increase Up"; }
        bind "H" { Resize "Decrease Left"; }
        bind "L" { Resize "Decrease Right"; }
        bind "J" { Resize "Decrease Down"; }
        bind "K" { Resize "Decrease Up"; }
        bind "=" { Resize "Increase"; }
        bind "-" { Resize "Decrease"; }
    }

    // Shared across all modes
    shared_except "normal" {
        bind "Esc" { SwitchToMode "Normal"; }
        bind "Enter" { SwitchToMode "Normal"; }
    }
}

The Alt key bindings in normal mode give you quick access to common actions without entering any mode at all. This hybrid approach gives experienced users speed while preserving discoverability through the mode system.

Theme Configuration

Zellij ships with several built-in themes, and you can define custom themes in your configuration. For teams that use a consistent color scheme across tools (we use Tokyo Night across our terminals, editors, and compositors), Zellij integrates cleanly:

theme "tokyo-night"

themes {
    tokyo-night {
        fg "#a9b1d6"
        bg "#1a1b26"
        black "#32344a"
        red "#f7768e"
        green "#9ece6a"
        yellow "#e0af68"
        blue "#7aa2f7"
        magenta "#ad8ee6"
        cyan "#449dab"
        white "#787c99"
        orange "#ff9e64"
    }

    catppuccin-mocha {
        fg "#cdd6f4"
        bg "#1e1e2e"
        black "#45475a"
        red "#f38ba8"
        green "#a6e3a1"
        yellow "#f9e2af"
        blue "#89b4fa"
        magenta "#cba6f7"
        cyan "#94e2d5"
        white "#bac2de"
        orange "#fab387"
    }
}

If you have set up Nerd Fonts on your system (covered in our complete Nerd Fonts guide), Zellij will automatically use powerline glyphs and icons in the status bar and tab bar plugins, producing a polished, information-rich interface. JetBrainsMono Nerd Font or FiraCode Nerd Font both render Zellij beautifully.

The Layout System: Zellij’s Killer Feature

If there is one feature that justifies switching from tmux to Zellij, it is the layout system. Layouts are KDL files that define an entire workspace: tabs, panes, pane sizes, commands to run in each pane, floating panes, and plugin panes. You save them as .kdl files in ~/.config/zellij/layouts/ and launch them by name.

Layout File Basics

// ~/.config/zellij/layouts/default.kdl
layout {
    // Default tab with standard splits
    tab name="main" {
        pane split_direction="vertical" {
            pane size="60%"
            pane size="40%" split_direction="horizontal" {
                pane
                pane
            }
        }
    }
    tab name="monitoring" {
        pane
    }
}

Load any layout from the command line:

zellij --layout ~/.config/zellij/layouts/default.kdl

Or, if the layout is in the standard layouts directory, reference it by name:

zellij --layout default

Running Commands in Panes

Layouts can specify commands that run automatically when the layout loads. This turns layouts into complete project workspace definitions:

// ~/.config/zellij/layouts/webdev.kdl
layout {
    tab name="editor" focus=true {
        pane command="nvim" {
            args "."
        }
    }
    tab name="servers" {
        pane split_direction="vertical" {
            pane name="frontend" command="npm" {
                args "run" "dev"
            }
            pane name="backend" command="cargo" {
                args "watch" "-x" "run"
            }
        }
    }
    tab name="git" {
        pane command="lazygit"
    }
}

Floating Panes in Layouts

layout {
    tab name="work" {
        pane split_direction="vertical" {
            pane size="70%"
            pane size="30%"
        }
        floating_panes {
            pane name="quick-terminal" {
                x 10
                y 5
                width 80
                height 20
            }
        }
    }
}

Floating panes defined in layouts start hidden and can be toggled with Alt+f or the pane mode floating toggle. This is perfect for scratch terminals, quick calculations, or monitoring commands you check periodically.

Layout Templates for Cybersecurity Assessments

Here is a layout we use at Petronella for security assessment engagements. It sets up a complete assessment workspace with tabs for each phase of the engagement:

// ~/.config/zellij/layouts/security-assessment.kdl
layout {
    tab name="recon" focus=true {
        pane split_direction="vertical" {
            pane name="nmap" size="50%" command="bash" {
                args "-c" "echo 'Ready for nmap scans. Usage: nmap -sV -sC target'"
            }
            pane split_direction="horizontal" size="50%" {
                pane name="dns-enum"
                pane name="osint"
            }
        }
    }
    tab name="exploit" {
        pane split_direction="vertical" {
            pane name="primary" size="60%"
            pane split_direction="horizontal" size="40%" {
                pane name="listener"
                pane name="payloads"
            }
        }
    }
    tab name="evidence" {
        pane split_direction="vertical" {
            pane name="screenshots" size="50%"
            pane name="notes" size="50%" command="nvim" {
                args "evidence.md"
            }
        }
    }
    tab name="report" {
        pane command="nvim" {
            args "report.md"
        }
    }
    tab name="monitoring" {
        pane split_direction="horizontal" {
            pane name="traffic" command="bash" {
                args "-c" "echo 'Network monitoring pane. Use tcpdump or wireshark-cli.'"
            }
            pane name="logs" command="bash" {
                args "-c" "echo 'Log monitoring pane. Tail relevant logs here.'"
            }
        }
    }
}

Every team member loads the same layout, producing a consistent workflow across the engagement. New analysts do not need to manually set up their terminal environment; they launch the layout and start working.

Layout Template for AI Training Monitoring

For AI development and model training work, we use a layout that monitors distributed training jobs, GPU utilization, and experiment logs:

// ~/.config/zellij/layouts/ai-training.kdl
layout {
    tab name="training" focus=true {
        pane split_direction="vertical" {
            pane name="train-log" size="60%" command="bash" {
                args "-c" "echo 'Attach to training process log here'"
            }
            pane split_direction="horizontal" size="40%" {
                pane name="gpu-monitor" command="watch" {
                    args "-n" "2" "nvidia-smi"
                }
                pane name="system" command="btop"
            }
        }
    }
    tab name="experiments" {
        pane split_direction="vertical" {
            pane name="mlflow" size="50%"
            pane name="tensorboard" size="50%"
        }
    }
    tab name="data" {
        pane split_direction="vertical" {
            pane name="explorer" size="40%"
            pane name="processing" size="60%"
        }
    }
    tab name="code" {
        pane command="nvim" {
            args "."
        }
    }
}

The watch nvidia-smi pane refreshes GPU metrics every two seconds, giving you continuous visibility into VRAM usage, temperature, and utilization across your GPU hardware without needing a separate monitoring window.

Plugin System and WebAssembly

Zellij’s plugin architecture is one of its most forward-thinking design decisions. Plugins are compiled to WebAssembly and run inside a sandboxed WASM runtime within the Zellij server process. This provides security (plugins cannot access the filesystem or network unless explicitly granted permission), portability (a plugin compiled on one system runs on any other), and language flexibility.

Built-in Plugins

Zellij ships with several plugins that handle core UI functionality:

• compact-bar / tab-bar: Renders the tab strip at the top of the terminal. Shows tab names, active tab highlighting, and sync indicators.
• status-bar: The bottom bar that displays available keybindings for the current mode. This is the discoverability engine of Zellij.
• strider: A built-in file manager plugin that lets you browse directories and open files in new panes without leaving Zellij.
• session-manager: Lists all active sessions with a picker interface for switching, creating, and managing sessions.
• filepicker: A file selection dialog used by other plugins and available for layout integration.

You can include plugins in layouts:

layout {
    pane size=1 borderless=true {
        plugin location="compact-bar"
    }
    pane split_direction="vertical" {
        pane size="25%" {
            plugin location="strider"
        }
        pane size="75%"
    }
    pane size=2 borderless=true {
        plugin location="status-bar"
    }
}

Writing Custom WASM Plugins

Custom plugins are typically written in Rust using the zellij-tile crate, though any language with a WASM target works. Here is a minimal Rust plugin structure:

// Cargo.toml
[package]
name = "my-zellij-plugin"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib"]

[dependencies]
zellij-tile = "0.40"

// src/lib.rs
use zellij_tile::prelude::*;

#[derive(Default)]
struct MyPlugin;

register_plugin!(MyPlugin);

impl ZellijPlugin for MyPlugin {
    fn load(&mut self, _configuration: BTreeMap<String, String>) {
        subscribe(&[EventType::ModeUpdate, EventType::TabUpdate]);
    }

    fn update(&mut self, event: Event) -> bool {
        match event {
            Event::ModeUpdate(mode_info) => {
                // React to mode changes
                true // returning true triggers a render
            }
            Event::TabUpdate(tabs) => {
                // React to tab changes
                true
            }
            _ => false,
        }
    }

    fn render(&mut self, rows: usize, cols: usize) {
        println!("My custom plugin: {}x{}", cols, rows);
    }
}

Build with cargo build --release --target wasm32-wasip1, then reference the resulting .wasm file in your layout or configuration.

Community Plugins Worth Installing

• zellij-forgot: A searchable cheat sheet plugin. Type a keyword and it shows matching keybindings and commands. Useful while learning Zellij or for teams with custom bindings.
• zjstatus: A highly configurable status bar replacement with modules for git branch, system metrics, weather, and custom scripts. More flexible than the built-in status bar.
• zellij-nav: Seamless navigation between Zellij panes and Neovim splits, similar to vim-tmux-navigator for the tmux ecosystem.
• room: A session manager with a richer UI, supporting session previews and workspace descriptions.
• monocle: A scrollback search plugin with fuzzy finding capabilities, similar to tmux-fingers or tmux-yank but native to Zellij.

Install community plugins by downloading the .wasm file and placing it in ~/.config/zellij/plugins/, then reference it in your layout or configuration by path.

Zellij for AI Development

AI development workflows involve long-running processes, multi-node monitoring, and frequent context switching between code, logs, and system metrics. Zellij addresses each of these needs better than tmux for several reasons.

Multi-Pane Monitoring of Distributed Training

When training a model across multiple GPUs or nodes, you need visibility into each node’s status simultaneously. Zellij’s tab sync feature (ToggleActiveSyncTab) lets you type a command in one pane and have it execute in all panes of the same tab. SSH into four GPU nodes, enable sync, and run nvidia-smi in all of them at once. Disable sync to interact with individual nodes.

Combined with the layout system, you can define a training monitoring workspace that connects to your entire cluster on startup:

// ai-cluster-monitor.kdl
layout {
    tab name="cluster" {
        pane split_direction="vertical" {
            pane name="gpu-node-1" command="ssh" {
                args "gpu1" "-t" "watch -n 2 nvidia-smi"
            }
            pane name="gpu-node-2" command="ssh" {
                args "gpu2" "-t" "watch -n 2 nvidia-smi"
            }
        }
        pane split_direction="vertical" {
            pane name="gpu-node-3" command="ssh" {
                args "gpu3" "-t" "watch -n 2 nvidia-smi"
            }
            pane name="gpu-node-4" command="ssh" {
                args "gpu4" "-t" "watch -n 2 nvidia-smi"
            }
        }
    }
}

Floating Panes for Quick Checks

During a training run, you frequently need to check metrics without disrupting your current view. Toggle a floating pane with Alt+f, run nvidia-smi or gpustat, check the result, and dismiss the pane. Your primary layout remains untouched. In tmux, this requires switching to another pane or window, which loses your visual context.

Session Persistence for Long-Running Experiments

AI training jobs run for hours or days. Zellij sessions persist even if your SSH connection drops or your local terminal crashes. Reconnect and run zellij attach training-run-42 to resume exactly where you left off, with all panes, tabs, scrollback, and running processes intact. Session serialization (enabled with session_serialization true) also saves and restores your layout structure when Zellij restarts.

Integration with AI Development Tools

Zellij works well alongside the tools in our AI services stack. Run MLflow tracking in one tab, TensorBoard in another, and your training script in a third. The strider file manager plugin provides quick filesystem navigation for organizing datasets and checkpoints without leaving the terminal.

Zellij for Cybersecurity

Security professionals live in the terminal. Penetration testing, incident response, forensic analysis, and compliance auditing all require juggling multiple tools, sessions, and outputs simultaneously. Zellij offers concrete advantages over tmux for these workflows.

Running Multiple Assessment Tools Simultaneously

A typical penetration test involves running nmap in one pane, Burp Suite proxy output in another, a reverse shell listener in a third, and note-taking in a fourth. Zellij layouts let you pre-define these workspaces for different engagement types (external network, internal network, web application, wireless) so that every assessment starts from a consistent, documented baseline.

The floating pane feature is especially useful during assessments. You are reviewing nmap output and need to quickly decode a base64 string or look up a CVE. Toggle a floating pane, run the command, copy the result, and dismiss the pane. Your assessment layout stays exactly as it was.

Session Logging

Zellij supports scrollback export per pane, which is valuable for evidence collection during assessments. You can dump the full scrollback of any pane to a file using Ctrl+s (scroll mode) and then the dump keybinding, or use the zellij action dump-screen IPC command for scripted captures. For organizations that require CMMC compliance, having terminal session logs as evidence artifacts is a practical requirement.

Secure Remote Access Patterns

When connecting to client environments for assessments, Zellij sessions on a jump host provide session persistence and isolation. If the VPN drops, your tools keep running in the Zellij session on the jump host. Reconnect and reattach. This is the same capability tmux provides, but Zellij adds the layout system (start a consistent environment on every engagement) and the visual discoverability that helps team members who do not use terminal multiplexers daily.

For organizations building security operations centers or managed IT environments, standardizing on Zellij layouts means every analyst gets the same monitoring dashboard layout, reducing setup time and ensuring consistent operational procedures.

Comparison Table: Zellij vs tmux vs screen

A note on performance: tmux is leaner in memory because it does not embed a WASM runtime or render a rich status bar by default. On modern hardware, the difference (15 MB vs 5 MB) is negligible. The comparison matters only on extremely constrained embedded systems or containers, where tmux or screen remain the better choices.

Migration Guide from tmux to Zellij

If you are a tmux user considering the switch, here is a practical migration path that does not require going cold turkey.

Step 1: Install Zellij Alongside tmux

There is no conflict between having both installed. Keep tmux for existing sessions and workflows while you learn Zellij in parallel. Run zellij when starting new work and tmux when you need your established environment.

Step 2: Map Your Core tmux Workflow

Identify the tmux commands you use most frequently and find their Zellij equivalents:

Step 3: Convert tmux Scripts to Zellij Layouts

If you have tmux startup scripts that create windows and panes, convert them to Zellij layout files. A tmux script like this:

tmux new-session -d -s dev
tmux split-window -h
tmux split-window -v
tmux select-pane -t 0
tmux send-keys "nvim ." Enter
tmux attach -t dev

Becomes this Zellij layout:

layout {
    tab name="dev" {
        pane split_direction="vertical" {
            pane command="nvim" {
                args "."
            }
            pane split_direction="horizontal" {
                pane
                pane
            }
        }
    }
}

The Zellij version is more readable, reusable, and does not depend on shell scripting semantics.

Step 4: Adopt Gradually

Start with personal workstations before rolling Zellij out to servers. Servers often have older distributions where installing Zellij requires compiling from source or copying a static binary. On servers where you only need basic session persistence (no layouts, no plugins), tmux remains perfectly serviceable. The strongest case for Zellij is on development workstations where you benefit from the layout system, floating panes, and discoverability features.

Frequently Asked Questions

Is Zellij production-ready?

Yes. Zellij has been stable for daily use since the 0.35+ releases. Our team has run it on NixOS workstations and remote servers throughout 2025 and 2026 with no data-loss incidents. The project follows semantic versioning and publishes detailed changelogs. The 0.x version number reflects the developers’ high bar for 1.0, not instability.

Does Zellij work over SSH?

Yes. Zellij works over SSH identically to tmux. Start a Zellij session on the remote host, detach, disconnect, reconnect, and reattach. The session and all its panes, tabs, and running processes persist on the remote server. The only requirement is that Zellij is installed on the remote host.

Can I use Zellij inside tmux or vice versa?

Technically yes, but it is not recommended. Nesting terminal multiplexers creates confusing keybinding conflicts and wastes resources. If you run Zellij locally and SSH into a server running tmux, the keybinding namespaces are different enough (Zellij uses modes, tmux uses a prefix) that coexistence is manageable. But avoid running Zellij inside Zellij or tmux inside tmux.

How does Zellij compare to Wezterm’s multiplexing?

Wezterm (a GPU-accelerated terminal emulator) includes built-in multiplexing features: tabs, splits, and a form of session persistence. The key difference is that Zellij is terminal-emulator-agnostic. It works inside any terminal: kitty, alacritty, foot, wezterm, or the default GNOME terminal. If you use Wezterm exclusively, its built-in multiplexing may suffice. If you switch between terminals or need to work over SSH, Zellij provides consistent multiplexing regardless of the terminal emulator.

Does Zellij support true color and Unicode?

Yes. Zellij passes through true color (24-bit) and Unicode, including emoji and Nerd Font glyphs for powerline symbols and icons. Ensure your terminal emulator supports true color (TERM=xterm-256color or better) and that your font includes the necessary glyphs. See our Nerd Fonts setup guide for font configuration details.

Can I run Zellij inside a compositor like Niri or Hyprland?

Absolutely. Zellij is a terminal application, not a compositor. It runs inside any terminal emulator on any compositor or desktop environment. Our team runs Zellij inside kitty on Niri (our scrollable tiling Wayland compositor) and inside alacritty on Hyprland. The compositor manages windows; Zellij manages terminal sessions within a single window. They complement each other: Niri or Hyprland for window-level tiling, Zellij for terminal-level multiplexing.

Is there a GUI or web interface for Zellij?

No. Zellij is a terminal-native tool. There is no web UI, Electron wrapper, or graphical configuration editor. Configuration is done through KDL files, and interaction is through keyboard (and mouse) within the terminal. This is by design: the target audience is developers and system administrators who work primarily in the terminal.

Getting Started

Install Zellij using your preferred method, launch it with zellij, and spend your first session exploring the modes. Press Ctrl+p for pane mode, Ctrl+t for tab mode, and read the status bar at the bottom. Within 15 minutes, you will understand the navigation model. Create a layout file for your most common workflow, save it in ~/.config/zellij/layouts/, and launch it with zellij --layout name. That single layout file will save you hours of manual pane arrangement over the coming weeks.

For teams running Material Shell on GNOME or another desktop environment and looking to standardize their terminal workflow, Zellij layouts provide a consistent, shareable, version-controllable way to define workspaces that every team member can use identically.

If your organization needs guidance on terminal workflow standardization, Linux workstation deployment, AI development infrastructure, or hardware selection for compute-intensive workloads, contact Petronella at (919) 348-4912 for a consultation.

About the Author: Craig Petronella is the CEO of Petronella Technology Group, a cybersecurity and IT infrastructure firm in Raleigh, NC. With CMMC-RP, CCNA, CWNE, and DFE certifications and over 30 years in IT, Craig’s team uses Zellij daily across NixOS workstations for security research, AI model training, and infrastructure management.