Complete Tmux Course: Master the Terminal Multiplexer from Beginner to Pro

🚀 Latest Edition
📖 Beginner to Advanced
⏱️ 40 min read
🎯 20+ Sections

⏱️ Estimated reading time: 35-40 minutes

📋 Quick Summary: Tmux is a terminal multiplexer that lets you split your terminal into multiple panes, manage multiple windows, and keep sessions alive even after disconnecting. By the end of this course, you’ll master tmux from basic session management to advanced scripting, custom keybindings, and automated workflows that supercharge your terminal productivity.

💡 What Is Tmux and Why You Need It

Tmux (short for Terminal Multiplexer) is one of those tools that once you start using, you wonder how you ever survived without it. It’s a terminal application that lets you:

• Split your terminal into multiple panes and see them simultaneously
• Create multiple windows inside a single terminal session
• Keep your work persistent — disconnect and reconnect later without losing anything
• Share terminal sessions with pair programming partners
• Automate terminal layouts with scripts and plugins

Imagine you’re SSH’d into a server, running a long database migration, and your WiFi drops. With a regular terminal — RIP your progress. With tmux — reconnect, reattach, and your migration is still running like nothing happened. That’s the power of tmux.

Tmux was created by Nicholas Marriott as a modern alternative to GNU Screen. It’s BSD-licensed, actively maintained, and the default choice for most developers and sysadmins today.

💡 Did You Know? Tmux stands for “tmux” — it’s recursive! The actual expansion is “Tmux Multiplexer.” Yes, it’s a recursive acronym, just like GNU (GNU’s Not Unix).

🔄 Tmux Myths vs Reality

📦 Installation

🐧 Linux

# Debian/Ubuntu
sudo apt update && sudo apt install tmux -y

# RHEL/CentOS/Fedora
sudo dnf install tmux -y

# Arch
sudo pacman -S tmux

🍎 macOS

# Homebrew
brew install tmux

🪟 Windows

# WSL (Windows Subsystem for Linux)
# Install Ubuntu/Debian from Microsoft Store, then:
sudo apt update && sudo apt install tmux -y

# Or via Git Bash / MSYS2
pacman -S tmux

# Verify installation
tmux -V
# tmux 3.5a (or similar)

🎬 Your First Tmux Session

Fire up your terminal and run:

tmux new -s mysession

Notice the green status bar at the bottom? That’s the tmux bar. You’re now inside a tmux session. Let’s understand what you’re looking at:

To detach: tmux detach or press Ctrl+b d. Your session stays alive.

To reattach:

tmux attach -t mysession
# Or just attach to most recent session
tmux attach

💡 Did You Know? The prefix key Ctrl+b can be remapped to Ctrl+a (like GNU Screen) or the easier-to-reach Ctrl+Space. Most veterans remap it to Ctrl+a or use Caps Lock as an extra Ctrl key.

🔑 The Prefix Key — Your Tmux Master Key

Everything in tmux starts with the prefix key. By default it’s Ctrl+b. The pattern is always:

Prefix → Command key → Action happens

For example: Ctrl+b then c → creates a new window. You don’t hold both — press prefix, release, then press the command.

🗂️ Session Management

Sessions are the top-level container. Think of them as independent workspaces.

✨ Creating Sessions

# Named session (recommended)
tmux new -s myproject

# Unnamed session
tmux new

# Start with a command
tmux new -s dev 'vim main.py'

# Start in a directory
tmux new -s project -c ~/projects/myapp

📋 Listing Sessions

tmux ls
# Or
tmux list-sessions

🔗 Attaching & Detaching

# Detach from current session
tmux detach
# Or: Ctrl+b d

# Attach by name
tmux attach -t myproject

# Attach to most recent
tmux attach

# Detach others if attached elsewhere
tmux attach -t myproject -d

# Switch between sessions (from inside tmux)
tmux switch -t other-session

💀 Killing Sessions

# Kill a specific session
tmux kill-session -t myproject

# Kill all except current
tmux kill-session -a

# Kill all except a specific one
tmux kill-session -a -t keep-this-one

