tmux: The Swiss Army Knife for Remote Session Persistence and Terminal Multiplexing
Ever SSH'd into a server to run a long task, only to have the process die when your network flakes? tmux solves exactly this problem. It lets you run multiple programs in a single terminal window, keeps them running in the background when you disconnect, and lets you reattach anytime.
tmux is a terminal multiplexer. Its core capabilities boil down to three things: session persistence, window splitting, and remote reuse. Whether you're organizing local workspaces or ensuring tasks on remote servers survive disconnections, tmux provides reliable support. It runs on OpenBSD, FreeBSD, NetBSD, Linux, macOS, and Solaris—covering virtually all major Unix-like systems.
Why You Need tmux
Consider these scenarios:
- You're transferring hundreds of GB via
rsyncon a remote server. Halfway through, the Wi-Fi drops and the transfer dies, forcing you to start over - You're monitoring logs, running tests, and editing configs simultaneously, constantly switching between terminal windows
- You want to compare two files side by side, but your terminal's built-in splitting is too limited
tmux unifies these needs. It places each program in an independent virtual terminal managed by the tmux server. Even if you close your physical terminal, the tmux server keeps running and your programs remain untouched.
Core Concepts: Server, Session, Window, Pane
tmux uses a four-layer architecture to organize your terminal environment. Understanding these terms is key to using it effectively:
| Term | Description | Analogy |
|---|---|---|
| Server | The tmux background process managing all state and programs | OS kernel |
| Session | A collection of windows; one session can contain multiple windows | Workspace/project |
| Window | A single full-screen interface, like a traditional terminal tab | Browser tab |
| Pane | A split area within a window, each running its own terminal | Editor split |
Execution flow: Server runs in the background → Session organizes related Windows → Window is divided into multiple Panes → Each Pane runs an independent shell or program.
A Session can be attached to multiple clients or run completely detached. This is the mechanism behind "remote persistence"—you detach, the Session keeps running in the Server; SSH from another machine and reattach, everything is exactly as you left it.
Basic Operations: From Creation to Splitting
Creating and Detaching Sessions
# Create a new session (default names are numbers 0, 1, 2...)
tmux new-session
# or shorthand
tmux new
# Create with a specific name
tmux new -s myproject
# Detach from current session (shortcut: Ctrl+b then d)
tmux detach
# List all sessions
tmux ls
# Reattach to a session
tmux attach -t myproject
# or shorthand
tmux attachWindow Management
Windows are like "tabs" in traditional terminals, but entirely keyboard-controlled:
| Shortcut | Function |
|---|---|
Ctrl+b c | Create new window |
Ctrl+b n | Switch to next window |
Ctrl+b p | Switch to previous window |
Ctrl+b 0~9 | Switch to window by number |
Ctrl+b w | List all windows, interactive selection |
Ctrl+b , | Rename current window |
Ctrl+b & | Close current window |
Pane Splitting
This is tmux's most visible feature—operating side by side in one window:
| Shortcut | Function |
|---|---|
Ctrl+b % | Split vertically (left/right) |
Ctrl+b " | Split horizontally (top/bottom) |
Ctrl+b arrow | Switch between panes |
Ctrl+b o | Switch to next pane |
Ctrl+b ; | Switch to previously active pane |
Ctrl+b x | Close current pane |
Ctrl+b z | Zoom/unzoom current pane |
Ctrl+b space | Cycle through pane layouts |
Typical workflow after splitting: left pane for editor, right pane for tests or log monitoring, top small pane for ad-hoc commands.
The Practical Value of Session Persistence
Imagine starting a long-running task on a remote server:
# SSH to server
tmux new -s deploy
# Run inside tmux session
database-migration --verboseNow the network suddenly drops. Without tmux, this migration process might receive SIGTERM and terminate; with tmux, everything continues. After reconnecting via SSH:
tmux attach -s deploy
# You see the migration still running, output scrolling normallyThis "disconnect and reconnect" capability is crucial for:
- Long compilations: Large C++ projects compiling for hours, safe from network interruptions
- Data migration/backup:
rsync,pg_dumpand similar operations can safely run in the background - ML model training: GPU training tasks are expensive—can't fail due to network hiccups
- IRC/chat clients: Keep IRC clients online, attach anytime to check messages
Multiple Client Connections
A Session can be attached by multiple clients simultaneously, useful for collaboration:
# On machine A
tmux new -s pair
# On machine B (could be another computer, or another terminal as the same user)
tmux attach -t pairBoth people see the exact same terminal content, and input syncs in real-time. Combined with SSH shared accounts, this becomes the simplest "pair programming" environment.
Configuration and Customization
tmux's configuration file is ~/.tmux.conf with a simple command syntax. Here are some practical configurations:
# Change prefix key (from Ctrl+b to Ctrl+a, for screen users)
unbind C-b
set -g prefix C-a
bind C-a send-prefix
# Enable mouse support (click to switch panes, resize splits)
set -g mouse on
# Increase scrollback history
set -g history-limit 10000
# Status bar styling
set -g status-style bg=black,fg=white
set -g status-left "[#S] "
set -g status-right "%H:%M %d-%b-%y"
# Start window indexing at 1 (0 is too far from the left hand)
set -g base-index 1
setw -g pane-base-index 1
# Auto-renumber windows (when closing a middle window, others shift)
set -g renumber-windows on
# Vi-style keys (copy mode)
setw -g mode-keys vi
bind-key -T copy-mode-vi 'v' send -X begin-selection
bind-key -T copy-mode-vi 'y' send -X copy-selectionReload config: tmux source-file ~/.tmux.conf or in tmux press Ctrl+b : then type source ~/.tmux.conf
Copy Mode and Buffers
tmux has a built-in copy mode similar to Vim for scrolling and selecting in terminal history:
| Shortcut | Function |
|---|---|
Ctrl+b [ | Enter copy mode |
Space | Start selection |
Enter | Copy selection |
Ctrl+b ] | Paste buffer content |
q | Exit copy mode |
With mode-keys vi configured, you can use hjkl to move, / to search, v to select, and y to copy in copy mode.
Installation Methods
Package Manager Installation (Recommended)
macOS:
brew install tmuxDebian/Ubuntu:
sudo apt install tmuxArch Linux:
sudo pacman -S tmuxFedora/RHEL:
sudo dnf install tmuxAlpine:
sudo apk add tmuxBuilding from Source
# Install dependencies (libevent 2.x and ncurses)
# macOS: brew install libevent ncurses
# Ubuntu: sudo apt install libevent-dev ncurses-dev
# Build and install
git clone https://github.com/tmux/tmux.git
cd tmux
sh autogen.sh
./configure && make
sudo make installUsage Recommendations and Scenarios
Scenarios where tmux shines:
- Long-running tasks on remote servers
- Operations requiring simultaneous monitoring of multiple log streams
- Side-by-side file or output comparison
- Keeping IRC, email clients, or similar long-running applications online
- Organizing complex development environments (editor + tests + docs)
tmux and Terminal Emulators:
Modern terminal emulators (like Alacritty, iTerm2) have built-in splitting and tabs—so why tmux? The key is session persistence and cross-terminal reuse. Terminal splits disappear when you close the window; tmux sessions can be detached in iTerm2 and reattached in the system's default Terminal.
Recommended approach: terminal emulators handle rendering and aesthetics; tmux handles session management and workspace organization. Local development can use terminal splits; switch to tmux for remote servers or tasks that need to survive disconnections.
Shortcut Memory Tips:
All tmux shortcuts start with a prefix key (default Ctrl+b). Just remember a few essential ones:
ccreate,nnext,pprevious,ddetach%vertical split,"horizontal split, arrow keys to switchzzoom current pane, press again to restore
Related Resources
Source: