man tmux Command

Man page for apt-get tmux Command

Man Page for tmux in Linux

Ubuntu Man Command : man tmux

Man Tmux  Command

This tutorial shows the man page for man tmux in linux.

Open terminal with 'su' access and type the command as shown below:
man tmux

Result of the Command Execution shown below:

TMUX(1)                   BSD General Commands Manual                  TMUX(1)

tmux terminal multiplexer

tmux [ 28lquv] [ c shell command] [ f file] [ L socket name]
[ S socket path] [command [flags]]

tmux is a terminal multiplexer: it enables a number of terminals to be
created, accessed, and controlled from a single screen. tmux may be
detached from a screen and continue running in the background, then later

When tmux is started it creates a new session with a single window and
displays it on screen. A status line at the bottom of the screen shows
information on the current session and is used to enter interactive com

A session is a single collection of pseudo terminals under the management
of tmux. Each session has one or more windows linked to it. A window
occupies the entire screen and may be split into rectangular panes, each
of which is a separate pseudo terminal (the pty(4) manual page documents
the technical details of pseudo terminals). Any number of tmux instances
may connect to the same session, and any number of windows may be present
in the same session. Once all sessions are killed, tmux exits.

Each session is persistent and will survive accidental disconnection
(such as ssh(1) connection timeout) or intentional detaching (with the
'C b d' key strokes). tmux may be reattached using:

$ tmux attach

In tmux, a session is displayed on screen by a client and all sessions
are managed by a single server. The server and each client are separate
processes which communicate through a socket in /tmp.

The options are as follows:

2 Force tmux to assume the terminal supports 256 colours.

8 Like 2, but indicates that the terminal supports 88

c shell command
Execute shell command using the default shell. If neces
sary, the tmux server will be started to retrieve the
default shell option.

f file Specify an alternative configuration file. By default,
tmux loads the system configuration file from
/etc/tmux.conf, if present, then looks for a user configu
ration file at ~/.tmux.conf. The configuration file is a
set of tmux commands which are executed in sequence when
the server is first started.

If a command in the configuration file fails, tmux will
report an error and exit without executing further com

l Behave as a login shell. This flag currently has no effect
and is for compatibility with other shells when using tmux
as a login shell.

L socket name
tmux stores the server socket in a directory under /tmp;
the default socket is named default. This option allows a
different socket name to be specified, allowing several
independent tmux servers to be run. Unlike S a full path
is not necessary: the sockets are all created in the same

If the socket is accidentally removed, the SIGUSR1 signal
may be sent to the tmux server process to recreate it.

q Prevent the server sending various informational messages,
for example when window flags are altered.

S socket path
Specify a full alternative path to the server socket. If
S is specified, the default socket directory is not used
and any L flag is ignored.

u tmux attempts to guess if the terminal is likely to support
UTF 8 by checking the first of the LC_ALL, LC_CTYPE and
LANG environment variables to be set for the string
"UTF 8". This is not always correct: the u flag explic
itly informs tmux that UTF 8 is supported.

If the server is started from a client passed u or where
UTF 8 is detected, the utf8 and status utf8 options are
enabled in the global window and session options respec

v Request verbose logging. This option may be specified mul
tiple times for increasing verbosity. Log messages will be
saved into tmux client PID.log and tmux server PID.log
files in the current directory, where PID is the PID of the
server or client process.

command [flags]
This specifies one of a set of commands used to control
tmux, as described in the following sections. If no com
mands are specified, the new session command is assumed.

tmux may be controlled from an attached client by using a key combination
of a prefix key, 'C b' (Ctrl b) by default, followed by a command key.

Some of the default key bindings are:

c Create a new window.
d Detach the current client.
l Move to the previously selected window.
n Change to the next window.
p Change to the previous window.
& Kill the current window.
, Rename the current window.
? List all key bindings.

A complete list may be obtained with the list keys command (bound to '?'
by default). Key bindings may be changed with the bind key and
unbind key commands.

