zellij.dev

A terminal multiplexer is a program that runs inside your terminal and lets one terminal window or SSH connection host multiple sessions, windows, and panes — and keep them alive after you disconnect. You need one when you work over SSH, want to split one terminal into several views, or need a long-running process to survive a dropped connection. You probably don't need one for quick single-window local work. Zellij is a modern example: it is free and open source, and its maintainers also run a paid hosted session-sharing service that is currently in beta.

The problem a multiplexer solves

A normal terminal window is one view onto one shell. Close the window or lose the network, and whatever was running in that shell is gone. A multiplexer sits between your terminal and your shells and adds three things:

• Multiple views from one connection. Split the screen into panes, or keep several windows/tabs, all inside a single terminal or SSH session.
• Persistence. The multiplexer keeps running in the background. Detach, close the laptop, reconnect later, and reattach to the same session with the same state.
• Sharing. Because sessions are managed by the multiplexer rather than the terminal window, they can be attached to from more than one place.

Multiplexer vs. terminal emulator vs. shell

These are three different layers, and knowing which one you're choosing prevents confusion:

A multiplexer runs inside a terminal emulator and around your shells. So "split panes" can mean two things: the emulator's own split feature (which dies with the window) or the multiplexer's panes (which persist). If persistence is the point, you want the multiplexer's panes.

What you actually do with one

• Split panes: run an editor in one pane, logs or a test watcher in another, a shell prompt in a third — all in one window.
• Detach and reattach: start a long build or a remote job, detach, log out, come back later, and reattach to find it still running.
• Survive disconnects: work on a remote machine over SSH; if the connection drops, the session on the server keeps going.
• Share a session: hand someone a view of your session for pairing or support. Zellij's maintainers offer this as a paid hosted service (in beta); self-hosted sharing is a general multiplexer capability.

Zellij as a concrete example

Zellij describes itself as a "terminal workspace with batteries included," written in Rust. On its site you can download builds for Linux, macOS, and Windows, or try it without installing — for bash/zsh:

