TMUX in 100 seconds | Prime Reacts

TL;DR

tmux is a terminal multiplexer that lets users run and organize multiple terminal sessions inside one window.

Briefing Cornell Notes

Briefing

tmux is an open-source terminal multiplexer that lets users juggle many terminal sessions from a single window—without losing work when windows close. Created in 2007 by Nicholas Marriott after frustration with older terminal multiplexers, it’s positioned as a practical alternative to tools like GNU Screen, with tmux’s BSD license often cited as a reason it’s widely adopted. The core payoff is organization: sessions can be split into panes horizontally or vertically, assigned custom names, and navigated quickly through a status bar—so running a web server, database, logs, editors, and system monitors doesn’t turn into “chaos” across separate terminal windows.

A major theme is resilience. When a terminal running a long-lived process gets closed, tmux keeps the session alive in the background. Reconnecting is fast: listing sessions with tmux ls and reattaching with tmux attach restores the exact working environment. That workflow is contrasted with the typical pain of manually restarting multiple terminals after a disconnect or reboot. The transcript also emphasizes speed of switching—moving between sessions and windows via keyboard shortcuts rather than the mouse—plus the ability to keep multiple project contexts alive simultaneously.

Beyond manual use, tmux becomes more powerful through scripting. The transcript walks through a bash-driven approach: check whether a named session exists using tmux has-session; if it does, reattach; if not, create it with tmux new-session and initialize windows with commands (for example, changing directories into a project and launching an editor like Nano). Additional windows can be created for services such as a server, database, and logging, and tmux can focus a specific window first using select-window. There’s also mention of plugins that automate common workflows—such as resurrect to restore environments after reboot—along with a custom plugin called sessionization that supports fuzzy-finding between project sessions while keeping them running.

The transcript closes with setup guidance for getting started on Unix-like systems (including Mac OS, Linux, and WSL), plus a brief tour of navigation and pane/window management shortcuts. It also nods to Ghostty as a terminal emulator the user wants to try next, but the central message remains consistent: tmux turns terminal work into a structured, scriptable workspace where sessions persist, switching is keyboard-fast, and complex multi-service development setups can be recreated reliably.

Cornell Notes

tmux is a terminal multiplexer that keeps multiple terminal sessions organized inside one window, with a status bar for quick navigation. Its key advantage is persistence: closing a terminal doesn’t kill the running processes—sessions keep running in the background and can be listed (tmux ls) and reattached (tmux attach). The workflow becomes even more efficient with scripting: bash can check whether a named session exists (tmux has-session), create it if missing (tmux new-session), and initialize windows to run commands in specific project directories. Plugins and custom tooling (like sessionization) can further automate restoring and switching between project environments. This matters because it reduces the time and risk of “rebuilding” a multi-terminal setup after disconnects or restarts.

What problem tmux solves for day-to-day development workflows?

tmux prevents “terminal sprawl” by letting users run many sessions (web server, database, logs, editors, monitoring tools) inside one organized interface. Instead of reopening and manually recreating multiple terminals, tmux keeps sessions alive and accessible through a status bar and keyboard navigation.

How does tmux handle the common failure mode of closing a terminal window?

Closing the terminal window doesn’t end the work. The tmux session continues running in the background. Users can recover by running tmux ls to find the session and then tmux attach to reattach to it, restoring the environment.

How can tmux be automated with bash to recreate a project workspace?

A bash script can define a session name, then check for existence with tmux has-session. If the session exists, the script reattaches; otherwise it creates a new session with tmux new-session. It can then initialize windows (e.g., cd into the project directory and start an editor or service) and use select-window to bring the editor window into focus first.

What role do plugins play in tmux workflows?

Plugins can automate recurring tasks. The transcript mentions resurrect as a plugin that restores the environment after reboot. It also references a custom plugin called sessionization that supports switching between project sessions using fuzzy finding while keeping sessions alive.

How do tmux windows and panes differ in practice?

Windows are separate terminal contexts within a tmux session (each can run different commands like server, database, logs, or an editor). Panes are subdivisions within a window, created by splitting horizontally or vertically, allowing multiple views at once. The transcript notes that some users avoid splits and rely more on windows for switching.

Review Questions

Describe a recovery workflow using tmux when a terminal window closes unexpectedly.
Outline the logic of a bash script that creates or reattaches to a tmux session by name.
Give an example of how you might structure tmux windows for a multi-service project (server, database, logs, editor).

Key Points

1
tmux is a terminal multiplexer that lets users run and organize multiple terminal sessions inside one window.
2
Sessions persist even after closing the terminal window, and can be recovered with tmux ls and tmux attach.
3
Keyboard-driven navigation and a status bar make it faster to switch between sessions and windows without using a mouse.
4
tmux supports splitting panes horizontally or vertically, though some workflows rely primarily on windows.
5
tmux can be controlled via bash scripting to create sessions programmatically, initialize project directories, and start services automatically.
6
Plugins like resurrect can restore environments after reboot, and custom plugins like sessionization can improve project switching.

Highlights

Closing a terminal doesn’t kill the work: tmux keeps sessions running in the background and reattachment restores everything.

A simple bash pattern—tmux has-session to check, tmux new-session to create, then initialize windows—turns tmux into a repeatable project launcher.

Custom naming plus a status bar makes multi-service setups (server, database, logs, editors) navigable without mouse use.

Topics

tmux
Terminal Multiplexer
Session Persistence
Bash Scripting
Project Automation

Mentioned

Nicholas Marriott
WSL