Learn Zellij - Latest Stable Features (0.40 - 0.44)

#Introduction

The Learn Zellij series enters its final phase. After mastering the foundations in episodes 0 through 24 — sessions, tabs, panes, the mode system, KDL configuration, layouts, pipes, the plugin system, persistence, up to multiplayer — now it's time to see how all that material is woven together by the latest releases. Episode 25 is a chronological map: the stable features born from versions 0.40 to 0.44, a span that transformed Zellij from a feature-rich multiplexer into a truly modern terminal workspace ready for daily use.

Why is this episode important? Almost every previous episode touched these features separately: pipes were covered in depth in episode 13, the filepicker and strider in episode 14, the plugin manager in episode 15, pinned floating panes and stacked resize in episode 7, the new theme spec in episode 11, the web client in episode 20, and remote sessions and CLI automation in episodes 13 and 19. In episode 25 you'll see everything on one complete timeline: what was born in which release, what real problems were solved, and how those features interconnect to form an ecosystem.

There's one interesting thread running through this timeline. Each major release turns out to answer a follow-up question from the previous release: 0.40 made interacting with the workspace more human, 0.41 made plugins easier to manage, 0.42 refined layout and theming, 0.43 brought Zellij beyond the terminal's boundaries, and 0.44 closed the loop with cross-platform support and command-line automation. By the end of the episode, you'll build one complete case study that uses all those layers at once: CLI actions, pipes, layouts, and plugins in a single automation workflow.

#Welcome Screen, New UI & Filepicker (0.40)

Release 0.40, released in April 2024, was a major turning point for user experience. Previously, running zellij landed you directly in one empty pane; since 0.40 there's a welcome screen — a friendly menu showing options for starting a new session (with a specific name or folder), attaching to a running session, or resurrecting an exited session. This welcome screen isn't just decoration: it's a session-management gateway that trains you to think of workspaces as entities that can be created, approached, and brought back to life — exactly the mental model built since episode 0.

The second feature in 0.40 is the filepicker, rewritten from scratch. The filepicker (aka Strider) lets you browse the filesystem from inside the workspace without leaving the keyboard: navigate with arrow keys, toggle hidden files with Ctrl+e, mark multiple files at once, then press Enter to open a file in your default editor or open a terminal in that folder. The fastest way to invoke it from the command line:

zellij plugin -- filepicker

What makes the 0.40 filepicker special is its integration with pipes. You can interactively select files and pipe the results to another command through a traditional shell pipe — the filepicker closes itself and prints the selected paths to stdout:

zpipe filepicker | xargs -i cp {} my-chosen-file

The same release added several features that later became standard: floating panes can be opened at specific coordinates and sizes, tabs can be moved with Alt+i and Alt+o, other clients can be disconnected from the session-manager with Ctrl+o then Ctrl+x, plugin aliases shorten long plugin URLs into easy-to-remember names, and the zellij attach --create-background flag lets sessions start in the background. There were also two significant performance improvements: line wrapping for very long lines is now much faster, and synchronized render (CSI 2026) makes full-screen applications like Neovim feel far smoother.

#Pipes & Plugin Manager (0.40 - 0.41)

Pipes are Zellij's new communication foundation, introduced in 0.40. A pipe lets messages be sent to plugins from the command line, from keybindings, or from other plugins — and a target plugin that isn't running will be loaded automatically on the first message that arrives. You already explored this concept in depth in episode 13; in this episode we highlight its place in the ecosystem. Pipes integrate with ordinary shell pipes, provide flow control, and open the door to data visualization, in-terminal notifications, and even floating panes that appear conditionally when certain conditions are met.

To send a message to a pipe, use the zellij pipe CLI or its short alias zpipe. Plugins registered as aliases, such as filepicker, can be invoked directly by name:

zellij pipe -p filepicker
zellij pipe -n monitor -p my-status-plugin "refresh"

In 0.41, the plugin ecosystem became far easier to manage through the plugin manager. From inside a session, press Ctrl+o then p to open an interface showing running plugins, available plugins, and currently loaded plugins. The plugin manager turns Zellij from "plugins hidden behind config" into "plugins visible and managed" — you can see which plugins are active, load new ones, and close unused ones, all without touching a configuration file.

#Pinned Floating Panes, New Theme Spec & Web Client (0.42 - 0.43)

Release 0.42, March 2025, refined window management with three features you already know from previous episodes. First, pinned floating panes: a floating pane can now be pinned so it always stays on top even when unfocused — perfect for showing documentation, real-time logs, or syntax previews. Pin a pane with Ctrl+p then i (TogglePanePinned). Second, stacked resize: when resizing, panes stack with their neighbors, giving more screen space while still showing other panes' titles so keyboard or mouse navigation stays fast. Third, a new theme definition spec that replaces the "color mapping" approach with a "UI component" approach.

This new theme spec deserves extra attention. Instead of only defining foreground and background colors, themes can now define the appearance of the tab-bar, status-bar, pane frames, table titles, and list items separately — and this spec extends to plugins, so custom plugins can also adapt to the active theme. If episode 11 covered theming basics with the old format, this episode asserts that the UI component format is the standard to use for all new themes.

Release 0.43, August 2025, brought Zellij out of the terminal: the web client. With the web client, you can access Zellij sessions from a browser — no client installation, from any device, just via a URL. The technical details and workflow were already covered in episode 20; what matters for this timeline is that the web client opens Zellij to an audience without Zellij installed. 0.43 also added multiple pane actions: you can select many panes at once with Alt + left-click, then close, stack, or move that group of panes in bulk — a feature no other multiplexer has. Double-click and triple-click for text selection also arrived in this release, along with a much richer new Rust plugin API.

