DEV Community: Aram Drevekenin

Zellij 0.43 brings the terminal to your browser

Aram Drevekenin — Tue, 05 Aug 2025 08:55:08 +0000

Your browser does not support the video tag.

Zellij 0.43.0 has just been released! Check it out!

Some highlights:

Web Client
Multiple Select
Key Tooltips
Stack Pane Keybinding
New Rust Plugin APIs
Performance Improvements
Please Support the Zellij Developer ❤️

Web Client

Zellij was never meant to live exclusively in your terminal, and this release brings it to the browser. With a keypress, you can now share existing sessions to the browser with Zellij's multiplayer capabilities: each client getting their own cursor.

No more "can you share your screen?", no more ssh key exchange and NAT traversal dances. Just simple, secure sessions in your browser.

Use for remote access, teaching, demos, collaborative debugging or even as your daily driver - making a dedicated terminal emulator optional.

Check out the new web-client screencast if you'd like to learn more.

Bookmarkable Sessions

Each session gets its own unique URL (eg. https://127.0.0.1/my-session-name)

Hit that URL while the session is running and you attach to it directly.
Hit it after the session has exited and Zellij resurrects it with the same layout and commands.
Enter a new URL and a session by that name is created.

Bookmark your favorite sessions and you will always be able to come back to them - locally, from a different trusted machine or even from your phone.

Built-In Security Measures

Your terminal is a vulnerable and private interface. Access to it must be carefully guarded and protected.

For this reason, Zellij requires any user be authenticated with a special token before they can log in from the browser. These tokens can be generated and revoked, but are kept hashed in a local database, so can never be displayed again. They are never saved in your browser or written to any storage.

In addition, Zellij enforces the use of HTTPS with a user-provided certificate if listening on a public interface (anything that is not localhost/127.0.0.1).

These security measures cannot be disabled.

Don't like this feature?

No problem. Zellij now also offers a zellij-no-web release without the web client or any of its dependencies.

Multiple Select

This release adds the ability to perform bulk operations on several panes at once. Mark several panes either with the mouse or with a keyboard shortcut, then:

Turn them into a stack
Break them out to a new or existing tab
Make them all floating/embedded
Close them all

To mark panes: Alt p while focused on the pane (or Alt <left-mouse-click> on any pane) and then follow the on-screen instructions.

Key Tooltips

A much requested feature has been to be able to temporarily see the keybinding hints without having them constantly take up valuable screen space. This release includes the ability to add temporary tooltips for use with the existing compact-bar. These tooltips can either be toggled or only displayed as needed when performing operations outside of the base mode.

To use in the zellij config:

// compact-bar location="zellij:compact-bar" { <== comment out this line
compact-bar location="zellij:compact-bar" { // replace it with these lines
    tooltip "F1" // choose a keybinding to toggle the hints
}
default_layout "compact" // make sure this is set so you'll get the compact-bar instead of the default UI

Stack Pane Keybinding

Zellij has included stacked panes for a while, but this release adds the ability to explicitly create a stacked pane inside the currently focused pane - making this feature more accessible.

By default: Ctrl p + s (or Ctrl g + p + s for "unlock-first").

New Rust Plugin APIs

Since many of these new features are implemented as built-in plugins, this also adds lots of interesting APIs for Rust plugins.

GroupAndUngroupPanes(Vec<PaneId>, Vec<PaneId>, bool), // panes to group, panes to ungroup, bool -> for all clients, - used for multiple select
HighlightAndUnhighlightPanes(Vec<PaneId>, Vec<PaneId>), // panes to highlight, panes to unhighlight - used for mouseovers, but can be used for other things (eg. bookmarking panes)
CloseMultiplePanes(Vec<PaneId>), FloatMultiplePanes(Vec<PaneId>), EmbedMultiplePanes(Vec<PaneId>) - used for multiple select and will operate on the panes that have been grouped, either by the API or by the user
Web client operations:
- StartWebServer
- StopWebServer
- ShareCurrentSession
- StopSharingCurrentSession
- QueryWebServerStatus
- GenerateWebLoginToken(Option<String>) // String -> optional token id
- RevokeWebLoginToken(String) // String -> token id (provided or generated)
- ListWebLoginTokens
- RevokeAllWebLoginTokens
- RenameWebLoginToken(String, String), // (original token id, new token id)
InterceptKeyPresses - temporarily intercept all user keypresses (excluding actions), not just ones sent to the plugin directly
ClearKeyPressesIntercepts - clears the above intercept (also happens automatically on plugin close)
ReplacePaneWithExistingPane(PaneId, PaneId), // (pane id to replace, pane id of existing) - useful for pane pickers

All of these APIs are behind relevant permissions, for more information see the plugin documentation.

Performance Improvements

This version includes a global debounced async rendering mechanism for both terminal text and Zellij actions such as opening new panes. This serves to reduce the number of renders and make the experience of using the app much smoother.

Please Support the Zellij Developer ❤️

Zellij is a labor of love and is provided free and open-source to anyone who wishes to use it.

Zellij will never display ads or collect your data.

To help sustain the project, please consider a recurring donation so that the developer can pay their bills: https://github.com/sponsors/imsnif

Why we started Devsession

Aram Drevekenin — Thu, 06 Jan 2022 13:46:32 +0000

When I started developing, after a certain period of writing code alone, I was taught how to collaborate with others. I was introduced to version control tools (back then it was SVN, today it would be Git) as the point of coordination. My first impression was that someone was trying to play a trick on me.

In order to work along side my teammates I would need to:

Work on my feature alone until I'm done
Try to push my changes to the joint code base
Have Git tell me what it understands are the contradictions I need to fix
Fix those contradictions, and hope there aren't any more non-textual contradicting assumptions that the tool couldn't catch

This just seemed so needlessly complex to me.

We waste so much time on merge conflicts, and on fixing bugs that happen because Alice zero indexed the IDs while Bob one indexed them.

Development is team work, but as individual developers, our teammates' work is often a point of friction rather than a welcome additional pair of hands.

What if things could be different?

This is where Devsession comes in. We're building an IDE synchronizer that would allow you to have a Google-docs-like collaborative experience in your own IDE, and see your teammates type in real time.

Plug in a url (for example: https://my.devsession.is/alices-session) into your IDE, terminal or browser and you're in the session.

Join a dev session from your own IDE

With Devsession, the code is shared between all members of the team, but each one still works in their own environment.
Devsession will also include a built in set of feature flags, allowing developers to switch each other's changes on and off if they want to temporarily work alone without having to diverge the code itself.

The feature flags are logical rather than textual. This means that instead of having a language specific feature flag such as if (my_feature_flag_name == true) inside the code, Devsession will be able to manage which parts of the code should appear in your editor depending on which flags you switched on.

In addition, Devsession will include a built in modern messaging system. Meaning that if you don't want to be interrupted in your flow, you could also set yourself as "Do not disturb", and then your teammates can always switch off your feature flag if they want to.

Share your terminal without sharing your cursor

Devsession will also allow you to synchronize your terminal, with each user having their own cursor rather than being made to share the cursor with others. This would allow developers to hop between the different environments of their teammates in order to be able to seamlessly pair on a joint problem in the middle of development.

This solution could also be used separately. In order to collaborate on solving a production issue or temporarily helping a friend out of a jam.

Say goodbye to meticulous coordination

Imagine you and your teammate are working on two different features, each one touching the same data structure. For example: in a social media site, both of you need to change the User model. One of you wants to add an attribute, and the other wants to change the type of a different attribute. Today, depending on our language or environment, we would often have to meticulously coordinate such tasks. Usually this would not even be enough and on the whole, we would be slowing each other down.

With Devsession, this problem goes away. We would both make our changes to the data structure and quickly fix any contradicting assumptions each developer's implementation creates.

Look through history with varying levels of granularity

How often did you try to optimize a piece of code someone else wrote only to end up with basically the same thing after a few iterations? No shame, it happens to us all.

Right now, if we need to understand a piece of code as developers, the only history we have is our git log. While certainly better than nothing, git commits tend to be of finished pieces. There is a lot of context about "why things are this way" that gets lost. We could ask the developer who wrote it... if they are still around - or if they even remember.

Wouldn't be cool if we were able to analyze a piece of code and see exactly how it was written? Kind of like going through an undo-chain in our own editor.

An upshot of Devsession is that since everyone is coding together in the same instance - the instance itself has memory. We could use it to better understand what was happening when a piece of code was created - and we could even edit it into a feed that developers could browse to find out what happened while they were on vacation.

Do you want to get rid of Git?

No, not at all! We believe Git is a great tool for version control, but that we've been misutilizing it as a collaboration tool.

We think Git should be used in tandem with Devsession, with developers deciding when to commit a larger change together as part of the code-base's evolution.

Devsession is an open source company

Devsession was started by the team behind Zellij. We intend to use Zellij as our technological infrastructure and be the first major app in a growing ecosystem around it. To that end, we intend to sponsor the development of Zellij and work to improve it and nurture others who might benefit from the infrastructure it offers.

As a free service to the Zellij community - Devsession also intends to offer terminal sharing over the web for free. Sharing that will not lock users in to only having one cursor each. But instead allow them to work separately in the same session. When we launch, we intend for terminal sharing to be as simple as sending a friend a URL: https://my.devsession.is/alices-session. They would open the URL in their browser or through Zellij and immediately start working together.

Devsession itself intends to be as open-source as possible. Pursuing revenue by providing services rather than creating intellectual property.