# Tabby: a configurable terminal, SSH and serial client for Windows, macOS and Linux

> Tabby (formerly Terminus) bundles a terminal emulator, an SSH connection manager and a serial console into one Electron app. It is a strong fit if you juggle saved remote hosts and serial devices, and the wrong fit if you care about RAM.

**Eugeny/tabby** — Tabby is a cross-platform terminal with SSH connections, serial support, profiles, themes, and configurable shortcuts.

- Repository: https://github.com/Eugeny/tabby
- Website: https://tabby.sh
- Stars: 74,679 · Forks: 4,266
- Language: TypeScript
- License: MIT
- Published: 2026-08-04 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/eugeny-tabby

## The problem Tabby solves: too many remote endpoints, too many windows

The README frames Tabby as an alternative to Windows' standard terminal (conhost), PowerShell ISE, PuTTY, macOS Terminal.app and iTerm. That list is the point. PuTTY is a connection manager with a dated terminal; iTerm is a good terminal with no built-in serial support; conhost is neither. Tabby puts an SSH2 client, a connection manager, a Telnet client and a serial terminal inside the same application as the emulator, so a saved host and a serial device sit in the same sidebar as a local shell.

The audience is narrow but real: people who maintain a list of remote machines, who hop through jump hosts, and who occasionally plug into a console cable. The README also lists X11 and port forwarding, automatic jump host management, and agent forwarding including Pageant and the Windows native OpenSSH Agent. Those are features you normally assemble from a terminal plus a separate SSH config plus a key agent plus a serial tool.

What it is not matters just as much. The README says plainly that Tabby is not a new shell, is not a MinGW or Cygwin replacement, and "isn't lightweight". It directs anyone who cares about RAM to Conemu or Alacritty. That is an unusually direct self-assessment, and it should be taken at face value: this is an Electron application, and the repository layout confirms it, with tabby-electron and electron-builder.yml at the top level.

## How Tabby is put together: plugins over an Electron core

The top-level repository entries read like a module list rather than a single app: tabby-core, tabby-terminal, tabby-local, tabby-ssh, tabby-serial, tabby-telnet, tabby-settings, tabby-electron, tabby-web, tabby-web-demo, tabby-plugin-manager, tabby-linkifier and tabby-uac. Each concern lives in its own package, and the application composes them. That is why a plugin can add a Docker connection type or an SFTP tab without patching the emulator.

