Getting to know the tmux terminal multiplexer
First, let's introduce some nomenclature:
A terminal is a (typically) graphical application that provides an interface to input text (typically through the keyboard) and display the outputs (typically a grid of characters in a graphical window, managed by the operating system windowing manager).
The shell runs inside the terminal. The shell is a much simpler non-graphical application. It accepts an input text stream (sequence of characters) and outputs a text stream (also, a sequence of characters). The shell typically runs a Read-Eval-Print-Loop (REPL) execution loop.
Common examples of shells are bash, zsh and PowerShell.
For example, consider the following shell session:
$ ls a b c d
The shell initially outputted the string "$ ", which is the prompt, and awaited for the user's command. The user entered “ls” and pressed enter. As each of the keys was pressed, the shell echoed back “l” then “s”, as to provide feedback.
Finally, the shell processed the text of the command, resolved which executable is “ls”, asked the operating system to run it, then piped forward whathever “ls” outputted.
tmux stands for terminal multiplexer, but could also be understood as a command line-based terminal that allows shell multiplexing.
More concretely, it allows creating and managing multiple shell instances through a single text input/output stream.
“Why do that?”, one may ask.
For the local machine indeed there's little use for doing so. It's much easier to have multiple graphical terminal instances (or tabs in a single terminal), each running its own shell session. Managing multiplexing is much more conveniently done in the graphical environment.
But using tmux can be useful for remote ssh sessions for a few reasons. First, a graphical interface isn't available.
Second, it is inconvenient to start an additional ssh connection for every long-running process you plan to run in the remote machine.
Third, when (intentional or unintentional) disconnection occurs, a bare ssh session can't be reconnected, making it hard to manage or comunicate with a process initiated previously.
tmux to the rescue!
What tmux does is to provide a virtual terminal where: 1) multiple shell sessions can keep running concurrently; and 2) another shell session might “attach” and talk to it and then “detach”, all without stopping the execution of the tmux-managed processes.
In more practical terms, one can use ssh to connect to a remote machine, start a tmux session there, start an HTTP server inside the tmux terminal, then detach from the tmux session and terminate the ssh session, all while keeping the HTTP server running.
Later, another (or the same) ssh session can reattach to the same tmux session and manage that HTTP server.
By and large, tmux allows decoupling the user-interactive shell session from the underlying program execution, which is useful for long-running processes, background processes, service-based applications, and so on.