To understand why you might want to use tmux try the following:

1. Open your terminal
2. Start editing a file with vim or nano but don’t save the file
3. Close then re-open your terminal

You will have lost your progress, next we can repeat but this time using tmux so you don’t lose your session:

1. Open your terminal
2. Start a tmux session using tmux
3. Start editing a file again using vim or nano
4. Close and re-open the terminal
5. Type tmux a to re-attach to the existing session

Note that this time none of your progress is lost.

Aside from enabling you to have a persistent session, tmux also allows you to have multiple terminal panes open so you can do more than one thing at a time in the window, to see what I mean try this:

1. Open your terminal
2. Start a new tmux session using tmux
3. Type top to begin listing processes
4. Press ctrl b then % to make a new split pane
5. Enter ls or other terminal commands

You will see that you can use more than one panel to do things. This can be useful for example if you want to watch run tests and also run other commands.

I guess the best analogy is a “virtual desktop” but for the terminal.
It’s is a program which runs in a terminal and allows multiple other terminal programs to be run inside it.

Each program inside tmux gets its own “page” or “screen” and you can jump between them (next-screen, previous-screen etc).
So instead of having multiple terminal windows, you only have one and switch the screen/page inside it.

You can detech from the program and leave it running - so next time you log on to the server, you can re-attach to it and all your screens/sessions are still there.

Not super useful on your local machine - but when you have to connect to a remote server (or several) is really shines. Especially if you have to go through a jumphost. You can just connect to your jumphost, start tmux, then create a “screen” for each server you need to connect to - do your stuff and deattach. Next time, just re-attach and all your stuff is there.

Did that help?

You’ve gotten a lot of good replies, so I’ll give you an example:

My wife and I set up a Minecraft server on an old work computer of hers. We would SSH in, start the server, and play. However, if the host lost the SSH session, the entire server would crash because the session would close.

With tmux, we could attach, start the server, and unattach. I could start the server and later my wife could attach to close it. I could SSH on my phone via iSH, attach, start the server, unattach, and close the app. We could troubleshoot mods together, since we could both see everything that happened in the session on our screens.

It offered a level of flexibility a traditional SSH session doesn’t give.

People have already made lots of good replies but here’s my summary:

tmux is a terminal multiplexer. It allows multitasking in command line only environments. For example if you have to do a sudo apt upgrade but don’t want to leave your ssh client logged in until it finishes, you can run it in a tmux session so it will happen in the background even if you’re not logged in.

To start a new session, type “tmux”

To view running sessions, type “tmux list-sessions”

To switch to a running session, type “tmux attach-session -c N” where N is the number of the session.

To exit a tmux terminal and go back to the main terminal, do ctrl+b and then press d.

Tmux is essentially an extension of the concept of running ideas in the background. Like 0xtero mentioned, you use a sort of “virtual terminal” that is persistent (unlike the jobs system you might be familiar with on your shell).

Now, some people do just use it to split the screen. The idea is it can have multiple terminals, show them, and manage them - it is thus a “multiplexer”, which is where it gets its name (tmux = terminal multiplexer). If you’re on a terminal-only system, this isn’t that bad of a usage.

Say you’re compiling a large program, like the Linux kernel, and you want to step away, maybe even close the terminal and come back later. Tmux is great for this. You can start the compile in tmux, “detach” (stop viewing it) from it, and it’ll still run full-speed in the background. When you want to look at it again, or check the status, you just re-attach.

Decoupling the terminal from the shell also means you can keep your shell open while closing your terminal window. This can be useful on servers, or for long running commands that you want to be able to check on.

Ok, just to clarify, my original struggle was to understand what made tmux different from using some terminal app and just split the screen xD

Not every terminal emulator has window splitting capabilities. Some, like Alacritty, specifically expect you to run a program like tmux if you want this functionality. Splitting within tmux also makes it vastly easier to multitask on a remote host via SSH: if you run a remote tmux, every split window is already running on the same remote host, no need to log in again and again.

Tmux is no different from a terminal app that split the screen in terms of “multi window” functionality. However it’s not a graphical software, so you can start it remotely (eg. over ssh), and detach/reattach to it later without loosing what you where doing.

I didn’t see this mentioned, but by far the thing I depend on tmux for the most is being able to quickly copy and paste text from the terminal. e.g. grabbing a file name from the output of git diff. How does everyone else do this?

Another cool one is being able to attach to a session on my phone to check on something, and have it automatically resize without disconnecting my desktop.

Well, not knowing what other explanations you’ve read but don’t understand/grasp makes it a bit difficult to narrow down specifics, though to start from the beginning, tmux is a terminal multiplexer, what that means is that it will allow multiple sessions running concurrently under the same virtual terminal. It provides keyboard shortcuts to switch between them, or split them and display them concurrently.

The biggest use case for me however (though I use an older one called screen out of hard to shake habits) is the ability to detach and attach at will, so that any disconnected remote sessions won’t kill whatever I happen to be working on. Alternatively, I can have running sessions locally on my current machine and then I can go elsewhere and remote in and resume from where I’ve left off.

A somewhat frowned upon use case is to use it to run “background” processes on a remote server - like a development web service that you just can’t be bothered to properly package/daemonize - just open screen or tmux, start it, and detach the session and it should stay running barring any other problems.

The most common use case for tmux is to put long running terminal apps in the background when working remotely, e.g.:

# start a new virtual terminal
tmux

# do something in the terminal that will take a long while to complete
sleep 1m

# put the virtual terminal into the background
Ctrl-b d

# do other stuff

# reattach to the virtual terminal
tmux a

This allows you to disconnect from the server, but keep the process running in the background. It can also do split screen with multiple terminals, provide a scroll back buffer (Ctrl-b PageUp) and other stuff. But using it for background processes is probably the most common one.