The stack is TypeScript on Angular (the devDependencies pin @angular/* at ^15) rendered inside Electron 43, with webpack driving the build. Two consequences follow. First, the same core supports the desktop app and the web app: the README states that the SSH, SFTP and Telnet client is available as a web app at tabby.sh/app, and that it can be self-hosted via the tabby-web repository. Second, the plugin surface is genuinely open, because plugins are separate packages loaded by tabby-plugin-manager and installed from the Settings view rather than from a marketplace URL.

Secrets get their own treatment. The README describes an "integrated encrypted container for SSH secrets and configuration", which is the mechanism behind saved passwords and keys. The README does not document the container's format, where the file lives, or how to migrate it between machines, so treat backup and portability as something to confirm yourself before you depend on it.

## Installing Tabby and opening your first SSH session

The README points to three download routes: the latest release on GitHub, Debian/Ubuntu and RPM repositories hosted on packagecloud, and a nightly build. Start with the release page or the package repository; the nightly link is for testing builds from master, not for a workstation you rely on.

On a Debian or Ubuntu machine, the README links the packagecloud install script for the Debian repository. The exact script body is not reproduced in the README, so fetch it from the install page it links rather than copying a command from elsewhere:

```bash
# Follow the instructions on https://packagecloud.io/eugeny/tabby/install#bash-deb
# The README links this page for the Debian/Ubuntu repository setup.
```

On Windows, the portable mode is a single documented trick. Create a folder named data next to the executable and Tabby keeps its state there instead of in the user profile:

```bash
# Place a directory named 'data' in the same location as Tabby.exe
# The README states Tabby will then run as a portable app on Windows.
```

Once it is running, the first real use is a saved SSH profile. Open Settings, find the SSH section, and add a connection with host, port and credentials. The README lists login scripts and automatic jump host management as part of that client, so a host that needs a bastion can be expressed in the same profile rather than in a wrapper script. For a serial device, the serial terminal section documents saved connections, readline input, optional hex byte-by-byte input and hexdump output, newline conversion, and automatic reconnection. Plugins and themes are installed from the Settings view inside Tabby, which is also where you would add something like tabby-docker or sftp-tab.

## Where Tabby gets in the way

Memory is the documented trade-off. The README states that Tabby "isn't lightweight" and redirects users who care about RAM to Conemu or Alacritty. An Electron application carries a browser runtime; Alacritty is a GPU-accelerated terminal with no bundled connection manager. You are trading footprint for integration, and that trade is deliberate.

The second limitation is packaging drift. Releases are tagged frequently (v1.0.235 on 2026-07-22, v1.0.234 on 2026-05-17, v1.0.233 on 2026-05-07), but a distribution repository can lag behind the GitHub release. The README offers both routes without saying which is authoritative for a given platform, so if a fix matters to you, check the version after installing rather than assuming the repository has it.

Third, the web client is a different deployment with different exposure. The README says the SSH, SFTP and Telnet client is available as a web app and can be self-hosted from the tabby-web repository. Running that means you are now hosting a service that terminates SSH connections, and the README does not discuss hardening, authentication or network placement for it. If you only need a local terminal, the desktop app is the smaller surface.

Finally, the plugin list is community-maintained and uneven. Some entries are full connection providers such as tabby-docker; others are cosmetic or experimental, and the README itself includes a deliberately pointless example plugin. Installing from Settings is convenient, and it also means the quality bar varies by plugin author.

## Tabby against Alacritty and Conemu

The README names its own alternatives, which makes the comparison concrete. Alacritty is a GPU-accelerated terminal emulator with no built-in SSH connection manager, no serial terminal and no plugin settings pane. If your workflow is a local shell plus an ssh config file plus tmux, Alacritty gives you a faster, smaller window and nothing else. Tabby gives you the connection manager, the serial console and the plugin system in exchange for the Electron runtime.

Conemu is the other reference point, and it is Windows-only. Tabby ships for Windows, macOS and Linux, so the moment your work spans a Mac laptop and a Linux server, Conemu is out of scope. Tabby's Windows-specific features are still notable: the README lists PowerShell and PS Core, WSL, Git-Bash, Cygwin, MSYS2, Cmder and CMD support, plus proper tab completion on Windows via Clink. That is a broader Windows shell matrix than most cross-platform terminals attempt.

A fourth option worth naming is the plain combination of iTerm or Terminal.app with the OpenSSH client. It costs nothing and needs no plugin trust decisions, but you lose the saved-connection UI, the serial terminal and split panes tied to profiles. Tabby's value is proportional to how many endpoints you keep.

## Maintenance, licence and upgrade cost

The repository is not archived and the last push was on 2026-07-22, which is the same day as the v1.0.235 release. Release cadence over the visible window is uneven: roughly two and a half months between v1.0.233 and v1.0.234, then two months to v1.0.235. That is a steady trickle rather than a fast-moving project, and it is consistent with a mature application whose core packages are stable.

The licence is MIT, which is permissive: you can use, modify and redistribute it, including in commercial settings, provided the copyright notice and permission notice are preserved. That applies to the code in this repository. It does not automatically cover third-party plugins, themes or the web client, each of which lives in its own repository with its own licence file, and the README does not state what those are. If you plan to redistribute a build with plugins bundled, read each plugin's licence. Nothing here is legal advice.

Upgrade cost is mostly the Electron and Angular churn visible in package.json, which matters if you build from source rather than install a package. The devDependencies pin @angular/* at ^15 and electron at 43. Anyone maintaining a fork or a custom plugin inherits that toolchain, and the plugin API surface is defined by the tabby-core and tabby-terminal packages. For end users installing a release, the upgrade is a package update; the README does not document a config migration step between versions, and it does not document rollback.

## Conclusion

Adopt Tabby if you keep many saved SSH hosts, jump hosts and serial devices and want them in one window with split panes and a connection manager. Skip it if memory footprint is your first constraint; the README itself points to Conemu or Alacritty instead. Before committing, verify the two things the repository does not spell out: whether your platform's package is current with the latest release, and whether the SSH secret container's storage meets your own key-handling rules.

## FAQ

### How do I install Tabby?

The README lists three routes: the latest release on GitHub, Debian/Ubuntu and RPM repositories on packagecloud, and a nightly build from master. Use the release or the package repository for a machine you depend on.

### How do I use Tabby for the first time?

Open Settings, add an SSH connection with host and credentials, and the connection manager keeps it for later. Serial connections work the same way from the serial terminal section, and plugins and themes install from the Settings view inside Tabby.

### How do I use Tabby?

Tabby combines a terminal emulator with an SSH, Telnet and serial client. The README describes split panes, saved tabs, configurable shortcuts and an encrypted container for SSH secrets, all reachable from the same application window.

## Sources

- [Official documentation](https://tabby.sh)
- [Official README](https://github.com/Eugeny/tabby#readme)
- [Project repository](https://github.com/Eugeny/tabby)
- [Release notes](https://github.com/Eugeny/tabby/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/eugeny-tabby
