❌

Normal view

There are new articles available, click to refresh the page.
Before yesterdayMain stream

Ziggity is a Helpful Tool for Power Users Who Still Use Git Manually

By: Sreenath
15 November 2026 at 11:31
Ziggity git client

In the age when people are not even looking at the code generated by AI, I am reviewing a terminal-based client that gives full visibility and control over your git repositories. Because not everyone has handed over all the critical thinking to AI, I presume.

Over the years, many Git clients, both GUI and TUI, have emerged to make working with repositories easier. Tools like lazygit have become popular among terminal users, and Ziggity is another addition to the world of terminal-based Git interfaces.

What Makes Ziggity Special?

Let me show you some of the main features of Ziggity.

Ziggity Is Small and Quick to Launch

One of Ziggity's main selling points is its lightweight design. It compiles into a single static binary, and the footprint stays small by design rather than by tuning.

The project also leans entirely on the Git installation already on your system instead of bundling something like libgit2, which keeps the binary itself down to a couple of megabytes. The project's own benchmarks, run on a Mac against lazygit, put Ziggity's process startup at a few milliseconds against tens of milliseconds for lazygit, with a noticeably smaller resident memory footprint once things settle.

Of course, benchmark numbers will vary depending on your hardware, your repository size, and the machine's other workload at the time.

Git Operations Don't Get in Your Way

Speed at launch is one thing, but a responsive interface while you actually work matters just as much.

Ziggity handles potentially slow operations such as fetching, pulling and pushing away from the main interface. This means you can continue browsing your repository, checking diffs, or reviewing commits while the operation runs quietly in the background.

A spinner in the Status panel is the only indication that something is happening, and a short one-line summary appears once the task wraps up. If it fails, that's when you actually get interrupted with a dialog.

The same philosophy carries over to longer, multi-step operations such as merges, rebases, autosquash, bisect sessions, and applying patches. Rather than dropping you back into a raw terminal and asking you to press a key to "return" to the app, something anyone who has used git clients will recognize, Ziggity simply keeps its interface up the whole time.

Even authentication is handled without leaving the app. If a push over HTTPS needs a username and token, Ziggity opens an in-app prompt, masks the token as you type, and retries the operation once you're done. There's no dropping to an external credential helper, and if a saved keychain is configured, it's reused automatically the next time around.

First-Class Mouse Support

Terminal applications are usually associated with keyboard-only workflows, and Ziggity absolutely supports that. But if you are more comfortable with mouse, you can very well use it.

You can click on any panel to focus it, click a row to select it, and use the scroll wheel across lists, diffs, dialogs, and even the commit graph. In the staging view, you can click directly on a line and stage just that line with a keypress.

Ziggity also supports proper text selection. Click and drag over a diff, a commit, or any other panel, and the selected text lands straight on your clipboard, with color codes stripped out and indentation preserved. This even works over SSH, since it relies on the OSC 52 clipboard mechanism rather than anything terminal-local.

A Better Way to Look at Git Diffs

Diffs are where you spend a good chunk of your time reviewing changes, so a clear way to read them matters.

Ziggity supports comparing branches and commits with a single keystroke.

The diff view also does word-level highlighting. Instead of painting an entire changed line red or green, Ziggity picks out the specific words that changed within a line, so a one-character edit in a long line doesn't get buried.

For long lines, think Markdown or documentation files, you can toggle soft wrapping on demand instead of having to scroll horizontally. The word-level highlighting keeps working correctly even once a line wraps across rows.

History Navigation That Understands What You Want

The commit graph is a real rendering of git log --graph, in git's own colors, and it loads without freezing the interface. By default it shows your current branch and its upstream so you immediately see what's incoming, and there's a shortcut to widen it to every branch or jump straight back to HEAD.

There's also a dedicated Divergence view that separates your outgoing commits from incoming ones relative to upstream, and history-editing actions are deliberately disabled there so you can't accidentally try to rewrite commits you haven't even pulled yet. Commit hashes are color-coded by push state, so commits that haven't left your machine, and are therefore safe to rewrite, stand out at a glance.

A More Flexible Way to Stage Changes

Staging changes is a routine part of the Git workflow, and Ziggity gives you a few ways to handle it without overcomplicating things.

You can work directly from the staging view and use the mouse to select individual lines before staging them, which gives you finer control when a file contains several unrelated changes that shouldn't land in the same commit.

It's a small feature, but a genuinely useful one if you care about keeping commits focused rather than staging an entire file at once.