🪟 Working with Windows

Windows are like browser tabs inside a session. Each window has its own content and can be split into panes.

# CLI equivalents
tmux new-window -t mysession -n "editor"
tmux rename-window -t mysession:1 "server"
tmux select-window -t mysession:2
tmux kill-window -t mysession:3

# Move window to different session
tmux move-window -s mysession:1 -t other:1

# Reorder windows (swap 1 and 2)
tmux swap-window -s 1 -t 2

🧩 Mastering Panes — Split Your Screen

Panes let you view multiple terminals in one window. This is where tmux really shines.

# CLI equivalents
tmux split-window -h          # vertical split
tmux split-window -v          # horizontal split
tmux select-pane -L           # move left
tmux select-pane -U           # move up
tmux select-pane -t 2         # select by number
tmux resize-pane -L 10        # resize left by 10 cells
tmux resize-pane -D 5         # resize down by 5 cells
tmux kill-pane -t 1           # kill pane 1
tmux break-pane -n "isolated" # break pane to new window

🎨 Layouts — Arrange Panes Perfectly

Built-in layouts cycle through common arrangements:

# Cycle layouts (in order)
# Ctrl+b Space

# Or set directly
tmux select-layout even-horizontal
tmux select-layout even-vertical
tmux select-layout main-horizontal
tmux select-layout main-vertical
tmux select-layout tiled

# Custom layout (save/restore)
tmux list-windows -F '#{window_layout}'
# Save the layout string and restore later:
tmux select-layout "bb6d,135x47,0,0[135x28,0,0,0,135x18,0,29,1]"

Layout Types Explained

📋 Copy Mode & Scrolling

Regular terminal scrolling won’t work inside tmux. Everything goes through tmux’s scrollback buffer:

# Enter copy mode
# Ctrl+b [     (or Ctrl+b PageUp)

# Navigation in copy mode (vi-mode, default)
hjkl          # Move cursor
Ctrl+u        # Half page up
Ctrl+d        # Half page down
Ctrl+b        # Full page up
Ctrl+f        # Full page down
gg            # Top of buffer
G             # Bottom of buffer
/             # Search forward
?             # Search backward
n             # Next match
N             # Previous match

# Select and copy
v             # Start selection (character-wise)
V             # Start selection (line-wise)
y             # Yank (copy) selection to tmux buffer
Enter         # Copy and exit copy mode

# Paste
# Ctrl+b ]

Enabling Mouse for Scrolling

# In config (~/.tmux.conf)
set -g mouse on

# Or toggle while running
# Ctrl+b : set -g mouse on

💡 Did You Know? You can copy text to the system clipboard (not just tmux’s internal buffer) by adding this to your config: bind -T copy-mode-vi y send -X copy-pipe-and-cancel "pbcopy" (macOS) or xclip -i -selection clipboard (Linux).

⚙️ Tmux Configuration — ~/.tmux.conf

Your tmux config lives at ~/.tmux.conf. Every time you start a new session, tmux reads this file. Changes take effect immediately for new sessions.

Minimal Starter Config

# ─── Mouse Support ───
set -g mouse on

# ─── Increase History ───
set -g history-limit 50000

# ─── Faster Escape ───
set -sg escape-time 10

# ─── Start Window Index at 1 ───
set -g base-index 1
setw -g pane-base-index 1

# ─── Remap Prefix to Ctrl+a (easier) ───
unbind C-b
set -g prefix C-a
bind C-a send-prefix

# ─── Better Split Keys ───
bind | split-window -h    # Alt+Shift+\
bind - split-window -v    # Alt+-

# ─── Vim-like Pane Navigation ───
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R

# ─── Reload Config ───
bind r source-file ~/.tmux.conf \; display "Config Reloaded!"

# ─── Status Bar Styling ───
set -g status-style bg=#1a1a2e,fg=#e0e0e0
set -g status-left "#[fg=green]#S "
set -g status-right "#[fg=yellow]%d-%m-%Y %H:%M "

