Learn Zellij - Session Manager & Multi-Session Workflow

#Introduction

In episode 17 you gave Zellij long-term memory through session resurrection. Now it's time to put that memory to maximum use. Episode 18 covers Session Manager & Multi-Session Workflow: how to manage many sessions at once, switch between sessions quickly, and make sessions the main organizational unit of your work.

One trap beginner Zellij users often fall into: they create a single session, then pile all their work into it — several projects, several contexts, all mixed together in countless tabs. It works, but it's like opening ten jobs in one browser window without bookmarks: the more tabs, the harder it is to find what you're looking for. A far healthier pattern is one session per context, and this episode will build that habit.

The good news is that Zellij has provided the infrastructure for this pattern for a long time. Session-manager exists as a built-in plugin that's constantly refined, and in version 0.44 its interface was completely overhauled into a single screen with fuzzy search. Armed with session resurrection from episode 17, every session now has an identity that persists — its name, its layout, even the commands that were running — so managing many sessions feels like managing a set of neatly stored applications, not scattered terminal windows.

We'll cover four things: the session-manager plugin as a control center, the one-session-per-project pattern, parallel workflows across sessions, and fzf integration for switching sessions in the blink of an eye. By the end of the episode, you'll see sessions the way you see "apps" in an operating system: each one has its own name, contents, and lifecycle, and you know exactly how to move between them.

#Session Manager: The Control Center for All Sessions

Session-manager is Zellij's built-in plugin providing an interface for managing all sessions on your machine. It's the interactive version of zellij ls — but with full capabilities: attach, switch, create, rename, resurrect, and delete, all from one screen, without leaving a session.

To open it from inside a session, press Ctrl+o then w. Since version 0.44, the interface has been simplified into a single screen: you type a session name, and Zellij guesses your intent — if the session exists and is alive, you attach; if it has exited, the session is resurrected; if it doesn't exist yet, a new session is created. The search is fuzzy, so typing part of a name is enough to find the target session.

Interestingly, session-manager and the welcome-screen are the same plugin — zellij:session-manager. The only difference is the welcome_screen true configuration that makes it appear as a startup screen when Zellij starts without a specific session:

plugins {
    session-manager location="zellij:session-manager"
    welcome-screen location="zellij:session-manager" {
        welcome_screen true
    }
}

With the configuration above, opening a new terminal immediately shows a welcome-screen listing your sessions — the perfect place to start the workday: pick the session you want to continue, or type a new name to start another project.

#Navigation & Operations in the Session Manager

Once session-manager is open, you work with a list already familiar from episode 17: live sessions in one section, resurrectable sessions in another. Here are the core operations you'll use most:

Rename is a lifesaver that's often forgotten. In the middle of chaotic work, you might forget the name of the session you're in — or the session was given a random name by Zellij. With Ctrl+r, you can change its name to something meaningful, and because renamed sessions are recorded in serialization, that name also becomes their identity when resurrected in episode 17.

#One Session Per Project

The most effective pattern you can adopt today: one session per project. If you work on five projects, have five sessions — each with a layout, tabs, and name that reflect the project. The benefits are immediate: one project's long processes don't interfere with another's, and switching context is just switching sessions, not spinning through tabs in a single crowded space.

Start with consistent names. Use the project name or a project-plus-context combination — for example api, web, infra-deploy. When starting a new session, don't forget to bring along the layout you prepared in episode 10:

zellij -s web -l dev-web
zellij -s api -l dev-api

The two commands above create two separate sessions with their own layouts. Note that each layout can set a different cwd and environment — the pattern we discussed in episode 17 — so each session lands in the right context immediately.

#Parallel Workflows Across Sessions

The real power of multi-session shows when several sessions run in parallel. For example, the api session runs the backend server and tails logs, while the web session runs the frontend dev server and editor. Both live side by side, never blocking each other, and can be accessed alternately.

Switching between them is done with zellij attach -c — the -c flag means "attach or create", so the same command works both for entering an existing session and for building one for the first time:

zellij attach -c api
zellij attach -c web

To see the full picture of running sessions, run zellij list-sessions (or zellij ls) from any shell. Its output shows the name and status of each session, and because serialization from episode 17 is active, exited sessions show up as EXITED too. This is the fastest way to map the workspace state before deciding where to move:

zellij ls

Session name          Status
api                   RUNNING
web                   RUNNING
pipeline              EXITED - attach to resurrect

Notice that api and web are both RUNNING — they live side by side in the background, while pipeline waits to be resurrected. From a list like this, context-switch decisions can be made in a single glance, and episode 17's memory works exactly as promised: whatever exited, can return.

