tmux 30-Day Zero-to-Hero

Task 1: Start session, name it, run sleep 300, detach, reattach

Objective: Understand how tmux sessions persist in the background

tmux new -s mysession
echo This is session 1 ...
# press prefix + d to detach
tmux attach -t mysession

Task 2: Create 3 sessions named work, play, test. List, attach/detach, kill one

Objective: Manage multiple concurrent sessions

tmux new -s work
 tmux new -s play
 tmux new -s test
tmux ls
tmux kill-session -t test

Task 3: Detach, close terminal tab, reopen, tmux attach — session survived

Objective: Prove session survives terminal disconnect

# detach, close tab, open new tab
tmux ls          # server still running
tmux attach      # session still alive

Task 1: Create 5 windows, rename each by task

Objective: Organize workflow with named windows

prefix + c  # new window
prefix + ,  # rename window
# name: code, logs, git, docs, shell

Task 2: Navigate by number, next, prev, last — 50 reps each

Objective: Build muscle memory for window switching

prefix + n    # next window
prefix + p    # prev window
prefix + 0-9  # jump to window N
prefix + l    # last window

Task 3: Create window, run tail -f on log, switch away, come back

Objective: Run background tasks while working in another window

prefix + c
tail -f /var/log/syslog
# switch away, switch back — still tailing

Task 1: Build 2x2 grid: split both ways, navigate all 4 panes 30x

Objective: Master pane splitting and navigation

prefix + %    # vertical split (left/right)
prefix + "    # horizontal split (top/bottom)
prefix + arrows  # move between panes

Task 2: Zoom each pane, work inside, unzoom — 20x

Objective: Focus on single pane without losing layout

prefix + z    # zoom into current pane
prefix + z    # unzoom

Task 3: Practice accidental-close recovery

Objective: Handle mistakes without panic

prefix + x    # close pane
# notice layout shift — learn to live with it

Task 1: Window 1: 3 panes. Window 2: single pane. Both for one project

Objective: Design multi-window, multi-pane project layout

# window 1: prefix + % twice, prefix + " once
# window 2: prefix + c

Task 2: Break a pane out into new window, rejoin if possible

Objective: Rearrange layout on the fly