# ─── 256 Colors ───
set -g default-terminal "screen-256color"
set -ga terminal-overrides ",*256col*:Tc"

Applying Config

# Reload config from inside tmux
# Ctrl+b :source-file ~/.tmux.conf

# Or with the bind from above: Ctrl+b r

# Check current settings
tmux show -g
tmux showw                    # window options
tmux show -g mouse           # specific option

🎯 Customizing the Status Bar

The status bar is tmux’s dashboard. You can display anything — system info, battery, git branch, weather, even CPU load.

# ─── Left side: session name + window list ───
set -g status-left "#[fg=green,bold] #S "
set -g status-left-length 40

# ─── Right side: date/time and host ───
set -g status-right "#[fg=yellow] %d-%m-%Y #[fg=cyan]%H:%M #[fg=red]#h "
set -g status-right-length 60

# ─── Active window highlight ───
setw -g window-status-current-style bg=#2563eb,fg=white

# ─── Status bar position ───
set -g status-position top    # default is bottom

# ─── Interval (how often right side updates) ───
set -g status-interval 5

🔌 Tmux Plugin Manager (TPM)

TPM is the easiest way to extend tmux:

# 1. Install TPM
git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

# 2. Add to ~/.tmux.conf
# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'tmux-plugins/tmux-sensible'
set -g @plugin 'tmux-plugins/tmux-resurrect'
set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @plugin 'tmux-plugins/tmux-yank'
set -g @plugin 'nhdaly/tmux-better-mouse-mode'
set -g @plugin 'christoomey/vim-tmux-navigator'

# Initialize TPM
run '~/.tmux/plugins/tpm/tpm'

# 3. Install plugins
# Ctrl+b I  (capital I)

Must-Have Plugins

🤖 Tmux Scripting — Automate Everything

This is where tmux becomes a productivity powerhouse. You can script entire development environments:

#!/bin/bash
# dev-session.sh — Launch a complete dev environment

SESSION="myapp"
WORKSPACE="$HOME/projects/myapp"

# Kill existing session if it exists
tmux kill-session -t $SESSION 2>/dev/null

# Create new session with one window
tmux new-session -d -s $SESSION -c $WORKSPACE -n "editor"

# Window 0: editor with vim (left 60%)
tmux send-keys -t $SESSION:0 'vim src/' Enter
tmux split-window -h -t $SESSION:0 -c $WORKSPACE
tmux resize-pane -t $SESSION:0 -R 30

# Window 1: server + logs
tmux new-window -t $SESSION -c $WORKSPACE -n "server"
tmux send-keys -t $SESSION:1 'npm run dev' Enter
tmux split-window -v -t $SESSION:1 -c $WORKSPACE
tmux send-keys -t $SESSION:1.2 'tail -f logs/app.log' Enter

# Window 2: git status
tmux new-window -t $SESSION -c $WORKSPACE -n "git"
tmux send-keys -t $SESSION:2 'git status' Enter

# Window 3: terminal scratch
tmux new-window -t $SESSION -c $WORKSPACE -n "terminal"

# Select first window and attach
tmux select-window -t $SESSION:0
tmux attach -t $SESSION

👥 Pair Programming with Tmux

One of tmux’s killer features — two people, one terminal:

# Person A (on the server)
tmux new -s pair

# Person B joins via SSH, then:
tmux attach -t pair

# Both users see the same session in real-time
# Each can have their own cursor in their own client

# Socket sharing (alternative, no SSH needed for LAN):
tmux -S /tmp/pair new -s pair
chmod 777 /tmp/pair
# Person B: tmux -S /tmp/pair attach

⌨️ Essential Tmux Commands Reference

📦 Managing Buffers

Tmux has multiple copy buffers (like Vim’s registers):

# List buffers
tmux list-buffers

# Show buffer content
tmux show-buffer -b 0

# Save buffer to file
tmux save-buffer -b 0 -a > output.txt

# Delete buffer
tmux delete-buffer -b 0

# Paste buffer
tmux paste-buffer -b 0

# Choose buffer interactively
# Ctrl+b = (equals sign)

