tmux

tmux new -s work -n editor -c ~/projects        # session "work", first window "editor", cwd set
tmux new -d -s build -x 200 -y 50               # detached; size matters for tools that read the terminal width
tmux ls                                         # sessions, window counts, attached or not
tmux attach -t work                             # a second client on the same session mirrors it
tmux attach -d -t work                          # detach the others first: fixes a window sized to a small screen
tmux switch-client -t build                     # move this client to another session without detaching
tmux rename-session -t work api
tmux kill-session -t build                      # kills every process in it

tmux new-window -n logs 'journalctl -fu my-app'   # a window running one command closes when that command exits
tmux split-window -h -c '#{pane_current_path}'    # right of the current pane, same directory
tmux split-window -v -l 10 'htop'                 # below, ten lines high
tmux select-pane -t :.+                           # next pane in the current window
tmux resize-pane -Z                               # toggle zoom
tmux resize-pane -D 5                             # five lines shorter
tmux select-layout even-horizontal                # also even-vertical, main-horizontal, main-vertical, tiled
tmux break-pane                                   # current pane becomes its own window
tmux join-pane -s logs -t editor                  # window "logs" becomes a pane in "editor"
tmux swap-pane -U                                 # exchange with the pane above
tmux swap-window -s 3 -t 1
tmux respawn-pane -k                              # kill what is running and restart the pane's command

tmux list-keys -T prefix                    # everything under the prefix
tmux list-keys -T copy-mode-vi | grep -i copy
tmux bind -r H resize-pane -L 5             # repeatable
tmux bind -n M-Left select-pane -L          # Alt-Left, no prefix
tmux unbind C-b; tmux set -g prefix C-a; tmux bind C-a send-prefix   # C-a as prefix, C-a C-a sends a literal C-a

set -g mode-keys vi
bind -T copy-mode-vi v send-keys -X begin-selection
bind -T copy-mode-vi C-v send-keys -X rectangle-toggle
bind -T copy-mode-vi y send-keys -X copy-selection-and-cancel
bind -T copy-mode-vi Escape send-keys -X cancel
bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel   # mouse selections go to copy-command too

tmux copy-mode -e            # -e: leave copy mode when scrolled back to the bottom
tmux list-buffers            # every buffer, newest first
tmux show-buffer             # print the newest to stdout
tmux save-buffer ~/out.txt   # write it to a file
tmux load-buffer ~/in.txt    # file into a buffer
tmux set-buffer "$text"      # string into a buffer
tmux paste-buffer -t work:1  # paste into a specific pane
tmux capture-pane -p -S -    # print the whole scrollback of the current pane, no copy mode needed

set -s set-clipboard on                                      # also lets programs inside (Neovim, for example) use OSC 52
set -as terminal-features ',xterm-256color:clipboard'        # tmux 3.2+; the name is the outer TERM, not tmux's own

set -s copy-command 'wl-copy'          # Wayland; xclip -selection clipboard for X11; pbcopy on macOS
set -s set-clipboard off               # avoid double-copying on terminals that also handle OSC 52

# Terminal: tmux's own TERM, and what the outer terminal can do
set -g default-terminal 'tmux-256color'                   # falls back to screen-256color if terminfo lacks it
set -as terminal-features ',xterm-256color:RGB'           # 24-bit colour on this outer TERM (3.2+); older: terminal-overrides ',*:Tc'
set -s escape-time 10                                     # ms to wait after Escape; default 500 makes Vim feel broken
set -s extended-keys on                                   # pass Ctrl-Shift and similar combinations through (3.2+)
set -g focus-events on                                    # Vim and Neovim see FocusGained/FocusLost
set -g allow-passthrough on                               # apps may send escape sequences straight to the outer terminal (3.3+): images, OSC 52 from inside