Checkout by Name, Without the Detached HEAD Surprise

Press the checkout shortcut, start typing any ref, and pick from live suggestions.

If you type the name of a remote branch, Ziggity checks it out with tracking set up automatically, landing you on a proper local branch rather than a detached HEAD. Existing local branches switch normally, and tags or commits detach, because that's the only thing that makes sense for them.

This is a small but real usability improvement over some other terminal Git clients, where typing a remote branch name in the checkout prompt can leave you in a detached state with no local branch created.

Writing Commit Messages Gets Some Extra Help

Ziggity puts real thought into the commit message experience. Its built-in editor nudges you toward the 50/72 commit message convention with live, configurable limits, and it supports prepare-commit-msg hooks including hooks that derive a ticket number from your branch name.

There's also optional AI-assisted commit message generation from your staged changes. Rather than locking you into one provider, Ziggity calls out to a configurable external command, so you can point it at whatever model or subscription you already use.

Installing Ziggity

Ziggity is easily installable via Homebrew. If you have Homebrew set up on your system, use the command below to install it:

brew install simoarpe/ziggity/ziggity

Other than that, Ziggity offers prebuilt binaries for several architectures. You can download the appropriate binary from the official GitHub releases page.

Extract and copy the binary to a folder that is in your PATH. You can then run Ziggity from the terminal using the command:

ziggity

Wrapping Up

Terminal-based Git clients are not new, and there are already some excellent options available for those who prefer managing repositories without leaving the command line.

Ziggity enters this space with a focus on staying lightweight, staying out of your way during slow operations, and getting small usability details like checkout behavior and force pushes right.

The project is still a relatively new addition to the TUI Git client space, but it already offers a solid set of features. Whether it can replace an established tool like lazygit will ultimately depend on your workflow and the features you rely on.

Have you tried Ziggity yet? Or do you already have a favorite Git client for the terminal? Let us know your thoughts in the comments.

Terminal Text Editor: Like VS Code But in Linux Terminal

By: Sreenath
22 October 2026 at 08:07
Terminal Text Editor

I spend a lot of time in the terminal. Whether it is writing scripts, editing configuration files, or managing remote servers, the terminal remains the place where I get most of my work done. But when a project becomes slightly complex, I often find myself reaching for the comfort of a graphical code editor like Zed.

I'll be honest, while I can appreciate why people love tools like Vim and Neovim, learning a modal editor has always felt like more of a commitment than I was willing to make.

My editing needs are fairly straightforward, and spending hours memorizing keybindings, configuring plugins, and building a workflow from scratch never felt like a worthwhile investment for me.

That's why TTT caught my attention. The project describes itself as a real alternative to VS Code, Zed, and Sublime Text that runs entirely inside the terminal.

βœ‹
Like most of the new open source software, TTT is also developed with the help of AI assistants.

Installing TTT

On Linux, to install TTT, you can use the official installer script. That's fashion these days. No package, just an installer script curled right into your system.

curl -sSfL https://raw.githubusercontent.com/eugenioenko/ttt/main/install.sh | sh

This will install the binary in ~/.local/bin. To run it, open your favorite terminal and use the command:

ttt

There are also prebuilt binaries available to download so that you can place it in a folder of your choice and use it in portable mode.

TTT features I liked

Instead of trying to emulate traditional terminal editors, it aims to provide a modern, GUI-like editing experience in the terminal application with virtually no configuration required.

Sure, not all of these features might be unique, but they are good to have in an editor.

Syntax Highlighting

TTT uses textmate-go for syntax highlighting, a Go implementation of Microsoft's TextMate engine that powers syntax highlighting in VS Code. It claims to support more than 120 languages out of the box, giving it a surprisingly mature editing experience for a terminal-based application.

Syntax Highlighting in TTT shown using a sample C file.
Syntax Highlighting

Multi-Cursor Editing

Multi-cursor editing is one of those features I started appreciating after spending some time with Helix. It's something I now instinctively look for in any editor.

Thankfully, TTT ships with multi-cursor support out of the box, so there's no need to install plugins or configure anything before getting started.

The workflow feels familiar if you've used modern editors before, like Sublime Text.

Pressing Ctrl+D selects the next occurrence of the highlighted text, while Alt+Click lets you place additional cursors exactly where you need them.

Multi-Cursor Editing

Mouse Support