# Buffer naming
tmux set-buffer -b my-snippet "content here"

📊 Tmux Formats — Custom Output

Tmux formats let you extract any property for scripting:

# List sessions with custom format
tmux list-sessions -F "#{session_name}: #{session_windows} windows"

# List windows with pane info
tmux list-windows -F "#{window_index}: #{window_name} [#{window_panes} panes]"

# List panes with details
tmux list-panes -F "#{pane_index} #{pane_current_command} #{pane_title}"

# Get current session name
tmux display-message -p '#S'

# Get current window index
tmux display-message -p '#I'

# Check if session exists
tmux has-session -t mysession 2>/dev/null && echo "exists"

# Common format variables:
# #{session_name}  #S
# #{window_index}  #I
# #{pane_index}    #P
# #{host}          #H
# #{host_short}    #h
# #{pane_title}    #T
# #{cursor_x}      #X
# #{cursor_y}      #Y
# #{scroll_position}

🛠️ Advanced Tmux Hacks

Broadcast to All Panes

# Set synchronization mode
# Ctrl+b : setw synchronize-panes on
# Every keystroke goes to ALL panes
# Perfect for running same command on multiple servers

# Toggle with a keybinding
bind S setw synchronize-panes \; display "Sync: #{?synchronize-panes,ON,OFF}"

Auto-Start Tmux on SSH

# Add to ~/.bashrc or ~/.zshrc
if [[ -z "$TMUX" ]] && [[ -n "$SSH_CONNECTION" ]]; then
    tmux new-session -A -s remote
    exit
fi

Tail Multiple Logs

#!/bin/bash
# tail-multi.sh — Tail multiple logs in tiled panes
SESSION="logs"
tmux new-session -d -s $SESSION -n "logs"
tmux send-keys -t $SESSION "tail -f /var/log/nginx/access.log" Enter
tmux split-window -h -t $SESSION
tmux send-keys -t $SESSION "tail -f /var/log/nginx/error.log" Enter
tmux split-window -v -t $SESSION
tmux send-keys -t $SESSION "journalctl -f -u nginx" Enter
tmux select-layout -t $SESSION tiled
tmux attach -t $SESSION

Popup Terminal (Tmux 3.2+)

# Display a popup terminal (like a floating window)
# Ctrl+b : display-popup -w 80% -h 80% "htop"

# Add keybinding
bind P display-popup -w 80% -h 80% -E "htop"

⚠️ Common Mistakes Beginners Make

🏗️ Real Project — Dev Environment Script

Here’s a complete script that sets up a full web development workspace:

#!/bin/bash
# webdev.sh — Full-stack development environment

PROJECT="${1:-myapp}"
SESSION="dev-$PROJECT"
WORKSPACE="$HOME/projects/$PROJECT"

# Check if project exists
if [[ ! -d "$WORKSPACE" ]]; then
    echo "📁 Creating project: $PROJECT"
    mkdir -p "$WORKSPACE"
fi

cd "$WORKSPACE" || exit 1

# Kill existing session
tmux kill-session -t "$SESSION" 2>/dev/null

# ── Window 0: Code Editor ──
tmux new-session -d -s "$SESSION" -n "code"
tmux send-keys -t "$SESSION:0" 'nvim .' Enter
tmux split-window -h -t "$SESSION:0"
tmux send-keys -t "$SESSION:0.right" 'make test' Enter
tmux split-window -v -t "$SESSION:0.right"
tmux send-keys -t "$SESSION:0.bottom" 'lazygit' Enter

# ── Window 1: Dev Server ──
tmux new-window -t "$SESSION" -n "server"
tmux send-keys -t "$SESSION:1" 'echo "🚀 Starting dev server..."' Enter
tmux send-keys -t "$SESSION:1" 'npm run dev' Enter
tmux split-window -v -t "$SESSION:1"
tmux send-keys -t "$SESSION:1.2" 'npx tsc --watch' Enter

# ── Window 2: Database ──
tmux new-window -t "$SESSION" -n "db"
tmux send-keys -t "$SESSION:2" 'mysql -u root -p' Enter

