Learn Zellij - Editor Integration & Developer Ecosystem

#Introduction

The internal features covered in episode 25 are only half the story. The other half is how Zellij gets along with the tools you already use every day: editors, git clients, task runners, and file finders. Episode 26 bridges Zellij with the modern developer ecosystem — from Neovim and VS Code to lazygit, fzf, and AI coding assistants — with one goal: building a daily driver that's comfortable and fast, fully keyboard-first.

Why is this episode important? Many people try Zellij, then quit because it feels "foreign" — when the problem isn't Zellij, but an integration that was never set up. A Neovim that doesn't know how to talk to Zellij's clipboard, lazygit placed in the wrong pane, or a session switcher that doesn't exist makes the experience feel broken. Episode 26 tidies up each of those connection points one by one.

This episode's plan follows a developer's real workflow: (1) editing code in Neovim or VS Code inside a Zellij pane, (2) reviewing changes with lazygit, (3) running tasks with a task runner, (4) switching between sessions with fzf and the session-manager, and (5) using an AI coding assistant without leaving the terminal. By the end of the episode, you'll see the common pattern that makes all those integrations feel seamless.

#Zellij + Neovim: Seamless Navigation

Neovim is Zellij's most natural partner: both were born from the keyboard-first philosophy, and both live inside the terminal. The most basic pattern is putting Neovim in one pane and a shell in the pane next to it. Moving focus between them is as simple as Alt+h/j/k/l — no need to leave insert mode, no need to touch the mouse.

One thing that often frustrates people is the clipboard. Zellij supports OSC 52, the protocol that lets applications inside the terminal read and write the system clipboard. With this support, a Neovim that sets clipboard to unnamedplus will sync yank and paste with the system clipboard — as if Zellij weren't between them:

vim.opt.clipboard = "unnamedplus"
vim.opt.mouse = "a"

The mouse = "a" rule makes mouse selection inside Neovim handled by Neovim itself, while in a pure shell pane selection is handled by Zellij — the two coexist without conflict. For a more focused workspace, zoom a pane with Ctrl+p then f (ToggleFocusFullscreen) so Neovim takes the full screen, then return to the original layout with the same key.

There's also the "editor owns the whole pane" pattern: run Neovim in one large pane, then open a floating pane on top of it for quick commands like git diff, rg, or cargo test. Open a floating pane with Ctrl+p then w, and don't forget the pinned floating panes feature from episode 25 (Ctrl+p then i) if you want that pane to always stay on top.

One integration that's often overlooked is the scrollback editor. From Scroll mode (Ctrl+s), press e to open the scrollback contents in $EDITOR — Neovim or Vim by default. This is useful when log output is long and you want to work with it using normal editing: g to go to the start of the buffer, / to search, then :w to save. This way, a long terminal buffer never again becomes an unworkable wall of text.

#VS Code & the Built-in Terminal

Not everyone lives in Neovim, and that's fine. Zellij runs perfectly inside VS Code's built-in terminal — on Linux, macOS, and Windows. A common approach combines the two layers: VS Code handles editing and debugging, while Zellij inside its terminal handles sessions, multiple panes, and persistence. This way, you still get the benefit of Zellij sessions that survive even when the VS Code window is closed.

For Zellij to display correctly in the VS Code terminal, make sure of two things. First, set the terminal font to a Nerd Font — in VS Code, set terminal.integrated.fontFamily to an installed Nerd Font, for example JetBrainsMono Nerd Font. Second, make sure true color is enabled; the VS Code terminal supports it by default. Without both, Zellij's tab-bar and status-bar will look broken.

{
  "terminal.integrated.fontFamily": "JetBrainsMono Nerd Font",
  "terminal.integrated.defaultProfile.linux": "zsh",
  "terminal.integrated.enableBell": false
}

For Windows, 0.44 brings native support that makes this experience far smoother. For those using WSL, Zellij also runs normally inside a Linux distribution on WSL. The pattern to remember: Zellij inside the VS Code terminal is an ordinary process like bash or zsh — don't hesitate to set zellij -l welcome as the VS Code startup shell, so every new terminal opens straight to the welcome screen for choosing a session.

#lazygit & Task Runner Inside a Pane

lazygit is a terminal UI for Git that runs perfectly inside a Zellij pane. The most productive pattern is a dedicated lazygit pane always open next to the editor pane: Alt+h to move to the editor, Alt+l to return to lazygit. In lazygit, select files, press space to stage, c to commit — then return to the editor pane to keep writing code.

Because lazygit is a full TUI application, it's most comfortable in a reasonably wide pane. In a layout, give the lazygit pane a balanced share:

layout {
    tab name="code" focus=true {
        pane command="nvim" size=60%
        pane split_direction="vertical" {
            pane command="lazygit" size=50%
            pane command="git log --oneline --graph --decorate --all -20"
        }
    }
}

For task runners, Zellij offers two approaches. First, command panes: open a pane that runs one command and closes itself when done — for example zellij run to run a task in a new pane without leaving the session. Second, the 0.44 CLI automation with blocking flags for CI-style task sequences:

zellij run --block-until-exit-success -- npm run test
zellij run --block-until-exit-success -- npm run build

With this pattern, a script only continues to the next task if the previous one succeeded. If it fails, the script stops and the pane stays open for inspection. This turns Zellij from a mere place to put processes into a real task orchestrator.

When you run many projects in a day, combine all three elements — lazygit, the task runner, and a per-project layout — into one layout that opens with a single zellij -l project-name command. That way, the workspace structure doesn't need to be built manually every morning: editor, lazygit, task runner, and logs are already arranged in their places. This is the essence of "workspace as code" you'll carry into episode 27.

