** Tabby: The Terminal Emulator That Also Replaces Your SSH Client

If you spend any time in a terminal, you know the friction of juggling different tools. You might use iTerm2 for local work, a native SSH client for remote servers, and a separate app like PuTTY for serial connections. It works, but it’s messy.

Tabby is a modern terminal emulator that aims to simplify this. It doesn’t just render a shell. It’s built from the ground up to be a single workspace for local terminals, SSH sessions, and serial connections—all in one tabbed window. Think of it as VS Code for your command line, but focused purely on connectivity and terminal rendering.

What It Does

Tabby is a cross-platform terminal emulator (Windows, macOS, Linux) written in TypeScript using Electron. At its core, it’s a fast, GPU-accelerated terminal. But the real power is in its built-in integrations.

It ships with native support for:

• Local terminals (PowerShell, Bash, Zsh, etc.).
• SSH connections with full profile management, key handling, and agent forwarding.
• Serial port connections (great for embedded work or talking to routers).
• Telnet and local shells for legacy systems.

You can configure all these sources as profiles. Switching between editing a file locally, running kubectl against a production cluster, and debugging a hardware sensor over serial is just a Ctrl+Tab away.

Why It’s Cool

The first thing you’ll notice is the modern UI. But it’s not just skin deep. Here’s what makes Tabby stand out.

First, the SSH client is excellent. It remembers your sessions, shows connection status directly in the tab bar, and it handles timeouts gracefully. You get a proper reconnection prompt instead of a frozen terminal. It also supports ProxyCommand and jump hosts natively.

Second, it’s extensible via plugins. There’s a built-in plugin manager. You can add features like clickable URLs, colored brackets, a quick command palette (think VS Code’s Ctrl+Shift+P), and even SSH profiles that sync via Dropbox or a custom URL.

Third, the serial terminal support is seamless. For tools like screen or minicom, you often need to set baud rates and flow control manually. In Tabby, you save a profile for your Arduino or network switch, and it reconnects automatically when you plug it in.

Finally, performance is solid. Thanks to GPU acceleration, it handles heavy output (like tailing logs) without stuttering. It’s not as lightweight as Alacritty for pure raw speed, but for daily workflow use, it’s snappy enough.

How to Try It

Getting started is simple.

1. Head to the releases page on GitHub and download the installer for your OS.
2. Install it normally (on macOS via .dmg, Windows via .exe, Linux via AppImage or package managers like winget or brew).
3. Open Tabby. On first launch, it will ask if you want to import settings from your current terminal (handy for Windows Terminal users).
4. Click the “+” button in the tab bar. You’ll see options for “Local”, “SSH”, “Serial”, and more.
5. Create a new SSH profile with your server’s IP, user, and key path. Connect once. Your session will be saved for next time.

For serial connections, click “Serial”, set your port (like /dev/ttyUSB0 or COM3), and set the baud rate (e.g., 115200). Hit connect.

Final Thoughts

Tabby isn’t perfect. As an Electron app, it uses a bit more memory than a minimal terminal emulator (expect around 150–200MB idle). And if you only ever run a local shell, it might feel like overkill.

But if you live in the space between local development, remote servers, and hardware, Tabby is a massive quality-of-life improvement. It removes the mental overhead of switching apps. You just open Tabby, and everything is there—local, remote, serial—in one window.

Give it a spin for a weekend. The big win is not speed, but flow. And that’s harder to quantify until you try it.

Found this useful? Follow @githubprojects for more dev tool highlights.