Many terminal editors advertise mouse support, but often that simply means you can click around and scroll. TTT goes much further than that.

The mouse interactions felt surprisingly close to what I'd expect from a graphical editor rather than a typical terminal application.

You can click to position the cursor, drag to select text, and right-click to access context menus.

0:00
/0:30

Mouse Support in TTT

The latter ended up being my favorite part because the menu isn't just a generic list of actions. Depending on where you click, TTT presents relevant options, making the whole experience feel far more polished and GUI-like than most terminal editors I've tried.

LSP and Auto Completion

A code editor doesn't feel complete these days without intelligent auto-completion, and TTT checks that box through Language Server Protocol (LSP) support.

Getting it up and running is fairly straightforward as you only need to install the language server for the programming language you work with.

The project also maintains a dedicated guide covering language server setup for a wide range of languages, which can save some trial and error during the initial configuration.

Once configured, you get the kind of code completion and language-aware features you'd expect from a modern editor, but without leaving the terminal.

LSP Autocompletion

Multi-folder Workspaces

Multi-folder workspaces allow you to group related folders into a single workspace and treat them as one project, much like VS Code's multi-root workspaces.

What makes this even more useful is that the workspace can be saved to a workspace.ttt file and reopened later with the exact same setup. So instead of manually opening the same collection of directories every time, you can simply load the workspace and continue where you left off.

For example, I have this customization.ttt file that has the content:

{
  "folders": [
    { "path": "/home/itsfoss/Projects/text-script-files/" },
    { "path": "/home/itsfoss/Projects/public-dot-files/" },
    { "path": "/home/itsfoss/Projects/desktop-customization" }
  ]
}

Now, I can always open this workspace by using the command:

ttt --workspace ~/Projects/customization.ttt

You don't need to manually create this file since you can add location to a workspace and later save it all via File -> Save Workspace As option.

0:00
/0:41

Multifolder Workspaces

Modern Search with Ripgrep

TTT uses ripgrep under the hood, which is already a favorite among developers thanks to its speed and ability to handle large projects without feeling sluggish.

In practice, this means you get fast, project-wide search capabilities directly inside the editor.

Combined with shortcuts like the Ctrl+K F for workspace search and Ctrl+K R for search and replace, it feels much closer to the experience you'd expect from a modern GUI editor than a typical terminal-based tool.

Search in TTT

πŸ’‘
You need to have ripgrep installed on your system.

Git Integration

TTT provides a dedicated Changes panel where you can stage, unstage, discard, commit, pull, push, and sync repositories without dropping back to the command line.

The built-in diff viewer is particularly nice to work with because it combines Git diffs with syntax highlighting, making code changes easier to read.

The Git gutter indicators and inline blame information help provide context while editing.

If you're working with multiple repositories in a workspace, TTT automatically groups changes by repository, which keeps things organized when juggling several projects at once.

0:00
/0:33

Git Integration

Integrated Terminal

You may find it funny that one of my favorite features in a terminal-based editor is... another terminal. But in practice, I found it incredibly useful.

Whenever I needed to run a command, I didn't have to open a split terminal in my terminal emulator or switch to another tab. Everything stayed inside TTT, which helps maintain focus on the task at hand.

TTT's integrated terminal is a full terminal emulator rather than a basic command prompt. It supports multiple terminal tabs, true-color rendering, scrollback, and can be toggled between panel and fullscreen modes with keyboard shortcuts.

For a project that aims to bring a GUI-like experience into the terminal, this feature fits perfectly, eliminating one more reason to leave the editor while working.

0:00
/0:41

Integrated Terminal

Plugins

TTT already comes with many of the features I normally install plugins for in other editors. But the more I explored it, the more I appreciated the approach.

TTT supports Lua-based plugins that can add commands, panels, and keybindings, allowing you to extend the editor without turning it into a configuration project.

Plugins run inside a sandboxed environment and must explicitly request permissions to approve each plugin's capabilities.

To add even more convenience, you can install plugins through a dedicated panel within the TUI.

You may read more about the plugins in their official documentation.

Plugins in TTT

Theming

TTT ships with a decent collection of built-in themes, including popular options like Dracula, Monokai, etc., making it easy to find something comfortable without downloading anything extra.

The built-in theme picker offers live previews as you browse themes, and you can customize virtually every aspect of the interface through JSON files, from syntax highlighting and diff colors to the sidebar, status bar, and even terminal colors.

Themes in TTT

Wrapping Up