This section contains a list of the commands supported by tmux. Most
commands accept the optional t argument with one of target client,
target session target window, or target pane. These specify the client,
session, window or pane which a command should affect. target client is
the name of the pty(4) file to which the client is connected, for example
either of /dev/ttyp1 or ttyp1 for the client attached to /dev/ttyp1. If
no client is specified, the current client is chosen, if possible, or an
error is reported. Clients may be listed with the list clients command.

target session is either the name of a session (as listed by the
list sessions command) or the name of a client with the same syntax as
target client, in which case the session attached to the client is used.
When looking for the session name, tmux initially searches for an exact
match; if none is found, the session names are checked for any for which
target session is a prefix or for which it matches as an fnmatch(3) pat
tern. If a single match is found, it is used as the target session; mul
tiple matches produce an error. If a session is omitted, the current
session is used if available; if no current session is available, the
most recently used is chosen.

target window specifies a window in the form session:window. session
follows the same rules as for target session, and window is looked for in
order: as a window index, for example mysession:1; as an exact window
name, such as mysession:mywindow; then as an fnmatch(3) pattern or the
start of a window name, such as mysession:mywin* or mysession:mywin. An
empty window name specifies the next unused index if appropriate (for
example the new window and link window commands) otherwise the current
window in session is chosen. When the argument does not contain a colon,
tmux first attempts to parse it as window; if that fails, an attempt is
made to match a session.

target pane takes a similar form to target window but with the optional
addition of a period followed by a pane index, for example: myses
sion:mywindow.1. If the pane index is omitted, the currently active pane
in the specified window is used. If neither a colon nor period appears,
tmux first attempts to use the argument as a pane index; if that fails,
it is looked up as for target window.

Multiple commands may be specified together as part of a command
sequence. Each command should be separated by spaces and a semicolon;
commands are executed sequentially from left to right. A literal semi
colon may be included by escaping it with a backslash (for example, when
specifying a command sequence to bind key).

Examples include:

refresh client t/dev/ttyp2

rename session tfirst newname

set window option t:0 monitor activity on

new window ; split window d

The following commands are available:

attach session [ d] [ t target session]
(alias: attach)
If run from outside tmux, create a new client in the current ter
minal and attach it to target session. If used from inside,
switch the current client. If d is specified, any other clients
attached to the session are detached.

If no server is started, attach session will attempt to start it;
this will fail unless sessions are created in the configuration

detach client [ t target client]
(alias: detach)
Detach the current client if bound to a key, or the specified
client with t.

has session [ t target session]
(alias: has)
Report an error and exit with 1 if the specified session does not
exist. If it does exist, exit with 0.

kill server
Kill the tmux server and clients and destroy all sessions.

kill session [ t target session]
Destroy the given session, closing any windows linked to it and
no other sessions, and detaching all clients attached to it.

list clients
(alias: lsc)
List all clients attached to the server.

list commands
(alias: lscm)
List the syntax of all commands supported by tmux.

list sessions
(alias: ls)
List all sessions managed by the server.

lock client [ t target client]
Lock target client, see the lock server command.

lock session [ t target session]
Lock all clients attached to target session.

new session [ d] [ n window name] [ s session name] [ t target session]
(alias: new)
Create a new session with name session name. The new session is
attached to the current terminal unless d is given. window name
and command are the name of and command to execute in the initial

If run from a terminal, any termios(4) special characters are
saved and used for new windows in the new session.

If t is given, the new session is grouped with target session.
This means they share the same set of windows all windows from
target session are linked to the new session and any subsequent
new windows or windows being closed are applied to both sessions.
The current and previous window and any session options remain
independent and either session may be killed without affecting
the other. Giving n or command are invalid if t is used.

refresh client [ t target client]
(alias: refresh)
Refresh the current client if bound to a key, or a single client
if one is given with t.

rename session [ t target session] new name
(alias: rename)
Rename the session to new name.

source file path
(alias: source)
Execute commands from path.

start server
(alias: start)
Start the tmux server, if not already running, without creating
any sessions.

suspend client [ c target client]
(alias: suspendc)
Suspend a client by sending SIGTSTP (tty stop).

switch client [ c target client] [ t target session]
(alias: switchc)
Switch the current session for client target client to
target session.

A tmux window may be in one of several modes. The default permits direct
access to the terminal attached to the window. The others are:

