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?

It’s a “terminal multiplexer”, i.e. you can start multiple terminals in a single terminal.

You might ask, why not open a new terminal window or tab? Well, you can only do that in a desktop environment and that’s not always available. Even if you can, you might want the terminals to be side by side in a single screen, which might not be easy to do with window tiling.

The real power of tmux, though, is that it manages the session you created. To quote from the manual:

tmux may be detached from a screen and continue running in the background, then later reattached.

So, one use case would be saving your current terminal setup. Instead of exiting the terminal and navigating to the project and setting up the environment again next time, you can simply detach and re-attach.

When connecting to a remote server, this is especially useful:

Each session is persistent and will survive accidental disconnection (such as ssh(1) connection timeout) or intentional detaching

Suppose you want to execute a long running command on a remote server. If you just put it to foreground, when you exit the ssh session, the job is also killed. If you put it to the background, its output can’t be easily observed.

With tmux, you can simply run it in the foreground like normal and detach. When you reattach later, the job is running and you get all the output easily, as if you have been in that session all along.

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.

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.

I created a tmux tutorial here -> https://lemmy.run/post/46783

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.

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.

Probably somebody can provide a better answer, but for me tmux is useful due that it has session manager (really useful if your remote connection drops) and the ability to split the screen in multiple screens (usually I split vertical, but you can create easily 4x4 screen).

The only trick is the learning curve of the actions (usually ctrl + b and the key required). For example to split the window vertical, you must do ctrl + b and then %.

But as I said, probably you will get better and more technical answers ^_U

EDIT: some grammar mistakes.

tmux (and GNU screen, its older predecessor) is a terminal multiplexer, which is a fancy phrase used to describe turning one terminal window into multiple terminal windows. It basically turns a single terminal window into a text-based tiling window manager that lets you run different shells concurrently in a single terminal, easily copy text between them, and have other quality of life improvements over using a single raw terminal.

Imagine you’re SSH’d into a remote machine. Unless you SSH again from a different terminal at the same time, you’re basically limited to a single terminal, and whatever you’re doing is interrupted if your connection drops. tmux runs on the remote machine, which means that if your connection is interrupted, tmux will continue running exactly as you left it, and you’ll be able to reattach to it using tmux attach.

Or, imagine your video drivers break and you’re forced to troubleshoot in a raw TTY. tmux will let you have a manpage and a shell open at the same time, or three different directories opened side by side. That’s a slightly more convoluted use case, but the point is that terminal multiplexers make it far more convenient to use the terminal in basically any situation that’s not just running a single short command and leaving.

What if we put a terminal in your terminal, so you could terminal while you terminal?

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 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.

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.