After spending some time with TTT, my biggest takeaway isn't that it's a great terminal editor. It's that this thing often doesn't feel like a terminal editor at all. In many ways, it feels like a full-blown GUI application that just happens to live inside a terminal window.

Now, I don't know how many of you will actually approve of that direction. The Linux and terminal communities have long maintained a clear distinction between TUIs and GUIs, and plenty of users prefer terminal applications precisely because they don't try to mimic desktop software. TTT deliberately blurs that line. Whether that's a good thing or not will ultimately depend on what you want from a terminal editor.

I found TTT's approach refreshing. It takes many of the conveniences people expect from modern GUI editors and brings them into the terminal with surprisingly very few compromises. If that idea sounds appealing, TTT is absolutely worth a look.

By the way, TTT is not the only editor of this kind. We have covered several other terminal editors that are easy to use since they provide terminal user interfaces that can be used with a mouse. If you are not allergic to Microsoft, their open source Edit editor is also worth a look.

I welcome your comments on TTT and other terminal based text editors you prefer.

I Tried This Rust Tool, and It Immediately Made Bash Modern

By: Sreenath
5 September 2026 at 09:25
Flyline

Most Linux users benefit from GNU Readline without realizing it. It is the library responsible for Bash's interactive command-line editing, providing familiar features like cursor movement, command history, and basic tab completion.

While Readline is highly configurable, Readline's completion remains relatively simple out of the box.

I came across a new tool called Flyline that takes Bash command completion to an entirely different level. No special configuration is required.

0:00
/0:56

For anyone who has control over their shell environment, Flyline could become a must-have terminal tool.

Flyline takes a different approach entirely. Instead of layering on top of Readline, it replaces it outright. It is built in Rust and ratatui to render richer, more interactive terminal interfaces than Readline.

Exploring Flyline features

When I installed Flyline for the first time and started using it, the difference was immediately noticeable. Command suggestions appeared as I typed, making it quicker to complete commands and move through my workflow. It makes working in the terminal noticeably faster.

IntelliSense style autosuggestion

As soon as you start typing, Flyline displays a completion popup right next to the cursor with matching suggestions. This keeps the suggestions close to where you're working, making it easy to complete commands without breaking your typing flow.

0:00
/0:29

Flyline IntelliSense Suggestion

You can cycle through the available suggestions by pressing the Tab key, with the selected entry being updated on the command line in real time. If you prefer, the Up and Down arrow keys work just as well, and the completion list can also be navigated using the mouse.

For longer lists, Flyline includes a functional scrollbar that lets you quickly jump through the available suggestions. Personally, I found it faster to keep typing and narrow down the results rather than reaching for the mouse, but it's nice to have the option.

Once you've found the suggestion you want, press Enter to insert it into the command line and close the completion popup.

Fuzzy search and path completion

Traditional command completion usually expects you to type characters in the correct order. For example, typing pamc won't normally suggest pacman, since the entered characters don't match the expected sequence.

0:00
/0:29

Fuzzy Search

Flyline addresses this with fuzzy search support. Instead of requiring an exact character order, it tolerates minor typos and partial matches, making it much easier to find the command you're looking for. This means you can type a bit more naturally without worrying about getting every character in the right place.

The same fuzzy matching also works for file and directory paths. As you type, Flyline presents matching paths based on your input, allowing you to navigate deep directory structures with fewer keystrokes. I found this particularly useful when working with long or nested paths, where a small typo would normally require me to backtrack and start over.

Automatic completion synthesis (a lifesaver)

Not every command line tool ships with a completion script. Install a new CLI tool and you keep on pressing tab, and nothing happens. No suggestions appear.

When that's the case, Flyline can generate one automatically by parsing the command's --help output and available man pages.

I noticed this while trying ffmpeg, which didn't have a completion script on my system. When I typed:

ffmpeg --<Tab>

Flyline prompted me to generate a completion script for the command. After confirming, it analyzed the available documentation and created a completion definition on the fly. From that point onward, option completion for ffmpeg worked as expected.

0:00
/0:28

Synthesize Suggestions

This is also useful for commands with dozens, or even hundreds, of available options. Instead of repeatedly opening the man page or running --help to look up an argument, I could simply rely on the generated completions and discover the available options as I typed.

It makes working with feature-rich command-line tools much more convenient.

Customize the cursor (for vanity)

This isn't exactly a productivity feature, but it does make the terminal feel a bit more lively.