From inside a session, switching can be done through session-manager: open it with Ctrl+o then w, pick the target session, and press Enter. When you switch, the session you left keeps running fully in the background — its processes don't stop just because you moved focus. This is the same behavior as detach (Ctrl+o then d), only smoother because it doesn't go through a shell.

#fzf Integration for Switching Sessions

For maximum agility, combine Zellij with fzf, the fuzzy finder you already met in episode 13. The idea is simple: a script lists projects, you pick one with fzf, and the script automatically creates or enters the Zellij session for that project. This is a very popular pattern in the multiplexer ecosystem — its tmux version is known as a sessionizer.

#!/usr/bin/env bash
set -euo pipefail
 
if [[ -n "${ZELLIJ:-}" ]]; then
    zellij action launch-or-focus-plugin "zellij:session-manager"
    exit 0
fi
 
selected=$(fd . ~/projects --min-depth 1 --max-depth 2 --type d | fzf)
 
if [[ -z "$selected" ]]; then
    exit 0
fi
 
session_name=$(basename "$selected" | tr . _)
cd "$selected"
zellij attach "$session_name" -c

Read the script above line by line: if you're already inside Zellij, the script just opens session-manager — there's no point creating stacked sessions from within a session. If you're outside Zellij, fzf shows a list of directories under ~/projects, and once a selection is made, the script enters that directory then attaches (or creates, thanks to -c) a session named after the project folder.

For those of you not using fd, a find variant works just as well:

selected=$(fd . ~/projects --min-depth 1 --max-depth 2 --type d | fzf)

selected=$(find ~/projects -mindepth 1 -maxdepth 2 -type d | fzf)

Finally, put the script in your PATH and create a quick invocation. In .zshrc, bind it to Ctrl+t; in bash, use an alias:

bindkey -s '^t' 'zellij-sessionizer\n'

alias zellij-sessionizer=~/bin/zellij-sessionizer

To use this script, make sure zellij-sessionizer is executable and in your PATH: chmod +x ~/bin/zellij-sessionizer and make sure ~/bin is listed in PATH. After that, the binding above works from any directory. The script is also idempotent — running it repeatedly for the same project just returns you to the existing session, never creating duplicates. If you use several machines, put this script into your dotfiles (a pattern we'll discuss in episode 27) so consistency holds everywhere.

With this setup, your workflow becomes: press Ctrl+t, type three letters of the project, Enter — and you land in the right session, with the right layout and working directory. Switching projects no longer takes more than two seconds.

#Common Pitfalls

1. Leaving sessions without clear names. Five randomly named sessions are a puzzle every morning. Rename immediately with Ctrl+r in session-manager, or create a name from the start with zellij -s name. Clear names make session-manager, fzf, and the resurrect list reliable tools instead of sources of confusion.
2. Piling all projects into one session. This creates countless tabs and messy context. Split into one session per project, and let session-manager be the bridge. As a guideline: if a single tab could be renamed to another project's name, you're forcing one session to hold too many contexts.
3. Assuming attach creates a session. zellij attach name fails if the session doesn't exist. Use -c (attach or create) when you want "create if absent" behavior. The sessionizer script we wrote above automatically uses this pattern.
4. Expecting session-manager to show remote sessions. Session-manager only sees sessions on the same machine. To manage sessions on another server, you must SSH there first — we'll deepen this pattern in episode 19, including the 0.44 remote sessions approach that crosses machine boundaries.
5. Letting dead sessions litter the list. Useless EXITED sessions pile up in zellij ls. Delete them with zellij delete-session to keep the list focused on what's actually relevant, and make this cleanup part of a weekly routine.

#Closing

In this episode 18 you've turned Zellij from a mere multiplexer into an organized workspace manager. We started with session-manager — the control center for attach, switch, create, rename, resurrect, and delete — then adopted the one-session-per-project pattern so each context has its own home. You also saw how parallel workflows leverage sessions running side by side, and closed with fzf integration that makes project switching take just two seconds.

The points to take away:

• Session-manager is opened with Ctrl+o then w; in version 0.44 its interface is a single screen with fuzzy search.
• The welcome-screen is session-manager configured as a startup screen.
• One session per project with consistent names is the most effective management pattern.
• zellij attach -c creates a session if it doesn't exist and attaches if it does.
• The fzf sessionizer turns project switching into a single keypress.

Remember, the Learn Zellij series consists of 28 episodes that build on each other. Managing many sessions on one machine is tidy now — but what if those sessions are on a distant server whose connection drops often? In episode 19 we cover Remote Development & SSH Workflow: running Zellij on a remote server, disconnect-tolerant attach/detach, mosh for slow connections, jump hosts or bastions, and the 0.44 remote sessions feature for cross-machine attach. See you in episode 19!