Learn Zellij - Pre-Requisites Skill & Environment Setup

#Introduction

Welcome to the Learn Zellij series! This series will take you from zero to building a productive, secure, production-ready terminal workspace. It totals 28 episodes that build on each other: prerequisites and environment setup, the history of why Zellij was born, the client-server architecture, session/tab/pane lifecycle, the mode system, scrollback and search, floating panes, config.kdl configuration, custom keybindings, KDL layouts, status bar and themes, pipes and CLI actions, the plugin system, session persistence, multiplayer, and finally a production-ready setup.

Why is Zellij important to learn? The terminal is the developer's home — yet most of us still work with a single narrow terminal window: one process, one screen, no memory when SSH disconnects. Zellij is a terminal workspace: it wraps the terminal with sessions, tabs, panes, floating panes, and a plugin system that all run keyboard-first. Built in Rust with plugins written in WASM, Zellij offers a modernity that older multiplexers lack while still surviving unstable connections.

This episode 0 is your roadmap. Before touching Zellij, we make sure of five things: (1) terminal skills and job control that feel comfortable under your fingers, (2) an understanding of processes and SSH for remote development, (3) a modern terminal with true color and a Nerd Font, (4) a mental model of a terminal workspace that will make Zellij's concepts feel familiar, and (5) a Zellij installation complete with a working first session. Every following episode assumes this foundation is solid. Let's begin.

#Terminal Skills You Must Master

Zellij doesn't replace the terminal — it sits on top of the terminal. Every Zellij pane is ultimately a process running inside a pseudo-terminal (PTY). If you aren't comfortable with basic CLI navigation, you won't get the most out of a Zellij workspace. These are the skills you must have before moving on.

Understand not just the commands, but the relationships between concepts: every Zellij pane is one shell process running inside a PTY. When you create a new pane, Zellij creates a new PTY and runs a shell inside it. When you close a pane, the process inside it is stopped too. This mental model — that a Zellij workspace is a collection of managed processes — is the key to understanding all the following episodes.

#Job Control: The Most Underrated Skill

Job control is the bridge between a plain terminal and a terminal workspace. The ability to suspend, move, and manage processes is what makes the multi-pane concept feel natural. Master the following commands until they flow:

Most Zellij workflows follow the same pattern: running a long process (dev server, tail log, build watcher) in one pane while another pane is used for editing code. If this flow still feels foreign, practice it here — because you'll be living inside it later.

#SSH: The Gateway to Remote Development

One of the biggest reasons people use a multiplexer is to survive SSH disconnects. When you work on a remote server and the connection drops, the foreground process dies with it. Zellij solves this with sessions that detach from the terminal. But for that, you need a basic grasp of SSH:

Basic SSH connection

ssh user@host
ssh -i ~/.ssh/id_ed25519 user@host

Understand three things about SSH before moving on:

• Key-based authentication: safer than passwords. Generate with ssh-keygen -t ed25519, then copy to the server with ssh-copy-id user@host.
• Persistent connection: use ControlMaster in ~/.ssh/config so SSH connections don't need to be re-handshaked every time — very helpful when attaching and detaching Zellij back and forth.
• Agent forwarding: ssh -A to forward the SSH agent — important when working through a bastion/jump host with Zellij.

Host myserver
    HostName 192.168.1.10
    User arman
    IdentityFile ~/.ssh/id_ed25519
    ControlMaster auto
    ControlPath ~/.ssh/controlmasters/%r@%h:%p
    ControlPersist 10m
    ServerAliveInterval 60
    ServerAliveCountMax 3

ServerAliveInterval and ServerAliveCountMax keep the connection alive and quickly detect dead connections — a perfect combination with Zellij surviving behind SSH.

#Shell Configuration: Home for Zellij

Zellij runs a shell inside every pane — and a healthy shell is the foundation of a comfortable workspace. Take the time to tidy up your shell before moving on. Note the two main files: the profile (loaded at login) and the rc (loaded every time an interactive shell starts). For bash: ~/.bash_profile and ~/.bashrc. For zsh: ~/.zshrc (one file for everything). For fish: ~/.config/fish/config.fish.

What should go in there?

One important detail for this series: Zellij respects $EDITOR. When you press e in Scroll mode to edit scrollback, Zellij opens the file in the editor defined by this variable. Set export EDITOR=nvim (or vim, code --wait) in your rc file — later in episode 6 this skill will prove very valuable.

#Modern Terminal: A Non-Negotiable Requirement