If you've used the Kitty terminal emulator, you might be familiar with its cursor animations. Flyline brings similar effects to virtually any terminal emulator, letting you customize how the cursor looks and behaves.

To explore the available cursor options, run:

flyline set-cursor --help

This displays the various settings you can tweak, including cursor style and animation effects.

For example, the following command adds a cursor trail that closely resembles Kitty's animated cursor, even if your terminal emulator doesn't support it natively.

flyline set-cursor \
  --backend flyline \
  --style "#33ccff" \
  --interpolate 1.5 \
  --interpolate-easing out-elastic \
  --effect fade \
  --effect-easing in-out-sine \
  --effect-speed 2.0
0:00
/0:30

Cursor Trail Emulation

A refined shell history

Flyline also gives Bash's reverse history search a much nicer interface. Instead of the traditional incremental search prompt, it presents your command history in a dedicated view where you can see each command in full, search through previous entries, and even check when a command was executed.

Refined History

Just like command completion, history search also supports fuzzy matching. This makes it easier to find an older typed command, even if you don't remember the exact sequence of characters.

What impressed me the most, though, was the Canceled Commands feature. The first time I pressed Alt+R, the list was empty. However, every command I subsequently interrupted with Ctrl+C, was automatically added there.

Cancelled Commands

Remember, it is the commands that are interrupted without executing are added to the cancelled list, and not those commands that are executed and then pressed CTRL+C.

This list is kept separate from your regular shell history, so searching your normal command history with Ctrl+R remains unaffected, while cancelled commands are available through Alt+R. The only limitation is that the list is maintained per terminal session, so it is cleared once you close or reset the terminal.

Working with AI agents

Flyline can also work with your favorite AI assistant to turn plain English into executable Bash commands. Once you've configured an AI agent, you can simply describe what you want to do in natural language, and Flyline will ask the agent to generate the corresponding command.

For example, you could type something like:

ai: list files older than three days

Pressing Alt+Enter, or simply Enter if you've configured a trigger prefix such as ai:, sends the prompt to the configured AI agent. Flyline then displays the generated command with syntax highlighting before you decide whether to run it. If the agent returns additional information in Markdown, Flyline renders that as well.

I didn't test this feature personally. I will let you try and comment your experience with it.

Prompt customization

Flyline doesn't just enhance command editing, it also offers extensive prompt customization. You can build rich prompts with dynamic widgets, animations, left and right prompts, transient prompts, live time displays, and even your own custom widgets that run shell commands in the background.

The project's documentation goes into great detail, complete with examples and screenshots for the various customization options. Rather than covering each one here, I've put together a sample configuration that combines several of these features, including a subtle animation. Simply append the following to your ~/.bashrc to give it a try.

# 1. Create the animation widgets
flyline create-prompt-widget animation \
  --name "SPINNER" \
  --fps 12 \
  '\e[38;2;137;180;250mβ ‹\e[0m' \
  '\e[38;2;137;180;250mβ ™\e[0m' \
  '\e[38;2;137;180;250mβ Ή\e[0m' \
  '\e[38;2;137;180;250mβ Έ\e[0m' \
  '\e[38;2;137;180;250mβ Ό\e[0m' \
  '\e[38;2;137;180;250mβ ΄\e[0m' \
  '\e[38;2;137;180;250mβ ¦\e[0m' \
  '\e[38;2;137;180;250mβ §\e[0m' \
  '\e[38;2;137;180;250mβ ‡\e[0m' \
  '\e[38;2;137;180;250m⠏\e[0m'

flyline create-prompt-widget animation \
  --name "PULSE" \
  --fps 6 \
  --ping-pong \
  '\e[38;2;166;227;161m●\e[0m' \
  '\e[38;2;116;199;236m●\e[0m' \
  '\e[38;2;203;166;247m●\e[0m'

# 2. Set prompt variables
PS1='\e[1;32m\u@\h\e[0m:\e[1;34m\w\e[0m\nSPINNER PULSE \e[1;35m❯\e[0m '
PS1_FILL='─'
RPS1='\e[38;2;249;226;175m\t\e[0m'
PS2='\e[2mFLYLINE_PROMPT_LINE_NUMBER β€Ί\e[0m '

# 3. Set transient history cleanup
PS1_FINAL='\e[38;2;166;227;161mβœ”\e[0m \e[1;34m\w\e[0m \e[1;30m❯\e[0m '
RPS1_FINAL=''
PS1_FILL_FINAL=''