It's also important to understand when to use a command pane versus a regular pane. A command pane (zellij run) runs one command and closes itself when done — suitable for one-shot tasks like tests, builds, or lint. A regular pane suits continuously running processes like dev servers or log watchers. Distinguishing the two keeps your workspace tidier: panes that can close themselves don't pile up.

#fzf & Session Manager for Fast Switching

The more sessions you create — one per project, as recommended in episode 18 — the more important it becomes to switch sessions quickly. Two tools that work together: fzf for fuzzy search from the shell, and the session-manager plugin for visual management from inside Zellij.

For fzf-based switching, create a shell function that lists sessions, filters with fzf, then attaches. The same function works in all shells, only the binding differs:

zellij_sessionizer() {
  local selected
  selected=$(zellij list-sessions 2>/dev/null | fzf --height 40% --reverse --prompt="session> ")
  if [[ -n "$selected" ]]; then
    zellij attach "$selected"
  fi
}
bindkey '^[s' zellij_sessionizer

zellij_sessionizer() {
  local selected
  selected=$(zellij list-sessions 2>/dev/null | fzf --height 40% --reverse --prompt="session> ")
  if [[ -n "$selected" ]]; then
    zellij attach "$selected"
  fi
}
bind -x '"\es": zellij_sessionizer'

bindkey '^[s' binds the function to Alt+s in zsh; the bind -x '"\es": ...' line does the same in bash. Choose a key that doesn't collide with Zellij modes — Alt+s is safe because it isn't used by default. Now, from wherever you are, one keystroke opens a filterable session list, and a selection takes you straight to that session.

From inside Zellij, the session-manager plugin is the primary choice. Press Ctrl+o then w to open the latest session-management screen (0.44), showing create, attach, and resurrect in one view with fuzzy finding. Combine the two: fzf for moving quickly between sessions from the shell, the session-manager for more complete operations like renaming, disconnecting other clients, or resurrecting old sessions.

Another variation of the fzf pattern is switching projects rather than sessions: list project directories, pick with fzf, then open a new Zellij session in that directory with a consistent name. This script closely resembles the sessionizer popular in the tmux community, and works just as well in Zellij. With these two switchers — fzf from the shell and the session-manager from inside — there's no reason to open a new terminal when you want to switch working context.

#AI Coding Assistant & a Keyboard-Only Daily Driver

AI coding assistants are now an important part of the developer ecosystem — and Zellij is an excellent home for them. A comfortable pattern is running the assistant in one pane (for example codex, Claude Code, or aider), the editor in another pane, and a plain terminal in a third. You ask the assistant a question, read its answer, then move the result into the editor — all with Alt+h/j/k/l navigation.

Zellij 0.44 added desktop notification support via OSC 99, so an assistant that finishes answering can send a notification to your system — you don't have to keep staring at that pane. Version 0.44.3 also fixed scrollback compatibility with codex. This is a small example of Zellij's commitment to being a comfortable home for terminal-based AI tooling.

The key to a keyboard-only daily driver isn't a single feature, but pattern consistency:

• Alt+h/j/k/l to move between panes — one pattern for every application.
• Ctrl+p then n for a new pane, Ctrl+t then n for a new tab.
• Ctrl+s to scroll and search output.
• Ctrl+o then w to switch sessions.

If you master the patterns above, you already have 90 percent of your daily navigation needs — whichever editor you use.

#Common Pitfalls

1. Neovim clipboard out of sync. Yank and paste don't carry over to other applications. Fix: make sure the terminal supports OSC 52 and set vim.opt.clipboard = "unnamedplus" in Neovim.
2. Using Scroll mode inside an editor. Scrolling Zellij's buffer while the cursor is inside Neovim or lazygit feels wrong because the application has its own scrollback. Fix: scroll with the application's shortcuts, keep Zellij's Scroll mode for pure shells.
3. Nerd Font not set in the VS Code terminal. Zellij's tab-bar displays as boxes. Fix: set terminal.integrated.fontFamily to a Nerd Font.
4. fzf keys colliding with Zellij modes. Binding the switcher to a key Zellij uses (for example Ctrl+p) will disturb pane mode. Fix: choose a free key like Alt+s.
5. Task runner without blocking flags. The script "just moves on" even if tests fail, because the pane doesn't block execution. Fix: use --block-until-exit-success and similar flags for sequential task runs.

#Closing

Episode 26 filled in the connection points between Zellij and the developer ecosystem: Neovim with OSC 52 clipboard and Alt+h/j/k/l navigation, VS Code with its built-in terminal and Nerd Font, lazygit living in a dedicated pane, CI-style task runners with blocking panes, fzf and the session-manager for fast session switching, and AI coding assistants that are comfortable to run inside a Zellij workspace. All those patterns revolve around one philosophy: a single consistent set of shortcuts across all applications.

The points to take away:

• Neovim and VS Code both work seamlessly with Zellij, as long as clipboard and fonts are set up correctly.
• lazygit is most productive in a dedicated pane next to the editor pane.
• zellij run --block-until-exit-success turns Zellij into a task orchestrator.
• fzf (from the shell) and the session-manager (from inside Zellij) close the session-switching gap.
• A keyboard-only daily driver can be built from just a few consistent patterns.

In episode 27 next, we level up: preparing a production-ready Zellij setup — storing configuration, layouts, themes, and plugins in a dotfiles repo, building an automatic install script, handling Linux, macOS, and Windows differences, ensuring automatic session persistence, and standardizing team workflows. See you in episode 27!