Linux

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.

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.

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 created a tmux tutorial here -> https://lemmy.run/post/46783

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

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.

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.

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

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.

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.

Have you ever seen someone use a tiling window manager instead of a desktop environment? Where it keeps all the currently running apps on screen in evenly sized tiles so you can see everything at once, nothing is in the "background?"

Tmux is a bit like that, but only for the terminal. It allows you to open multiple terminals in one "screen" or terminal emulator window, and switch between them with keyboard shortcuts. So if you want to look at your source code, test run your source code, and watch htop to see how it performs, you can do that with Tmux. It's a bit less cumbersome than opening three terminal windows.

It also works over SSH, so you can SSH into a server or something, start tmux, then easily run several tools simultaneously.

Tmux sessions are also persistent. Imagine if you were in the middle of working on something on your desktop at the office, then it's time to go home. You can detach your session, SSH into the box from your laptop, reattach that session and keep working right where you left off.

If you work in the terminal a lot, it's a handy tool.

It's a "terminal inside your terminal" that you can cut into tiny little pieces where programs are run in said little pieces.

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.

In the company I work, we have to use jumpbox + "password" from proprietary code generator.

Imagine going through this, then you suddenly need 2nd terminal. Inconvenience doing it again in another terminal?

Well, there is a solution:

1. tmux
2. CTRL+B then ". And now you have 2 terminals.

Also tmux is great for "quick solution" kind of things - to leave something running in the background. Talking about background - you can have many terminals open, from only 1 SSH session. :)

it's just a terminal session you can hide.