#Remote Sessions, Windows Support & CLI Automation (0.44)

Release 0.44 is the most ambitious release in Zellij's history, with three major pillars. First, native Windows support: Zellij now runs on Windows without WSL, with full feature parity — session management, workspace automation, plugin ecosystem, and multiplayer. Windows users who previously had to rely on WSL can now enjoy Zellij natively. Second, remote sessions: you can attach to a remote Zellij session directly from the terminal over HTTPS, using the same token-based authentication mechanism as the web client:

zellij attach https://example.com/my-cool-session

This release also added read-only tokens — tokens that allow attaching without the ability to change anything, ideal for teaching, demos, screencasts, or streaming. Tokens are issued via zellij web --create-read-only-token or the share plugin with Ctrl+o then s.

Third, much more powerful CLI automation. The --blocking, --block-until-exit-success, and --block-until-exit-failure flags on zellij run let scripts wait for a command's result inside a pane before continuing to the next command — opening the door to CI-style pipelines inside the terminal. There's also zellij subscribe for streaming pane output live, zellij action list-panes --json to query session state in structured format, and zellij action list-tabs --json for tab state. On the UX side, 0.44 brings a layout-manager (Ctrl+o then l), a session manager with fuzzy find on a single screen (Ctrl+o then w), automatic dark and light theme support via theme_dark and theme_light, mouse pane resizing, and click-to-open for file paths in terminal output. To enjoy all of it, make sure you update Zellij according to your platform:

Official installer (Linux/macOS)Homebrew (macOS)Windows (native)Cargo (build from source)

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

brew upgrade zellij

winget upgrade zellij.zellij

cargo install --locked zellij

#Case Study: Building a Complete Automation Workspace

Now let's put it all together: CLI actions, pipes, layouts, and plugins in one workflow. The goal of this case study is to build a script that opens a project, sets up the workspace, runs the dev server, and opens files — all from the command line, keyboard-first, without a single mouse click.

First, a KDL layout for a simple Rust project. This layout splits the screen into an editor on the left and two stacked panes on the right for the dev server and git:

layout {
    tab name="main" focus=true {
        pane command="nvim" cwd="/home/alman/project" size=50%
        pane split_direction="vertical" {
            pane command="cargo watch -x run"
            pane command="lazygit"
        }
    }
}

Then a bootstrap script that leverages CLI automation. This script kills the old session, creates a new session with the layout above, sends a command to the editor, and moves focus:

#!/usr/bin/env bash
set -euo pipefail
 
SESSION="dev"
zellij kill-session "$SESSION" 2>/dev/null || true
 
zellij attach --create-background "$SESSION" options --default-layout dev
zellij --session "$SESSION" action write-chars ":edit src/main.rs"
zellij --session "$SESSION" action go-to-tab 1
zellij --session "$SESSION" action move-focus down
zellij attach "$SESSION"

Finally, pipes and filepicker integration for choosing a target. You can pipe the file selection to any command, for example choosing an artifact to deploy:

zpipe filepicker | xargs -i ./deploy.sh {} --env production

These three layers work together: the layout provides the initial structure, CLI actions perform the orchestration, and pipes connect interactive choices to real commands. This is the concrete form of "workspace automation" promised since the beginning of the series.

#Common Pitfalls

1. Not updating the plugins block after an upgrade. The welcome screen and filepicker don't appear because the old plugin aliases aren't registered in the config. Fix: align your plugins block with zellij setup --dump-config.
2. Using the old theme spec. Palette-style themes still work, but can't leverage the new UI components of the 0.42 spec. For modern themes, use the UI component format so the tab-bar, status-bar, and pane frames follow along.
3. Remote attach without a web server and a shared session. zellij attach https://... requires a running Zellij web server and a shared session. Make sure both conditions are met before blaming the connection.
4. Automation scripts without --session. Running zellij action from outside a session without naming the session means the command lands in the wrong place — or has no effect at all.
5. Assuming 0.40 is the same as 0.44. Features like the layout-manager, dark/light themes, native Windows support, and CLI automation only exist in 0.44. Before following the latest tutorials, always check zellij --version.

#Closing

Episode 25 summarized the journey of releases 0.40 to 0.44: the welcome screen and filepicker that made workspace interaction more human, pipes that let plugins talk to each other, the plugin manager that tamed the plugin ecosystem, pinned floating panes and the new theme spec that refined layouts, the web client that brought Zellij to the browser, and remote sessions, Windows support, and CLI automation that closed the loop. The case study at the end of the episode showed how all those layers work together in one real automation workflow.

The points to take away:

• 0.40 introduced the welcome screen, filepicker, pipes, and plugin aliases.
• 0.41 added the plugin manager for managing plugins visually.
• 0.42 brought pinned floating panes, stacked resize, and a new theme spec.
• 0.43 brought the web client and multiple pane actions.
• 0.44 added native Windows support, remote sessions, and CLI automation.

In episode 26 next, we step out of internal features and look at how Zellij gets along with the developer ecosystem: seamless integration with Neovim and VS Code, lazygit inside a pane, task runners, fzf for session switching, the session-manager plugin, up to AI coding assistants — all woven into a keyboard-only daily driver. See you in episode 26!