# Behaviour
set -g history-limit 50000
set -g mouse on                                           # click panes, drag to resize, wheel to scroll
set -g base-index 1                                       # windows count from 1; 0 is far from the other keys
set -gw pane-base-index 1
set -g renumber-windows on                                # close window 2 of 4 and the rest shift down
set -g mode-keys vi
set -g status-keys emacs                                  # readline-style editing at the : prompt
set -g display-time 2000                                  # message duration, ms
set -g set-titles on
set -g set-titles-string '#S:#W #{pane_title}'

# Keys
unbind C-b
set -g prefix C-Space
bind C-Space send-prefix
bind r source-file ~/.tmux.conf \; display 'reloaded'
bind | split-window -h -c '#{pane_current_path}'
bind - split-window -v -c '#{pane_current_path}'
bind c new-window -c '#{pane_current_path}'
bind -r h select-pane -L
bind -r j select-pane -D
bind -r k select-pane -U
bind -r l select-pane -R

# Status line
set -g status-interval 5
set -g status-left '#[bold]#S #[default]'
set -g status-right '#(uptime | sed "s/.*load average: //") %H:%M'

#!/usr/bin/env bash
set -euo pipefail

session=dev
root=$HOME/projects/my-app

if ! tmux has-session -t "=$session" 2>/dev/null; then       # "=" forces an exact name match
  tmux new-session -d -s "$session" -n editor -c "$root"
  tmux send-keys -t "$session:editor" 'vim .' Enter
  tmux new-window -t "$session" -n server -c "$root"
  tmux send-keys -t "$session:server" 'make run' Enter
  tmux split-window -t "$session:server" -v -l 15 -c "$root"
  tmux send-keys -t "$session:server.1" 'tail -f log/dev.log' Enter
  tmux select-window -t "$session:editor"
fi

if [[ -n ${TMUX:-} ]]; then
  tmux switch-client -t "$session"      # already inside tmux: nesting an attach is refused
else
  exec tmux attach -t "$session"
fi

tmux new-session -d -s job "make test; tmux wait-for -S job-done"   # signal the channel when the command ends
tmux wait-for job-done                                              # block until it does
tmux capture-pane -p -t job -S - > test-output.txt

tmux pipe-pane -t work:server -o 'cat >> ~/server.log'   # -o toggles: the same command again stops it

tmux display -p -t work:server '#{pane_pid}'                       # PID of the shell in the pane
tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_current_command}'
tmux list-windows -t work -F '#{window_index} #{window_name} #{window_activity}'
tmux set-environment -t work API_URL https://api.example.com       # new panes in the session inherit it
tmux new-session -d -s api -e API_TOKEN="$API_TOKEN"               # 3.2+: environment for the whole session

Host build
    HostName build.example.com
    RequestTTY yes
    RemoteCommand tmux new -A -s main

eval "$(tmux show-environment -s SSH_AUTH_SOCK)"     # re-export the value tmux has now

# ~/.ssh/rc on the remote host: runs on each connection, in sh
if [ -S "$SSH_AUTH_SOCK" ] && [ "$SSH_AUTH_SOCK" != "$HOME/.ssh/agent.sock" ]; then
  ln -sf "$SSH_AUTH_SOCK" "$HOME/.ssh/agent.sock"
fi

# ~/.config/systemd/user/tmux.service
[Unit]
Description=tmux server

[Service]
Type=forking
ExecStart=/usr/bin/tmux new-session -d -s main
ExecStop=/usr/bin/tmux kill-server

[Install]
WantedBy=default.target

# outer .tmux.conf
bind -T root F12 set prefix None \; set key-table off \; refresh-client -S
bind -T off F12 set -u prefix \; set -u key-table \; refresh-client -S

# Attach to "main" or create it; the everyday entry point
tmux new -A -s main

# Run a long job detached, log it, and notify when done
tmux new -d -s backup 'rsync -a /data/ backup.example.com:/data/ 2>&1 | tee ~/backup.log; notify-send "backup finished"'

# Send the same command to every pane in the current window (toggle with the same command)
tmux setw synchronize-panes on

# Type a command into every pane of the window without sync mode
for p in $(tmux list-panes -F '#{pane_id}'); do tmux send-keys -t "$p" 'sudo dnf update -y' Enter; done