Zellij is an application hungry for modern terminal features. Some Zellij features (floating panes, web client, mouse support, automatic theme switching) depend on your terminal emulator's capabilities. Don't use a dated built-in terminal — invest five minutes to pick one:

The most important thing: true color support (24-bit). Zellij and its themes (dracula, catppuccin, etc.) rely on true color to look good. Check with the following command:

echo -e "\e[38;2;255;0;0mRED\e[0m"

If "RED" shows up in red, your terminal supports true color. Besides true color, make sure the terminal supports OSC 52 (remote clipboard) — a feature Zellij later uses for clipboard integration on remote hosts.

#Nerd Font: Making the Zellij Interface Beautiful

Zellij uses icons in the tab bar and status bar (active tab, active pane, active mode). These icons come from Nerd Font — a font enriched with thousands of glyphs. Without a Nerd Font, icons will appear as empty squares or strange characters. The two most popular options:

• JetBrainsMono Nerd Font — popular among developers, bold shapes.
• FiraCode Nerd Font — supports ligatures, comfortable for code.

Download from nerdfonts.com, install on your system, then set it as your terminal font. Verify the icons render by running a Zellij session later — the tab bar should display clear icons, not boxes.

#Installing Zellij

Zellij is available on almost every platform. Choose the method that fits best:

Option 1: Official installer (Linux/macOS)Option 2: Homebrew (macOS)Option 3: Windows (native / MSI)Option 4: Cargo (build from source)

curl -sSfL https://install.zellij.dev | bash

brew install zellij

winget install zellij.zellij

cargo install --locked zellij

Once installed, verify the installation:

zellij --version
zellij setup --check

zellij setup --check runs a series of environment checks — including a terminal check, a color check, and a configuration check. Green output means your environment is ready. Note the version: this series references Zellij 0.44.x; make sure your major version isn't too far behind so the commands in every episode remain valid.

#Your First Session

This is the "stress test" of this episode: start your first Zellij session and make sure everything works end to end — Zellij spawns a server, opens a pane, and renders the UI.

zellij

Once inside, you'll see:

• Tab bar at the top: shows the active tab name (tab 1) with an icon.
• Pane in the middle: your shell running inside the pane.
• Status bar at the bottom: shows the active mode (NORMAL), session name, and keybinding hints.

Try your first interactions: press Ctrl+p then n to create a new pane, Ctrl+p then h/l to move focus, and Ctrl+o then d to detach. After detaching, run zellij attach to attach again — notice that the shell inside the pane stays alive while you're away. That's the magic of a Zellij session.

#Common Pitfalls

1. Terminal doesn't support true color. Themes look "broken" and unappealing. Fix: move to a modern terminal (Kitty, WezTerm, Ghostty, Alacritty, iTerm2, Windows Terminal) before judging Zellij's appearance.
2. Nerd Font not set. Icons appear as boxes □. Fix: install a Nerd Font and set it in the terminal font settings.
3. Forgetting that detach ≠ close. Closing the terminal window while a Zellij session is running doesn't stop the processes inside panes — as long as the Zellij server isn't killed, the session persists. That's a feature, not a bug.
4. Zellij version too old. New feature commands (pipes, web client, remote sessions) aren't available in old versions. Always update to the latest stable version.
5. Ignoring job control. Without jobs/fg/bg, the multi-pane workflow feels awkward. Practice it first — this skill will shadow the entire series.

#Closing

In this episode 0 you've secured five foundations: terminal skills (navigation, file management, processes, job control), SSH understanding (key-based auth, persistent connections, agent forwarding) for remote development, a modern terminal with true color, a Nerd Font for a beautiful Zellij interface, and a verified Zellij installation — proven by a successfully running first session.

Key takeaways:

• Zellij sits on top of the terminal — every pane is a process running in a PTY.
• Detach ≠ close: Zellij sessions survive even when the terminal is closed.
• A modern terminal (true color + Nerd Font) is a non-negotiable requirement.
• SSH with key-based auth and persistent connections is Zellij's ideal partner.
• An unverified environment is a time bomb in this series.

Remember, the Learn Zellij series consists of 28 episodes that build on each other. Episode 0 is the first brick — and you've just laid it perfectly. In episode 1 next, we step back briefly to understand the history, background, and why Zellij was born: the evolution of terminal workspaces from GNU Screen and tmux, the story of Zellij first released in 2021, why Rust was chosen, and an honest comparison of Zellij against tmux and a plain terminal. See you in episode 1, and happy building your terminal workspace!