output mode
This is entered when a command which produces output, such as
list keys, is executed from a key binding.

copy mode
This permits a section of a window or its history to be copied to
a paste buffer for later insertion into another window. This
mode is entered with the copy mode command, bound to '[' by

The keys available depend on whether emacs or vi mode is selected (see
the mode keys option). The following keys are supported as appropriate
for the mode:

Function vi emacs
Back to indentation ^ M m
Clear selection Escape C g
Copy selection Enter M w
Cursor down j Down
Cursor left h Left
Cursor right l Right
Cursor to bottom line L
Cursor to middle line M M r
Cursor to top line H M R
Cursor up k Up
Delete entire line d C u
Delete to end of line D C k
End of line $ C e
Goto line : g
Half page down C d M Down
Half page up C u M Up
Next page C f Page down
Next word w M f
Paste buffer p C y
Previous page C b Page up
Previous word b M b
Quit mode q Escape
Scroll down C Down or J C Down
Scroll up C Up or K C Up
Search again n n
Search backward ? C r
Search forward / C s
Start of line 0 C a
Start selection Space C Space
Transpose chars C t

These key bindings are defined in a set of named tables: vi edit and
emacs edit for keys used when line editing at the command prompt;
vi choice and emacs choice for keys used when choosing from lists (such
as produced by the window choose command) or in output mode; and vi copy
and emacs copy used in copy mode. The tables may be viewed with the
list keys command and keys modified or removed with bind key and
unbind key.

The paste buffer key pastes the first line from the top paste buffer on
the stack.

The mode commands are as follows:

copy mode [ u] [ t target pane]
Enter copy mode. The u option scrolls one page up.

Each window displayed by tmux may be split into one or more panes; each
pane takes up a certain area of the display and is a separate terminal.
A window may be split into panes using the split window command. Windows
may be split horizontally (with the h flag) or vertically. Panes may be
resized with the resize pane command (bound to 'C up', 'C down' 'C left'
and 'C right' by default), the current pane may be changed with the
up pane and down pane commands and the rotate window and swap pane com
mands may be used to swap panes without changing their position. Panes
are numbered beginning from zero in the order they are created.

A number of preset layouts are available. These may be selected with the
select layout command or cycled with next layout (bound to 'C space' by
default); once a layout is chosen, panes within it may be moved and
resized as normal.

The following layouts are supported:

even horizontal
Panes are spread out evenly from left to right across the window.

even vertical
Panes are spread evenly from top to bottom.

main horizontal
A large (main) pane is shown at the top of the window and the
remaining panes are spread from left to right in the leftover
space at the bottom. Use the main pane height window option to
specify the height of the top pane.

main vertical
Similar to main horizontal but the large pane is placed on the
left and the others spread from top to bottom along the right.
See the main pane width window option.

Commands related to windows and panes are as follows:

break pane [ d] [ t target pane]
(alias: breakp)
Break target pane off from its containing window to make it the
only pane in a new window. If d is given, the new window does
not become the current window.

choose client [ t target window] [template]
Put a window into client choice mode, allowing a client to be
selected interactively from a list. After a client is chosen,
'%%' is replaced by the client pty(4) path in template and the
result executed as a command. If template is not given, "detach
client t '%%'" is used. This command works only from inside

choose session [ t target window] [template]
Put a window into session choice mode, where a session may be
selected interactively from a list. When one is chosen, '%%' is
replaced by the session name in template and the result executed
as a command. If template is not given, "switch client t '%%'"
is used. This command works only from inside tmux.

choose window [ t target window] [template]
Put a window into window choice mode, where a window may be cho
sen interactively from a list. After a window is selected, '%%'
is replaced by the session name and window index in template and
the result executed as a command. If template is not given,
"select window t '%%'" is used. This command works only from
inside tmux.

display panes [ t target client]
(alias: displayp)
Display a visible indicator of each pane shown by target client.
See the display panes time and display panes colour session
options. While the indicator is on screen, a pane may be
selected with the '0' to '9' keys.

down pane [ t target pane]
(alias: downp)
Change the active pane to the next pane (higher index).

