If you do a lot of programming from the Linux console, you’ll certainly appreciate the power of
tmux. It is a terminal multiplexer, which means that it can create multiple virtual consoles within a single terminal shell. Since these virtual consoles are not bound to a terminal, they will keep running in the background, even if you close the terminal you started it in. This means that you can detach these consoles, and re-attach them in another terminal session.
For example, imagine you are working on some project on a development server. You log into that server over SSH from your office, create a
tmux session, and do your coding in
vim in there. Then you detach the session, and log out from the server to go home. Back at home, you log into the development server again, and re-attach the
tmux session, and you see the
vim session back where you left it. Not that I suggest you to work from home, but it is a good example of how you can continue your work or session from anywhere.
Another great thing about
tmux is that you can create multiple sessions within the same terminal window, and move between them, something like alt-tabbing between terminal windows, except it is much faster and with less visual distraction. An added bonus is that
tmux is able to subdivide the visible portion of your terminal window into parts, so you can have multiple virtual consoles, all visible within one window. Very useful if you have lots of screen estate at your command, so that you can code in
vim in one, access a MySQL console in another, and doing a
sass --watch in yet another, for example. All the information you need, everything visible in the same window, for optimal productivity.
tmux on Ubuntu, just
$ sudo apt-get install tmux
On MacOSX, get it from
$ sudo brew install tmux
Terminal multiplexers have a command mode in which you can tell it to do something, such as switching virtual consoles or creating new ones. In
tmux the short-cut key to this command mode, called the prefix, is by default
Ctrl-b, but because I come from
screen, another terminal multiplexer, where it is
Ctrl-a, I have the following in my
# Set the prefix to ^A unbind C-b set -g prefix ^A # So that you can go to the beginning of the line with ^A a bind a send-prefix
Ctrl-a is in my opinion also easier to reach than
However, on the command line,
Ctrl-a is also a short-cut for going to the beginning of the line. You can still do that: just hit
Ctrl-a a. That is what the last line in the configuration snippet tells
tmux what to do when
a is hit in command mode, i.e. send the prefix to the shell.
I will use
Ctrl-a as the prefix key in the rest of this article. It will be shown as
Now that you are ready to use
tmux, start it up. I make it a habit to give each
tmux session a name, so that I can easily re-attach it by using the name:
$ tmux new -s coding
In this example, I have called the
tmux session “coding”.
By default, it will look like this:
You can see the name of the
tmux session in the bottom left. Then you see that there is one virtual console session running
bash. In the bottom right, you see the hostname, time and date. This status bar can easily be configured to allow for a lot of variations. We will come back to the
tmux configuration file later, but for the status bar I’ll have to refer you to the man-pages.
First, let’s create some virtual consoles. Hit
^A c. In the status bar, you’ll see that you have created another virtual console, with
bash running in it. The
* means that that one is currently shown. Start
vim or your favourite editor.
See that the currently run process is
vim in the status bar?
To switch to the other window, hit
^A p (or
^A n). These letters stand for previous console and next console. As you see, it cycles through the list of consoles, so if you are at the last one in the list, and you do
^A n it will go to the first one.
Let’s create split windows. A vertical split is done with
^A % and a horizontal split with
^A ". Personally, these key-bindings do not make any sense, so we will change these later on. To navigate through these split windows, just use
^A and the arrow keys. If you have different programs running in these split windows, you will notice the status bar changing to show you the process name running in the split window you have navigated to.
You can still use
^A n and
^A p to go to the non-visible consoles.
Resizing the split windows is also easy with arrow keys. Hit
^A and while keeping the Ctrl key pressed, use the arrow keys to resize the currently focused split window.
Detaching and reattaching
Let’s try detaching the
tmux session. You can do that with
^A d, the
d stands for detach. To view a list of
tmux sessions running on the computer, do this:
$ tmux list-sessions
list-sessions command can be shortened to
$ tmux ls
You will see your
tmux session listed, with the name you gave it. To re-attach it, simply do:
$ tmux attach -t coding
where “coding” was the name of my
You can actually attach your
tmux session to multiple terminal windows. There are interesting possibilities here: you could have a mentoring session sharing your
tmux session with other programmers, or have some kind of pair programming where the programmers would be communicating by Skype or chat, and working in the same
Notice that the size of the
tmux windows are the same, and it is restricted to the smallest of the terminal sessions. The smaller one here is the top-right one, and you see the boundaries in the bottom-left one.
Here is where the
tmux attach -d option comes in play. The
-d option tells
tmux to detach that session from any other clients it is currently attached to.
There are so many things you can customize in
tmux and for the full list of options, I refer you to its man-page, or the many resources online. But let me list here how you can change the bind keys for split window creation. Personally, I find the
| (the pipe) and the
- (the dash) more logical for creating vertical and horizontal splits respectively. You can change the bindings by putting the following in your
unbind | bind | split-window unbind - bind - split-window -h
When you are going to configure your
.tmux.conf file to your liking, it will be nice to have a short-cut for reloading the
.tmux.conf configuration. Put the following in your
bind R source-file ~/.tmux.conf \; display-message "Config reloaded..."
Then start your
tmux session, and edit your
.tmux.conf inside that session. Now, whenever you change the configuration, you can do a
^A R (that is,
Ctrl-a Shift-r) to reload the configuration and see the effects of your changes directly!
You can even create different
tmux configuration files, and pass them to
tmux -f to pre-populate your
tmux session with extra sessions, split windows, pre-run programs, etc.
tmux terminal multiplexer is an awesome little tool that is certainly a must-have for every Linux/Unix/MacOSX programmer or system administrator. You can make such a good use of your screen estate by having one terminal window maximized, and populate it with split windows and hidden consoles you can easily navigate to quickly. If you are using
tmux, tell us about your favourite