prefix + !    # break pane into new window
prefix + }    # move pane right
prefix + {    # move pane left

Task 3: 10 full project sessions: create → panes → window → rename → detach → reattach

Objective: Internalize full session lifecycle

tmux new -s proj
# build layout, rename, detach, reattach
tmux rename-session -t 0 'myproject'

Task 1: Generate long output, scroll through, find line 500

Objective: Navigate scrollback buffer efficiently

seq 1 1000
prefix + [    # enter copy mode
# arrow keys or PgUp to scroll

Task 2: Copy multi-line block from one pane, paste in another — 20 reps

Objective: Transfer text between panes via copy buffer

prefix + [
# navigate, Space to start selection
# Enter/y to copy, prefix + ] to paste

Task 3: Search within copy mode, jump between matches

Objective: Find specific content in large output

prefix + [
/keyword    # search forward
?keyword    # search backward
n/N         # next/prev match

Task 4: Enable vi keys, redo all drills with h/j/k/l only

Objective: Use vim-style navigation in copy mode

prefix + :
set -g mode-keys vi
# now use h/j/k/l in copy mode

Task 1: Create 3 sessions, each with 2 windows + panes inside

Objective: Build complex multi-session environments

tmux new -s a
# add windows + panes, then:
tmux new -s b
tmux new -s c

Task 2: Switch between sessions, kill/rename via command line

Objective: Manage sessions without leaving keyboard

prefix + s    # list/switch sessions
prefix + $    # rename session
tmux kill-session -t name

Task 3: Recreate from scratch 5x until no looking at notes

Objective: Achieve session management fluency

# speed drill — muscle memory
# create session → windows → panes → detach

Task 1: Construct session dojo: editor (2 panes), server, git

Objective: Build a real-world developer workspace

tmux new -s dojo
# window 1: prefix + % (editor + shell)
# window 2: htop
# window 3: git status

Task 2: Navigate full chain 10 complete cycles

Objective: Fluent session → window → pane → copy → paste flow

session → window → pane → copy → paste
# full cycle 10x

Task 3: Speed drill: under 3 seconds to any named pane/window

Objective: Instant navigation to any element

prefix + 0-9  # window jump
prefix + arrows # pane jump
# target: < 3s

Task 4: Identify 3 forgotten keybindings, drill 100 reps each

Objective: Plug knowledge gaps with targeted repetition

prefix + ?    # list all keys
# find your weak spots, drill them

Task 1: Write config line by line, reload after each, verify live

Objective: Understand each config option's effect

# ~/.tmux.conf
set -g prefix C-a
unbind C-b
bind C-a send-prefix
set -g mouse on
# reload: prefix + : source ~/.tmux.conf

Task 2: Remap prefix, retrain all Week 1 drills with new prefix

Objective: Adapt muscle memory to custom prefix

set -g prefix C-a
unbind C-b
bind C-a send-prefix
# now use C-a instead of C-b

Task 1: Open 4 panes, cycle all layouts, note differences — 20 cycles

Objective: Know when to use each layout preset

prefix + space    # cycle layouts
even-horizontal, even-vertical, main-horizontal, main-vertical, tiled

Task 2: Build main-horizontal: big editor top, small console bottom

Objective: Create editor-focused workspace layout

prefix + space until main-horizontal
# resize: prefix + Alt+arrows

Task 3: Custom layout: 3 panes, resize to fit real dev workflow

Objective: Design layout matching your actual tools

prefix + z    # zoom pane
prefix + Alt+arrows  # resize split

Task 1: Show hostname, load average, time in status right

Objective: Display useful system info in status bar

set -g status-right '#H | #(uptime | cut -d, -f2) | %H:%M'

Task 2: Color the current window different from others

Objective: Visually distinguish active window

setw -g window-status-current-style bg=green,fg=black

Task 3: Add battery/date — make it yours

Objective: Personalize status bar for your needs

set -g status-right '#(date "+%%Y-%%m-%%d %%H:%%M")'

Task 1: Rebind pane navigation to vim keys h/j/k/l (no prefix)

Objective: Navigate panes with vim-style keys

bind -n M-h select-pane -L
bind -n M-j select-pane -D
bind -n M-k select-pane -U
bind -n M-l select-pane -R

Task 2: Add reload shortcut and direct window jump keys

Objective: Speed up config reload and window access

bind r source-file ~/.tmux.conf \; display 'reloaded'
bind -n M-1 select-window -t 1

Task 3: Full config from scratch with zero notes — 3x

Objective: Own your config through memorization

# delete ~/.tmux.conf, rebuild from memory
cat ~/.tmux.conf

Task 1: Use list-keys to find 5 unseen commands, document each

Objective: Discover hidden tmux capabilities

tmux list-keys | less
# find commands you never used

Task 2: Execute resize-pane, join-pane, swap-pane, synchronize-panes

Objective: Master advanced pane manipulation

prefix + : resize-pane -L 10
prefix + : join-pane -s 0
prefix + : swap-pane -U
prefix + : setw synchronize-panes on

Task 3: Write 10 command-mode macros you'll actually use

Objective: Create reusable command shortcuts

# bind them in .tmux.conf:
bind S command-prompt -p 'session:' 'new-session -s "%%"'

Task 1: Enable mouse: click, drag, scrollback, select windows

Objective: Full mouse integration for convenience

set -g mouse on
# click panes, drag borders, scroll wheel

Task 2: Give every window distinct color grouping

Objective: Visual organization by color coding

set -g window-status-format '#[fg=colour240]#I:#W'
set -g window-status-current-format '#[fg=colour46,bold]#I:#W'

Task 3: Configure dark color scheme; test in SSH and WSL

Objective: Consistent appearance across environments

set -g default-terminal 'tmux-256color'
set -ga terminal-overrides ',xterm-256color:Tc'

Task 1: Start EMPTY ~/.tmux.conf — build personal config under 20 min

Objective: Prove config fluency from memory

mv ~/.tmux.conf ~/.tmux.conf.bak
touch ~/.tmux.conf
# rebuild: prefix, mouse, vim nav, colors, status

Task 2: Time yourself: config to working setup, no notes

Objective: Speed benchmark for config creation

# target: < 20 minutes
# no peeking at notes

Task 3: Write paragraph summary of every config line

Objective: Deep understanding of every setting

# if you can't explain it, you don't own it
# annotate every line in ~/.tmux.conf

Task 1: Create full workspace scripted: session + windows + panes + commands

Objective: Automate workspace creation via CLI

tmux new -s proj -d
tmux split-window -h -t proj
tmux send-keys -t proj 'vim' Enter

Task 2: tmux new -s proj -d -c ~/project, attach after, verify

Objective: Script detached session with working directory

tmux new -s proj -d -c ~/project
tmux attach -t proj

Task 3: send-keys into a pane, confirm output

Objective: Send commands to specific panes programmatically

tmux send-keys -t proj 'ls -la' Enter

Task 1: Write ~/bin/dev script with has-session check

Objective: Create safe, re-runnable session scripts

#!/bin/bash
if tmux has-session -t dev 2>/dev/null; then
  tmux attach -t dev
else
  tmux new -s dev -c ~/project
fi

Task 2: Run script 5x from shell, from tmux, after killing session

Objective: Verify script works in all contexts

chmod +x ~/bin/dev
~/bin/dev    # always correct result

Task 1: Install tmuxp, write YAML: 3 windows with panes and commands

Objective: Define sessions as version-controlled YAML

pip install tmuxp
# ~/.tmuxp/project.yaml:
session_name: project
windows:
  - editor:
      layout: main-vertical
      panes:
        - vim
        - shell
  - server: npm start
  - git: git status

Task 2: Create session from YAML, save to dotfiles

Objective: Reproducible session definitions

tmuxp load ~/.tmuxp/project.yaml
tmuxp freeze > ~/.tmuxp/project.yaml

Task 3: Generate YAML from live session

Objective: Capture existing workspace as YAML

tmuxp freeze -y > new_session.yaml

Task 1: Add shell alias ta = attach-or-create

Objective: One-command session access from shell

# ~/.bashrc or ~/.zshrc:
ta() { tmux has-session -t "$1" 2>/dev/null && tmux attach -t "$1" || tmux new -s "$1"; }

Task 2: Auto-start tmux on SSH login (conditional)

Objective: Automatic tmux on remote connections

# ~/.bashrc:
if [ -n "$SSH_CLIENT" ] && [ -z "$TMUX" ]; then
  tmux attach-session -t main || tmux new-session -s main
fi

Task 3: Propagate env var into tmux session, verify pane sees it

Objective: Share environment variables across panes

set -g update-environment 'SSH_AUTH_SOCK SSH_CLIENT'
# or: tmux setenv -g VAR value

Task 1: 4 panes → synchronize → run commands in all at once → desync

Objective: Execute same command across multiple panes

prefix + :
setw synchronize-panes on
# type in all panes at once
setw synchronize-panes off

Task 2: Write test of sync/desync toggle, drill 20x

Objective: Toggle sync mode instantly

# bind to key:
bind S setw synchronize-panes \; display 'sync toggled'

Task 3: capture-pane + save-buffer to save output to file

Objective: Export terminal output for documentation

tmux capture-pane -t 0 -p > /tmp/output.txt
tmux capture-pane -t 0 -S -1000 | tee output.txt

Task 1: SSH to remote, start job, close terminal, reconnect, job alive

Objective: Work persists through network drops

ssh remote
tmux new -s work
tail -f /var/log/app.log
# close SSH, reconnect: job still running

Task 2: Two terminals attach same session, watch sync, detach one with -d

Objective: Multi-client session sharing

tmux attach -t session    # terminal 1
tmux attach -d -t session  # terminal 2 takes over

Task 3: If no remote: practice with docker container

Objective: Simulate remote environment locally

docker run -it --name tmux-test ubuntu bash
apt update && apt install tmux -y

Task 1: Write 3 scripts: dev workspace, server monitor, session switcher

Objective: Build reusable automation toolkit

# dev: new-session + split + send-keys
# monitor: htop, logs, ping in panes
# switcher: tmux switch-client -t name

Task 2: Break your own scripts, fix, verify idempotent

Objective: Harden scripts against edge cases

# run script twice — must not error
# add has-session checks

Task 3: 100 rep drill: create → navigate → detach → reattach → kill, timed

Objective: Speed and accuracy in full lifecycle

# speed drill
time ( tmux new -s test -d && sleep 0.1 && tmux kill-session -t test )

Task 1: Install TPM, restart tmux, verify no errors

Objective: Set up plugin management system

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm
# ~/.tmux.conf:
set -g @plugin 'tmux-plugins/tpm'
# press prefix + I to install

Task 2: Yank to system clipboard from copy mode

Objective: Copy text to system clipboard

set -g @plugin 'tmux-plugins/tmux-yank'
# copy mode: y copies to system clipboard

Task 3: Open URL under cursor

Objective: Open links directly from terminal

set -g @plugin 'tmux-plugins/tmux-open'
# copy mode: O opens URL under cursor

Task 1: Build workspace → save → kill-server → start fresh → restore → verify

Objective: Survive reboot with full workspace intact

set -g @plugin 'tmux-plugins/tmux-resurrect'
# save: prefix + Ctrl+s
# restore: prefix + Ctrl+r
tmux kill-server
# restart, restore — everything back

Task 2: Set auto-restore, simulate reboot, confirm zero loss

Objective: Automatic persistence without manual save

set -g @plugin 'tmux-plugins/tmux-continuum'
set -g @continuum-restore 'on'
set -g @continuum-save-interval '15'

Task 1: Install plugin, navigate vim→tmux without prefix, 30 reps seamless

Objective: Seamless navigation between vim and tmux

set -g @plugin 'christoomey/vim-tmux-navigator'
# use C-h/j/k/l to move between vim and tmux panes

Task 2: Try zoxide/fzf integrations

Objective: Fuzzy finding for sessions and files

set -g @plugin 'sainnhe/tmux-fzf'
# prefix + Ctrl-f for fuzzy session switch

Task 1: Popup pane drill: open/close popup, run command

Objective: Use popup panes for quick tasks

prefix + : display-popup
prefix + : display-popup -E    # interactive
prefix + : display-popup -w 80% -h 80%

Task 2: pipe-pane logging: record session to file, replay

Objective: Log terminal output for debugging

tmux pipe-pane -o 'cat >> /tmp/tmux.log'
tmux pipe-pane    # stop logging

Task 3: Multiple servers, list sockets

Objective: Run isolated tmux server instances

tmux -L foo new -s x    # custom socket
tmux list-sockets

Task 1: Build main pane + side panes workspace tuned to your tools

Objective: Design layout matching your development stack

# editor: 75% main + 25% side
# server: logs tailed
# git: status + diff panes

Task 2: Live in workspace for full day — no separate terminals

Objective: Complete workflow within tmux only

# every action through tmux
# count how many times you reach for new tab — retrain

Task 1: Build 4-pane monitor grid: htop, journalctl, df, ping

Objective: System monitoring dashboard in tmux

tmux new -s monitor
tmux split-window -h
tmux split-window -v
tmux select-pane -t 0
# htop | journalctl -f | df -h | ping localhost

Task 2: Multi-host SSH — one window per host, synchronize for parallel ops

Objective: Manage multiple servers simultaneously

# one tmux window per host
# synchronize-panes for parallel commands

Task 1: SSH to remote, attach nested session, double-prefix nav — 20x

Objective: Navigate nested tmux sessions

set -g prefix2 C-a    # secondary prefix
# double-tap prefix to reach inner tmux

Task 2: Session groups: link two sessions, switch windows across group

Objective: Share windows across multiple sessions

tmux new-session -d -s base
tmux new-session -d -s child -t base
# windows shared across group

Task 1: Profile config: every line justified, remove cruft, add why comments

Objective: Optimize config for performance and clarity

# comment every line: why, not what
# remove anything you don't use daily

Task 2: Test config on 2 different terminals and over SSH

Objective: Cross-environment consistency

# kitty, xterm, alacritty — all should look same
# SSH in, verify colors and keys

Task 3: Read man tmux for 3 commands — find one missed feature

Objective: Continuous learning from documentation

man tmux | less
# search for commands you use daily — find hidden flags

Task 1: Install/fix tmux from scratch

Objective: Clean installation from zero

apt install tmux / brew install tmux
tmux -V

Task 2: Write personal config from blank file (20 min cap)

Objective: Full config from memory under time pressure

# prefix, vim nav, mouse, colors, status, reload, base-index 1

Task 3: Script full dev workspace: session + 3 windows + 5 panes (10 min)

Objective: Automated workspace in under 10 minutes

tmux new -s dev -d
tmux split-window -h -t dev
tmux split-window -v -t dev.0
tmux send-keys -t dev 'vim' Enter

Task 4: TPM + resurrect + continuum working

Objective: Full plugin ecosystem operational

# plugins installed, save/restore working, auto-save on

Task 5: Copy-mode: search, select, yank to clipboard, paste

Objective: Complete copy workflow mastery

prefix + [ → /search → Space → y → prefix + ]

Task 6: Build 4-pane monitor grid

Objective: Operations dashboard from scratch

htop | journalctl -f | df -h | ping localhost

Task 7: Detach, kill server, restore via resurrect (5 min)

Objective: Full disaster recovery in 5 minutes

prefix + Ctrl+s
tmux kill-server
# restart, prefix + Ctrl+r

Task 8: Break something → fix via command mode only

Objective: Troubleshoot without config reload

prefix + :
# fix via command mode, no config reload
list-keys, show-options, resize-pane

Daily Block (2-3h)

15 min Warm-up — retype keybindings (muscle memory)
45 min New concept — read + tinker, break things
60 min Core drill — hands-on exercises
30 min Challenge — combine skills, build projects

5 min reading → 15 min tinkering. Break things.

Prefix Command

Ctrl + b Hold then release, press shortcut

c New window

n / p Next / Prev window

0-9 Jump to window N

% / " Split vertical / horizontal

arrows Move between panes

d Detach session

s Switch sessions

z Zoom pane

[ Copy mode

: Command mode

? List all keys

tmux Fluency: 30-Day Hands-On Challenge

Week 1: Core Concepts 0/7

Day 1 First Session, Client-Server Model

Day 2 Windows (Tabs)

Day 3 Panes: Splitting & Navigating

Day 4 Windows + Panes Combined

Day 5 Copy Mode & Scrolling

Day 6 Sessions Mastery

Day 7 WEEK 1 REVIEW: Digital Dojo

Week 2: Configuration & Layouts 0/7

Day 8 First .tmux.conf

Day 9 Layouts

Day 10 Status Bar

Day 11 Keybindings & Custom Commands

Day 12 Command Mode Deep Dive

Day 13 Colors, Mouse, UX Polish

Day 14 WEEK 2 REVIEW: Config from Scratch

Week 3: Scripting & Automation 0/7

Day 15 tmux CLI Scripting

Day 16 Idempotent Session Scripts

Day 17 tmuxp (YAML Session Definitions)

Day 18 Shell Integration

Day 19 Pane & Window Synchronization

Day 20 SSH + tmux Remote Workflow

Day 21 WEEK 3 REVIEW: Automation Portfolio

Week 4: Plugins & Mastery 0/9

Day 22 TPM (Tmux Plugin Manager)

Day 23 Persistence: resurrect & continuum

Day 24 vim-tmux-navigator Integration

Day 25 Advanced Features Tour

Day 26 Workflow Design: Dev Environment

Day 27 Workflow Design: Sysadmin/Server Ops

Day 28 Nested tmux & Deep Remote Work

Day 29 Performance & Polish

Day 30 FINAL: The Gauntlet

Daily Block (2-3h)

Prefix Command