How to Set Up Tabby SSH Client with Key-Based Authentication on Linux 2025

If you're managing multiple Linux servers and tired of juggling PuTTY, OpenSSH terminal sessions, and scattered SSH keys, Tabby offers a modern alternative that combines an SSH client, terminal emulator, and connection manager in one application. This guide walks you through setting up Tabby on Linux with secure key-based SSH authentication—no passwords required.

Why Tabby Over Traditional SSH Tools?

While ssh command-line tools and PuTTY are battle-tested, Tabby brings several advantages:

• Built-in SSH connection manager with saved profiles
• Encrypted container for storing SSH keys and credentials
• Split panes and tabs for managing multiple connections simultaneously
• Visual progress detection when transferring files
• Cross-platform (Windows, macOS, Linux) with consistent UI
• Modern theming and customizable shortcuts

Unlike PuTTY, which requires separate session configurations and doesn't natively support split panes, Tabby integrates terminal emulation with SSH management in a single interface.

Prerequisites

Before starting, ensure you have:

1. An SSH key pair already generated (typically in ~/.ssh/id_rsa and ~/.ssh/id_rsa.pub)
2. Remote server access with your public key added to ~/.ssh/authorized_keys
3. Linux system (Ubuntu, Fedora, Debian, or similar)
4. Basic familiarity with terminal commands

If you don't have an SSH key pair yet, generate one:

ssh-keygen -t ed25519 -C "your-email@example.com"

Press Enter to accept the default location (~/.ssh/id_ed25519) and optionally set a passphrase.

Step 1: Install Tabby on Linux

Tabby provides native packages for major Linux distributions. Choose your method:

Ubuntu/Debian (APT)

curl -s https://packagecloud.io/install/repositories/eugeny/tabby/script.deb.sh | sudo bash
sudo apt install tabby-terminal

Fedora/RHEL/CentOS (RPM)

curl -s https://packagecloud.io/install/repositories/eugeny/tabby/script.rpm.sh | sudo bash
sudo dnf install tabby-terminal

Manual Download

Download the latest AppImage or release from Tabby GitHub Releases:

wget https://github.com/Eugeny/tabby/releases/download/v1.0.x/tabby-1.0.x-linux-x64.AppImage
chmod +x tabby-1.0.x-linux-x64.AppImage
./tabby-1.0.x-linux-x64.AppImage

Step 2: Launch Tabby and Access Settings

Once installed, launch Tabby:

tabby

The application opens with a default local terminal tab. To configure SSH:

1. Click the Settings icon (gear/cog) in the top-right corner
2. Navigate to SSH in the left sidebar
3. You'll see options for connection profiles

Step 3: Create an SSH Connection Profile

In the SSH settings panel:

1. Click Add Connection (or the "+" button)

2. Fill in the connection details:

   • Name: prod-server-01 (or your preferred label)
   • Host: 192.168.1.10 or example.com
   • Port: 22 (default)
   • User: ubuntu or root (depending on your server)
   • Authentication: Select Private Key

3. In the Private Key Path field, enter:

   ~/.ssh/id_ed25519
   

   (or ~/.ssh/id_rsa if using RSA keys)

4. If your key has a passphrase, Tabby will prompt you upon first connection

Step 4: (Optional) Use Tabby's Encrypted Container

Tabby includes an encrypted storage system for sensitive SSH data:

1. Go to Settings → Vault
2. Set a master password
3. Return to your SSH connection profile
4. Instead of storing the key path in plain text, you can reference it through the vault
5. Click Save

This adds a layer of security, especially on shared systems.

Step 5: Test Your Connection

1. Open the main terminal window
2. Click the Profiles icon (or press the connection menu)
3. Select your newly created SSH profile (e.g., "prod-server-01")
4. Tabby initiates the SSH connection
5. If using a passphrase, you'll be prompted once

You should now see your remote shell prompt.

Comparison: Tabby vs PuTTY vs OpenSSH Terminal

| Feature | Tabby | PuTTY | OpenSSH CLI | |---------|-------|-------|-------------| | SSH Key Management | Built-in profiles + vault | Sessions stored separately | Manual key path each time | | Split Panes | Yes, native | No (requires addon) | No | | GUI Connection Manager | Yes | Yes | No | | Encrypted Secret Storage | Yes (vault) | Limited | No | | File Transfer (SCP/SFTP) | Via drag-drop (Zmodem) | Via pscp utility | Via scp command | | Cross-platform | Windows/macOS/Linux | Windows/Unix | All platforms | | Resource Usage | ~150-200 MB RAM | ~20 MB RAM | ~5 MB RAM | | Theming | Extensive | Limited | None (terminal theme only) | | Learning Curve | Beginner-friendly | Beginner-friendly | Intermediate |

Best for: Tabby is ideal if you need a modern GUI with split-pane management and encrypted credential storage. PuTTY is better if RAM is critical. OpenSSH is unbeatable for scripting and headless systems.

Advanced Tips

Bulk Import SSH Config

If you have many servers in your ~/.ssh/config file, Tabby can parse it:

1. Open Settings → SSH
2. Look for Import from SSH Config option
3. Tabby auto-discovers profiles from your config file

Configure Global SSH Hotkey

Set a "Quake console" hotkey to spawn Tabby anywhere:

1. Settings → Hotkeys
2. Search for "New Window"
3. Assign a global shortcut (e.g., Ctrl+Alt+T)

Use Multiple Key Types

Tabby supports Ed25519, RSA, and ECDSA keys. You can have multiple keys and specify which to use per connection:

1. Create different profiles for different servers
2. Point each to its respective key path
3. Tabby tries keys in order; failures fall back to password auth if enabled

Troubleshooting Common Issues

"Permission denied (publickey)"

• Verify the public key is in ~/.ssh/authorized_keys on the remote server
• Check server sshd_config allows public key authentication: PubkeyAuthentication yes
• Ensure key permissions are correct: chmod 600 ~/.ssh/id_ed25519

"Connection refused"

• Confirm SSH port (default 22) is not blocked by firewall
• Test with: ssh -vvv user@host to see detailed error logs

Passphrase prompt every time

• Add your key to ssh-agent: ssh-add ~/.ssh/id_ed25519
• Tabby respects ssh-agent; it won't re-prompt

Wrapping Up

Tabby transforms SSH management from a command-line chore into a streamlined visual workflow. Its encrypted vault, connection profiles, and split-pane terminal make it a solid alternative to PuTTY and scattered SSH sessions. For DevOps engineers managing multiple servers, the efficiency gains justify the small RAM footprint overhead.

Start with a single connection profile, test file transfers via Zmodem, then expand to your full server inventory.