# ── Window 3: API Docs / Shell ──
tmux new-window -t "$SESSION" -n "shell"
tmux send-keys -t "$SESSION:3" 'curl http://localhost:3000/api/health' Enter

# ── Attach ──
tmux select-window -t "$SESSION:0"
tmux select-pane -t "$SESSION:0.left"
tmux attach -t "$SESSION"

✅ Do’s and Don’ts

❓ FAQ — 10 Questions Everyone Asks

📖 Glossary

🛠️ Tools & Resources

• Tmux GitHub — Official source code and releases
• TPM — Tmux Plugin Manager — The standard plugin manager
• tmux-resurrect — Save and restore sessions
• tmux-continuum — Auto-save and restore on tmux start
• tmux-yank — System clipboard integration
• vim-tmux-navigator — Seamless Vim/tmux navigation
• Tmux Cheat Sheet — Quick reference for all commands
• Official Tmux Manual — The complete reference
• Awesome Tmux — Community-curated list of plugins and resources

🗺️ Learning Roadmap

1. Day 1: Create a session, detach, reattach. Practice session management commands.
2. Day 2: Master windows — create, rename, switch, close. Use Ctrl+b w for the window picker.
3. Day 3: Panes — split vertically and horizontally, navigate, resize, zoom. Practice layouts.
4. Day 4: Copy mode and buffers. Learn to navigate, search, select, yank, and paste within tmux.
5. Day 5: Config file. Create your ~/.tmux.conf with mouse, history, prefix remap, and custom bindings.
6. Day 6: Status bar customization. Add git branch, date/time, hostname. Make it look good.
7. Day 7: Plugins. Install TPM and add resurrect, continuum, yank, and vim-navigator.
8. Day 8-10: Scripting. Write a dev environment script. Automate your daily workspace setup.
9. Day 11-14: Advanced. Pair programming, popups, custom formats, nested sessions. Explore what’s possible.

🔧 Troubleshooting Guide

⚡ Performance & Benchmarking

Tmux is remarkably lightweight:

# Memory usage (new session, 1 window, 1 pane)
# ~8-12 MB RSS

# With 5 windows and 15 panes
# ~25-35 MB RSS

# CPU: essentially idle (~0.1%) when not rendering changes
# Screen updates: ~60fps, no perceptible lag

# Benchmark: 4 windows × 3 panes = 12 panes, all running `watch` commands
# CPU: 2-3% on a modern processor
# Memory: ~40 MB

Compared to modern IDE terminals, tmux uses 10-50x less memory and CPU. That’s why it’s the go-to for servers, embedded systems, and minimal setups.

🏁 Final Thoughts

Tmux is one of those rare tools that fundamentally changes how you interact with a terminal. It’s not just a multiplexer — it’s a session persistence layer, a window manager for the terminal, and a scripting engine for development environments.

The key to mastering tmux isn’t memorizing every keybinding. It’s:

1. Learn the 10 essential commands (session, window, pane basics)
2. Create a config file that works for your workflow
3. Use scripts to automate your setup
4. Install TPM and a few must-have plugins
5. Practice until it becomes muscle memory

Start small — just use tmux new -s work tomorrow morning and detach/reattach throughout the day. You’ll be hooked by lunch.

💡 Pro Tip: The real power of tmux reveals itself during SSH sessions. Once you have tmux-resurrect + tmux-continuum running on a remote server, you can literally never worry about dropped connections again. Everything auto-saves and auto-restores. It changes the game for remote work.

📚 More Free Courses on TricksPage

• Git & GitHub Course — Master Git from basics to collaboration workflows, CI/CD, and open-source.
• Linux Commands Course — Complete Linux command line mastery from beginner to advanced.
• Docker & Swarm Course — Containers, Dockerfiles, Compose, Swarm orchestration.
• n8n Automation Course — Workflow automation with 400+ integrations.
• Agentic AI Course — Build AI agents with ReAct patterns, tools, memory.
• DSA Course in Python — Master data structures and algorithms with Python.
• Productivity Blueprint — Master time management and achieve your goals.