# 4. Enable cursor trail & motion
flyline set-cursor \
  --backend flyline \
  --style "#cba6f7" \
  --interpolate 1.5 \
  --interpolate-easing out-elastic \
  --effect fade \
  --effect-easing in-out-sine \
  --effect-speed 2.0

Restart your terminal and enjoy the effects.

0:00
/0:11

Custom animated Prompt

Install Flyline

The easiest way to install Flyline is by using the official installation script. Open a terminal and run:

curl -sSfL https://github.com/HalFrgrd/flyline/releases/latest/download/install.sh | sh

The installer downloads the latest release and automatically updates your ~/.bashrc to load Flyline, so there's no need to perform any additional setup manually.

Once the installation is complete, launch the interactive tutorial with:

flyline run-tutorial

I recommend going through the tutorial before you start using Flyline. It walks you through onboarding, making it much easier to get comfortable with the enhanced editing experience.

Is there anything similar for ZSH?

When I started using Flyline, apart from its intellisense style completion, I can't say it felt like a first in a lifetime moment, because I kind of used a similar functionality in ZSH for some time.

Flyline is designed exclusively for Bash, so you can't use it with Zsh.

But, the combination of zsh-syntax-highlighting, zsh-autosuggestions, and zsh-autocomplete covers many of the features you'd expect from an IntelliSense-like command-line interface.

Together, they offer inline suggestions, syntax highlighting, and interactive command completion that make working in the terminal much more comfortable.

ZSH Autosuggestion, Syntax Highlighting and Auto Complete

If you pair these plugins with a prompt framework like Starship or a Powerline-style prompt, you can build a polished and highly productive terminal environment.

Wrapping Up

Flyline is one of the new breed of terminal tools that are built in rust to be faster and provide features that either require too much config effort or not possible in classic GNU tools at all.

From intelligent command completion and fuzzy search to AI-assisted command writing and prompt customization, Flyline adds plenty of quality-of-life improvements without changing the shell you've grown accustomed to.

Give Flyline a try. It's already a capable tool, and with active development, it'll be interesting to see how it evolves in the future.

Looking Beyond Tmux and Screen: 8 Terminal Multiplexers Worth Trying

By: Sreenath
17 August 2026 at 11:10
terminal multiplexers for Linux

Whether you're a developer, system administrator, or simply someone who spends a lot of time in the terminal, juggling multiple terminal sessions can be messy and frustrating.

A terminal multiplexer helps you keep everything organized, letting you manage several sessions from a single interface while making your workflow much more efficient.

While tmux and GNU Screen are the names most Linux users are familiar with, there are many more similar terminal multiplexer tools available. As someone who like to explore new tools, I spent some time and came up with this list for you.

πŸ“‹
Many terminal emulators let you split your screen into panes, but splitting a screen isn't the same as multiplexing it. For this list, I am focusing on tools that offer real session value beyond arranging windows.

Zellij

Zellij describes itself as a terminal workspace rather than just a multiplexer, with an emphasis on delivering a polished experience from the moment you launch it.

It aims to provide sensible defaults while still leaving plenty of room for customization.

Zellij

One of the things that sets Zellij apart is its focus on usability. Built-in layouts, a plugin system, and collaborative sessions are all part of the experience, but the project's philosophy is that you shouldn't have to trade simplicity for advanced functionality.

This makes it approachable for newcomers while still offering enough flexibility for users who want to tailor their workspace.

While this is not a ranking list, Zellij is the first one on this list because I have used it on a daily basis for the past several months.

TUIOS

While most terminal multiplexers focus on helping you manage terminal sessions, TUIOS takes that idea a step further by presenting itself as a terminal window manager.

TUIOS tries to bring concepts you'd expect from a tiling window manager, such as workspaces, automatic tiling, and window management, into your existing terminal.

TUIOS

The workflow is centered around a modal interface inspired by Vim, letting you switch between managing windows and interacting with terminal applications.

Alongside features like a command palette and workspace organization, TUIOS also supports automation through tape files, making it suitable for users who want to build repeatable terminal workflows instead of just juggling multiple shells.

Wezterm

You probably know WezTerm as a feature-rich terminal emulator. But there's more to it than meets the eye.

WezTerm includes a built-in multiplexer, allowing you to create and manage persistent sessions without relying on a separate tool.

Wezterm as a Terminal Multiplexer