# One pane per host, tiled, each running an SSH session
for h in web-1 web-2 db-1; do tmux split-window -c ~ "ssh $h"; tmux select-layout tiled; done; tmux kill-pane -t 0

# Kill every session except the current one
tmux kill-session -a

# Kill sessions with no attached client
tmux ls -F '#{session_name} #{session_attached}' | awk '$2==0{print $1}' | xargs -rn1 tmux kill-session -t

# Save the whole scrollback of the current pane to a file
tmux capture-pane -p -J -S - > ~/pane-$(date +%s).txt

# Search scrollback for a pattern and print matching lines with pane context
tmux capture-pane -p -S - | grep -n 'ERROR'

# Move the current pane into a window of its own, then bring it back later
tmux break-pane -n scratch; tmux join-pane -s scratch -t work:1

# Rename the current window after the running command
tmux rename-window "$(tmux display -p '#{pane_current_command}')"

# Toggle the status line to reclaim a row
tmux set status

# Show the effective value of one option and where it was set
tmux show-options -g escape-time; tmux show-options -gs terminal-features

# Which TERM and colour capabilities does tmux believe the outer terminal has
tmux display -p '#{client_termname} #{client_termfeatures}'

# Resize the current window to the largest attached client
tmux resize-window -A

# Open a popup shell over the current pane (3.2+); Escape or exit closes it
tmux display-popup -E -w 80% -h 80%

# Watch a pane's output in another pane
tmux pipe-pane -o 'cat >> /tmp/watch.log'; tmux split-window 'tail -f /tmp/watch.log'

# Use a private server for a throwaway environment, isolated from the default socket
tmux -L scratch new -s test

# Clear history of the current pane
tmux clear-history

# List every pane with its PID, so `kill` can target the process not the pane
tmux list-panes -a -F '#{session_name}:#{window_index}.#{pane_index} #{pane_pid} #{pane_current_command}'

#!/usr/bin/env bash
# usage: workspace <name> <directory>
set -euo pipefail
name=${1:?session name}
dir=${2:?directory}
[[ -d $dir ]] || { printf 'no such directory: %s\n' "$dir" >&2; exit 1; }

if ! tmux has-session -t "=$name" 2>/dev/null; then
  tmux new-session -d -s "$name" -n shell -c "$dir"
  tmux new-window -t "$name" -n edit -c "$dir" "${EDITOR:-vim}"
  tmux new-window -t "$name" -n git -c "$dir"
  tmux send-keys -t "$name:git" 'git status' Enter
  tmux select-window -t "$name:edit"
fi
if [[ -n ${TMUX:-} ]]; then tmux switch-client -t "$name"; else exec tmux attach -t "$name"; fi

#!/usr/bin/env bash
# usage: fanout "<command>" host1 host2 ...
set -euo pipefail
cmd=${1:?command}; shift
(( $# )) || { echo 'no hosts' >&2; exit 2; }
session="fanout-$$"
tmux new-session -d -s "$session" -x 220 -y 60 "ssh -o ConnectTimeout=10 $1 $(printf '%q' "$cmd"); echo '[done: $1]'; exec \$SHELL"
shift
for host in "$@"; do
  tmux split-window -t "$session" "ssh -o ConnectTimeout=10 $host $(printf '%q' "$cmd"); echo '[done: $host]'; exec \$SHELL"
  tmux select-layout -t "$session" tiled
done
tmux setw -t "$session" synchronize-panes off
exec tmux attach -t "$session"

#!/usr/bin/env bash
set -euo pipefail
tmux ls -F '#{session_name}' 2>/dev/null | while IFS= read -r s; do
  attached=$(tmux display -p -t "$s" '#{session_attached}')
  printf '%s (%s clients)\n' "$s" "$attached"
  tmux list-panes -s -t "$s" -F '  #{window_index}:#{window_name}.#{pane_index}  #{pane_current_command}  #{pane_current_path}'
done