find window [ t target window] match string
(alias: findw)
Search for the fnmatch(3) pattern match string in window names,
titles, and visible content (but not history). If only one win
dow is matched, it'll be automatically selected, otherwise a
choice list is shown. This command only works from inside tmux.

kill pane [ a] [ t target pane]
(alias: killp)
Destroy the given pane. If no panes remain in the containing
window, it is also destroyed. The a option kills all but the
pane given with t.

kill window [ t target window]
(alias: killw)
Kill the current window or the window at target window, removing
it from any sessions to which it is linked.

last window [ t target session]
(alias: last)
Select the last (previously selected) window. If no
target session is specified, select the last window of the cur
rent session.

link window [ dk] [ s src window] [ t dst window]
(alias: linkw)
Link the window at src window to the specified dst window. If
dst window is specified and no such window exists, the src window
is linked there. If k is given and dst window exists, it is
killed, otherwise an error is generated. If d is given, the
newly linked window is not selected.

list panes [ t target window]
(alias: lsp)
List the panes in the current window or in target window.

list windows [ t target session]
(alias: lsw)
List windows in the current session or in target session.

move window [ d] [ s src window] [ t dst window]
(alias: movew)
This is similar to link window, except the window at src window
is moved to dst window.

new window [ dk] [ n window name] [ t target window] [command]
(alias: neww)
Create a new window. If d is given, the session does not make
the new window the current window. target window represents the
window to be created; if the target already exists an error is
shown, unless the k flag is used, in which case it is destroyed.
command is the command to execute. If command is not specified,
the default command is used.

The TERM environment variable must be set to ``screen'' for all
programs running inside tmux. New windows will automatically
have ``TERM=screen'' added to their environment, but care must be
taken not to reset this in shell start up files.

next layout [ t target window]
(alias: nextl)
Move a window to the next layout and rearrange the panes to fit.

next window [ a] [ t target session]
(alias: next)
Move to the next window in the session. If a is used, move to
the next window with a bell, activity or content alert.

pipe pane [ o] [ t target pane] [command]
(alias: pipep)
Pipe any output sent by the program in target pane to a shell
command. A pane may only be piped to one command at a time, any
existing pipe is closed before command is executed. If no
command is given, the current pipe (if any) is closed.

The o option only opens a new pipe if no previous pipe exists,
allowing a pipe to be toggled with a single key, for example:

bind key C p pipe pane o 'cat >>~/output'

previous window [ a] [ t target session]
(alias: prev)
Move to the previous window in the session. With a, move to the
previous window with a bell, activity or content alert.

rename window [ t target window] new name
(alias: renamew)
Rename the current window, or the window at target window if
specified, to new name.

resize pane [ DLRU] [ t target pane] [adjustment]
(alias: resizep)
Resize a pane, upward with U (the default), downward with D, to
the left with L and to the right with R. The adjustment is
given in lines or cells (the default is 1).

respawn window [ k] [ t target window] [command]
(alias: respawnw)
Reactive a window in which the command has exited (see the
remain on exit window option). If command is not given, the com
mand used when the window was created is executed. The window
must be already inactive, unless k is given, in which case any
existing command is killed.

rotate window [ DU] [ t target window]
(alias: rotatew)
Rotate the positions of the panes within a window, either upward
(numerically lower) with U or downward (numerically higher).

select layout [ t target window] [layout name]
(alias: selectl)
Choose a specific layout for a window. If layout name is not
given, the last layout used (if any) is reapplied.

select pane [ t target pane]
(alias: selectp)
Make pane target pane the active pane in window target window.

select window [ t target window]
(alias: selectw)
Select the window at target window.

split window [ dhv] [ l size | p percentage] [ t target window]
(alias: splitw)
Creates a new pane by splitting the active pane: h does a hori
zontal split and v a vertical split; if neither is specified, v
is assumed. The l and p options specify the size of the new
window in lines (for vertical split) or in cells (for horizontal
split), or as a percentage, respectively. All other options have
the same meaning as in the new window command.

swap pane [ dDU] [ s src pane] [ t dst pane]
(alias: swapp)
Swap two panes. If U is used and no source pane is specified
with s, dst pane is swapped with the previous pane (before it
numerically); D swaps with the next pane (after it numerically).