It integrates multiplexing directly into the terminal and supports local domains. While it lets you connect to remote domains over SSH and other tmux like features, this requires you to spend some time configuring.

Kitty + Abduco

If you're already using Kitty as your terminal emulator, you don't necessarily have to switch to a traditional multiplexer. Pairing it with abduco gives you a lightweight way to keep terminal sessions running in the background while letting Kitty handle everything on the frontend.

0:00
/0:30

Kitty with Abduco

It's a simple combination that sticks to the Unix philosophy of using small tools that do one job well.

The primary job of abduco is to detach and reattach terminal sessions, leaving the rest to your terminal emulator.

Kitty complements this nicely with features like tabs, splits, and a polished interface, giving you a workflow that feels familiar while still providing session persistence.

tmate

Rather than reinventing the multiplexer experience, tmate builds on tmux and adds secure session sharing, making it easy to collaborate, troubleshoot problems, or provide remote assistance without asking someone to install extra software.

0:00
/0:46

Tmate

The biggest addition is the ability to generate a connection string that others can use to join your session.

By default, these shared sessions are relayed through tmate's public servers, although you can host your own relay if you prefer to keep everything under your control. If you never need to share your terminal, however, plain tmux is likely the better fit.

Boo

At first glance, boo might look like just another GNU Screen alternative. In reality, it's a fairly different take on terminal multiplexing.

Built on Ghostty's terminal emulation library, boo keeps track of the actual terminal state, allowing it to recreate a session exactly as you left it, even after you've detached and reattached.

0:00
/0:46

Boo

The project also leans into automation. Besides keeping sessions alive, it includes commands that let scripts and AI agents inspect or interact with detached sessions without needing a live terminal connection.

Okena

Okena combines terminals, tabs, panes, and projects into a single interface, with a strong focus on helping you pick up exactly where you left off.

Close the application, reopen it later, and your workspace is restored much like you never left.

Okena

That persistence model is what makes Okena different. Unlike tmux or GNU Screen, it doesn't keep sessions running in the background after the application closes, nor is it designed for detached SSH workflows or remote session management.

Instead, the emphasis is on restoring your local workspace, making it feel more like a modern development environment than a server-backed multiplexer.

Seance

Seance, built with GTK4 and libadwaita, takes a desktop-first approach to terminal session management. It feel more like a modern Linux application than a traditional keyboard-driven multiplexer.

Seance. Video Credit: Seance

It offers a clean interface with configurable key bindings, workspace management, and session persistence across restarts, so you can reopen the application and continue where you left off.

However, it isn't designed around detached server sessions or remote SSH workflows. Instead, it focuses on providing a polished experience for managing terminal workspaces on your local Linux desktop.

Wrapping Up

As you can see, there's no shortage of ways to organize your terminal workflow. Some of these tools have been around for decades, while others are reimagining what a terminal workspace can look like. The thing is that there's no single "right" choice. It all comes down to how you work.

Whichever you choose, learning to use a terminal multiplexer is one of those skills that pays off over time. Once it becomes part of your workflow, your muscle memory, there is no going back to normal terminal sessions.

By the way, you might be interested in exploring various terminal emulators as well.

Exploring Kittens With Kitty Terminal Emulator

By: Sreenath
31 July 2026 at 11:16
Kitten Kitty terminal

Kitty is a popular terminal emulator that supports many modern features. Focused on power users, it offers a wide range of customization that other terminals often lack.

For example, it includes a functional image display protocol and smooth cursor animations.

I have shown Kitty tweaking in the past, and in the regards, I would like to discuss Kittens today.

Kittens are functional units that extend the features of the Kitty terminal or work as standalone programs. They have direct access to the running Kitty instance.

Kitty comes bundled with several of these kittens, written in Go, which we will explore in detail later. You even have the option to create your own custom Kittens in Python, if you find a specific need that hasn't been solved yet.

Some Cool Default Kittens

🚧
In my opinion, it is important to remember that many kittens are Kitty terminal exclusive. Before you build muscle memory around it, make sure you aren't planning to switch to a different terminal emulator anytime soon.

Themes

Let's start with the most popular tool first. If you use Kitty daily, you have likely come across this utility at some point.

Themes is a kitten that allows you to change your terminal color scheme interactively without editing any configuration files. Kitty includes a wide variety of preset themes that you can access by running a simple command:

kitten themes

Apply themes in Kitty

In the overlay window, you can easily scroll through both dark and light themes to see a live preview. Once you find one you like, just press Enter and follow the prompts to set it as your preferred theme.