bash <(curl -L https://zellij.dev/launch)

For fish:

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

For PowerShell:

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

The site links to the scripts that will be executed, so you can read them before running. The "batteries included" framing points at the usual multiplexer features — panes, sessions, detach/reattach — presented with defaults and on-screen hints rather than requiring a large config file first. Note that the try-without-installing commands download and execute a script; if that's not acceptable in your environment, use a normal install instead.

When a multiplexer is unnecessary

Skip it if all of the following are true: you work locally, in one window, and nothing you run needs to outlive that window. A terminal emulator's built-in tabs and splits cover that case with less to learn. Add a multiplexer when you start needing sessions that persist, remote work over SSH, or a consistent pane layout you can reattach to — that's the point where the extra layer pays for itself.

Zellij is a terminal workspace and multiplexer written in Rust—it is not the Rust programming language, a Rust toolchain, or a Rust-specific IDE. You can use Zellij with any shell and any language; Rust is simply the language it was built in. Choose Zellij if you want panes, tabs, and layouts inside one terminal window; skip it if you only need a single shell session and no session persistence.

What Zellij actually is

Zellij describes itself as a "Terminal Workspace with Batteries Included." In practice, it sits between your terminal emulator and your shell:

• Terminal emulator: the window that draws text (e.g., the app you open on your desktop).
• Shell: the program that reads commands (bash, zsh, fish, PowerShell).
• Zellij: a multiplexer/workspace that runs shells and other programs inside panes, tabs, and reusable layouts.

So Zellij does not replace your shell. It manages multiple programs—including shells—inside one terminal window.

Why "written in Rust" matters (and what it doesn't mean)

Zellij's site lists Rust among its keywords and presents Zellij as a terminal workspace. The Rust connection is about implementation, not usage:

• You do not need Rust installed to download or try Zellij.
• Rust is not a prerequisite for configuring or using panes, tabs, or layouts.
• Cross-platform availability is shown directly on the site: Linux, macOS, and Windows downloads are offered.
• Performance and reliability are reasonable expectations from a compiled systems language, but the site's page evidence does not publish benchmarks—treat speed claims as general, not measured.

If your actual goal is learning Rust, Zellij is not a learning tool. It is a terminal workspace you might happen to run cargo commands inside.

How to try or install it

The site provides both downloads and a no-install trial. The trial commands, as listed on zellij.dev:

For bash/zsh:

bash <(curl -L https://zellij.dev/launch)

For fish:

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

For PowerShell:

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

What happens: the command fetches and runs a launch script, starting Zellij without a permanent install. Expected result: you land in a Zellij session where you can open panes and tabs. Verification: confirm you can create a second pane and switch between them, then exit the session.

Common sticking points:

• Running the trial script executes remote code—review the linked script first if that matters in your environment.
• The fish syntax differs from bash/zsh; using the wrong one fails at the shell level, not inside Zellij.
• For a lasting setup, use the Linux, macOS, or Windows download links rather than the trial script.

Free, open source—and one paid service

Zellij states it is free and open source. The maintainers also run a paid hosted session sharing service, currently in beta. That means:

• The core terminal workspace is free and open source.
• Session sharing hosted by the maintainers is a separate paid offering in beta.
• The page evidence does not list prices, so check the site for current terms before relying on the hosted service.

Is it worth using?

Use Zellij if you want a multiplexer with built-in layouts and a workspace feel, and you value a single cross-platform tool for Linux, macOS, and Windows. It is a poor fit if you need only one shell tab, or if you were looking for Rust language tooling—in that case, look at the Rust toolchain instead.

A terminal is the text-based window (or its underlying emulator) that displays output and accepts keyboard input; a shell is the program that runs inside that window and interprets your commands. Xonsh is a Python-powered shell, so it runs inside a terminal the same way Bash or Zsh does — the terminal handles display and input, while Xonsh decides what your typed lines actually mean. This distinction matters whenever you troubleshoot "the command did nothing," "the shell isn't found," or "which layer am I configuring?"

Terminal vs. shell vs. REPL vs. command line

These four terms get used interchangeably in casual conversation, but they sit at different layers:

The practical takeaway: when something goes wrong, ask which layer is involved. A blank window is a terminal problem. A prompt that rejects your syntax is a shell problem. A Python expression that errors only in one shell is a language problem.

Why the terminal and shell are separate layers

Historically, a terminal was a physical device (a teletype or a dedicated screen and keyboard) wired to a larger computer. The shell was the program on that computer reading your input and sending back output. Modern systems replace the hardware with a terminal emulator — software that behaves like the old device — but the split remains:

• The terminal owns the window, fonts, colors, scrollback, tabs, and key bindings.
• The shell owns command parsing, variables, pipelines, job control, and startup files.

Because they're separate, you can change one without the other. You can run Bash, Zsh, Fish, or Xonsh in the same terminal window, and you can run the same shell in many different terminals. That's also why "my prompt looks different in a new window" is usually a terminal-config issue, while "my alias stopped working" is a shell-config issue.

Where Xonsh fits

Xonsh describes itself as a full-featured, cross-platform, Python-powered shell. Its language is a superset of Python 3 with shell functionality integrated directly, so the same prompt accepts both shell primitives and Python:

cd $HOME
cat /etc/passwd | grep root
2 + 2
var = "hello"
import json; json.loads('{"a":1}')

The first two lines are ordinary shell behavior — changing directory, piping through grep. The next lines are Python running in the same session. Xonsh also lets the two mix, for example appending to a path with $PATH.append('/tmp') or reading a file with p '/etc/passwd'.read_text().

Because Xonsh is a shell, it runs inside a terminal on every platform it supports. The project lists Linux, macOS, Windows, BSD, Jupyter, Android, Raspberry Pi, and Nix. The terminal you use on each of those is a separate choice — Xonsh doesn't replace the terminal, it replaces the shell running in it.

What this means when you troubleshoot

• "I opened a terminal and nothing happens." The terminal launched but no shell started, or the shell exited immediately. Check your terminal's configured shell command.
• "My command isn't recognized." You're likely in a different shell than you expect. Confirm which shell is running before editing aliases or startup files.
• "Python syntax works here but not there." You're probably in Bash or Zsh in one window and Xonsh in another. The terminal looks identical; the shell differs.
• "I want Xonsh but don't want to lose my current terminal." You don't have to — install Xonsh and start it from your existing terminal, or set it as your default shell.

Quick way to tell which layer you're in

At the prompt, ask the shell to identify itself. In Bash or Zsh, echo $0 or echo $SHELL reports the shell. In Xonsh, the same shell primitives work, and you can also drop into Python directly to inspect the environment. If a command behaves unexpectedly, checking the shell identity first usually resolves the confusion faster than editing configuration.

The short version: the terminal is the container, the shell is the interpreter, and Xonsh is one such interpreter — a Python-superset shell that runs in terminals across Linux, macOS, Windows, Android, and more.