swap window [ d] [ s src window] [ t dst window]
(alias: swapw)
This is similar to link window, except the source and destination
windows are swapped. It is an error if no window exists at
src window.

unlink window [ k] [ t target window]
(alias: unlinkw)
Unlink target window. Unless k is given, a window may be
unlinked only if it is linked to multiple sessions windows may
not be linked to no sessions; if k is specified and the window
is linked to only one session, it is unlinked and destroyed.

up pane [ t target pane]
(alias: upp)
Change the active pane to the previous pane (lower index).

tmux allows a command to be bound to most keys, with or without a prefix
key. When specifying keys, most represent themselves (for example 'A' to
'Z'). Ctrl keys may be prefixed with 'C ' or '^', and Alt (meta) with
'M '. In addition, the following special key names are accepted: BSpace,
BTab, DC (Delete), End, Enter, Escape, F1 to F20, Home, IC (Insert),
NPage (Page Up), PPage (Page Down), Space, and Tab. Note that to bind
the '"' or ''' keys, quotation marks are necessary, for example:

bind key '"' split window
bind key "'" select prompt

Commands related to key bindings are as follows:

bind key [ cnr] [ t key table] key command [arguments]
(alias: bind)
Bind key key to command. By default (without t) the primary key
bindings are modified (those normally activated with the prefix
key); in this case, if n is specified, it is not necessary to
use the prefix key, command is bound to key alone. The r flag
indicates this key may repeat, see the repeat time option.

If t is present, key is bound in key table: the binding for com
mand mode with c or for normal mode without. To view the
default bindings and possible commands, see the list keys com

list keys [ t key table]
(alias: lsk)
List all key bindings. Without t the primary key bindings
those executed when preceded by the prefix key are printed.
Keys bound without the prefix key (see bind key n) are enclosed
in square brackets.

With t, the key bindings in key table are listed; this may be
one of: vi edit, emacs edit, vi choice, emacs choice, vi copy or
emacs copy.

send keys [ t target pane] key ...
(alias: send)
Send a key or keys to a window. Each argument key is the name of
the key (such as 'C a' or 'npage' ) to send; if the string is not
recognised as a key, it is sent as a series of characters. All
arguments are sent sequentially from first to last.

send prefix [ t target pane]
Send the prefix key to a window as if it was pressed. If multi
ple prefix keys are configured, only the first is sent.

unbind key [ cn] [ t key table] key
(alias: unbind)
Unbind the command bound to key. Without t the primary key
bindings are modified; in this case, if n is specified, the com
mand bound to key without a prefix (if any) is removed.

If t is present, key in key table is unbound: the binding for
command mode with c or for normal mode without.

The appearance and behaviour of tmux may be modified by changing the
value of various options. There are two types of option: session options
and window options.

Each individual session may have a set of session options, and there is a
separate set of global session options. Sessions which do not have a
particular option configured inherit the value from the global session
options. Session options are set or unset with the set option command
and may be listed with the show options command. The available session
options are listed under the set option command.

Similarly, a set of window options is attached to each window, and there
is a set of global window options from which any unset options are inher
ited. Window options are altered with the set window option command and
can be listed with the show window options command. All window options
are documented with the set window option command.

Commands which set options are as follows:

set option [ agu] [ t target session] option value
(alias: set)
Set a session option. With a, and if the option expects a
string, value is appended to the existing setting. If g is
specified, the global session option is set. The u flag unsets
an option, so a session inherits the option from the global
options it is not possible to unset a global option.

Available session options are:

base index index
Set the base index from which an unused index should be
searched when a new window is created. The default is

bell action [any | none | current]
Set action on window bell. any means a bell in any win
dow linked to a session causes a bell in the current win
dow of that session, none means all bells are ignored and
current means only bell in windows other than the current
window are ignored.

buffer limit number
Set the number of buffers kept for each session; as new
buffers are added to the top of the stack, old ones are
removed from the bottom if necessary to maintain this
maximum length.

default command command
Set the command used for new windows (if not specified
when the window is created) to command, which may be any
sh(1) command. The default is an empty string, which
instructs tmux to create a login shell using the value of

Related Topics

Apt Get Commands