πŸ’‘
Latest versions of Kitty now support automatic theme changes based on your system's dark and light mode. This is a very convenient feature if you want your terminal to stay in sync with your global OS settings.

In my opinion, this is a feature I really miss when using Ghostty. While Ghostty has a similar interface, you still have to manually edit your configuration file to apply the theme name after you pick one.

Fonts

If you have found a new font and want to set it as your terminal choice, this kitten has you covered. You can launch the interactive interface directly in your terminal using a simple command:

kitten choose-fonts

Choose Fonts

This tool allows you to perform several actions within a single interface. You can select new fonts, preview how they look, and even fine-tune specific font faces.

The utility makes it much easier to manage your typography without guessing how a font will appear in your workspace. It handles the complex parts of the setup so you can focus on finding the perfect look.

Choose files

Choose files is a comprehensive file picker designed for Kitty and other GUI applications on your system. It functions similarly to fzf but is specifically optimized for finding and managing files.

Choose Files

This tool offers several powerful features, including the ability to select multiple files at once. It intelligently respects .gitignore rules in your git directories to keep your workflow clean.

To use it, run:

kitten choose-files

You can also select non-existent files to trigger a "save file" option or choose entire directories. In my opinion, this file picker will completely change the way you interact with files in your terminal.

Quick access terminal

If you remember Yakuake in KDE, you are already familiar with the concept of a drop down terminal for quick tasks. Kitty offers similar functionality through the Quick Access Terminal Kitten.

You can launch this feature at any time using a simple command in your terminal:

kitten quick-access-terminal
0:00
/0:19

Quick Access Terminal

If you want to personalize the experience, you can customize the tool using a specific configuration file. Simply create or edit quick-access-terminal.conf inside your ~/.config/kitty/ directory to adjust its behavior.

GPU accelerated dock panel

The Panel kitten is something truly special. It creates a desktop panel for you that functions much like i3bar.

0:00
/0:13

Kitten Panel

While some might feel this is a bit overpowered for a terminal application, the panel is quite interesting for minimal use cases. It even allows you to set tools like btop as your actual desktop wallpaper.

In my opinion, this is an incredible feature for anyone who loves a unique workspace. You heard that right, and here is a great example of how it looks in action.

A diff tool

The diff kitten is an excellent tool available directly within Kitty. It offers several advanced features like side-by-side comparisons, syntax highlighting, and even image diffs or recursive directory comparisons.

To use it, you simply pass the file names as shown in the command below:

kitten diff file1 file2

Diff Files

Other interesting Kittens

I use the terminal daily for standard update tasks and editing text files. If you are deeply involved in terminal usage, there are many kittens available for very niche use cases.

For example, the Broadcast kitten allows you to type text simultaneously across multiple Kitty windows. There are also SSH related kittens designed for editing files and even a specialized SSH supported clipboard.

In my opinion, these specific tools are essential for power users who manage remote servers regularly. Feel free to experiment with these options to make your terminal life significantly more productive.

Assign keybindings/alias for quick access

All these kittens can be bound to keyboard shortcuts or aliases so you don't have to manually run the command every time. This makes your workflow much faster by giving you instant access to your favorite actions.

I will show you how I mapped the kittens in my own configuration file. It is a straightforward process that keeps everything organized and easy to access.

The most important step is to make sure your chosen keys are uniquely assigned. You want to avoid any conflicts with existing terminal options or system-wide shortcuts.

In the below code, I mapped the F1 key to get the file chooser kitten in multiple file select mode.

map f1 kitten choose-files --mode=files

Adding the following line to your shell configuration file (~/.bashrc) to add an alias to the diff tool:

alias d="kitten diff"

Now, you can run:

d file1 file2

To get the difference between them.

Another example, let's map the F2 key to get a quick access terminal:

map f2 kitten quick-access-terminal

Wrapping up

So, we have seen how kittens can improve your terminal productivity. While most of these have separate alternatives like fzf for file selection or difftastic for diffs, integrating them directly into your terminal with a clean UI is commendable.

Kitty also offers a desktop-ui kitten that lets you integrate the file picker into all your GUI apps. Since this can cause issues with some applications and is something I use rarely, it remains out of scope for this guide.

In my opinion, the seamless integration of these tools makes Kitty feel much more cohesive than a standard terminal emulator.

Did you find any of these kittens useful enough to replace your existing tools?

❌
❌