[tmux.app]
tmux 3.8

Compare · Screen 4.9.1 and 5.0 vs tmux 3.8

GNU Screen vs tmux: comparison and migration guide

GNU Screen and tmux do the same core job: keep shells running after you disconnect, and let you reattach later. tmux adds a single scriptable server for all sessions, panes that are part of the session rather than the display, floating panes, hooks and formats. Screen is smaller, starts faster, and still opens serial lines. Moving over takes about ten minutes: the tables below translate every default key, command and .screenrc line, and every tmux line was run on tmux 3.8.

Updated Tested on tmux 3.812 min read

On this page
  1. Feature matrix: Screen 4.9, Screen 5.0 and tmux 3.8
  2. Key binding translation table
  3. Command-line equivalents
  4. Use Screen's Ctrl+a prefix in tmux
  5. .screenrc to .tmux.conf: directive mapping
  6. Sharing a session: screen -x and multiuser vs tmux sockets
  7. Architecture: one server vs one process per session
  8. Benchmarks: memory, startup and throughput (measured)
  9. What changed in GNU Screen 5.0
  10. When GNU Screen is still the right tool
  11. Migration checklist: from Screen to tmux
  12. FAQ: GNU Screen vs tmux

Quick answer

What is the difference between GNU Screen and tmux?

  • Keys: Screen's prefix is Ctrl+a, tmux's is Ctrl+b. Most keys after it differ too (table), and four lines in ~/.tmux.conf give you Ctrl+a in tmux.
  • Commands: screen -S x → tmux new -s x, screen -ls → tmux ls, screen -r x → tmux attach -t x (all).
  • Design: tmux runs one server for all your sessions; Screen runs one process per session. Split panes are saved with a tmux session; Screen's split regions belong to the terminal you are attached from (details).
  • Measured on one machine: 40 shells in 10 sessions took 1.6 MB (PSS) in tmux 3.8 and 11.6 MB in Screen; Screen reached a prompt in 10 ms vs 29 ms for tmux; tmux 3.8 printed a 32 MiB file in half Screen's time (benchmarks).

Feature matrix: Screen 4.9, Screen 5.0 and tmux 3.8

Screen 4.9.1 is what Debian 13 and Ubuntu 24.04 install today; 5.0.2 (July 2026) is the latest upstream release and is what Homebrew and Debian testing ship. The table separates them where they differ.

FeatureGNU Screen 4.9.1GNU Screen 5.0.2tmux 3.8
Detach and reattachYesYesYes
Process modelOne process per sessionOne process per sessionOne server for all sessions
Split screenRegions, belong to the displayRegions, belong to the displayPanes, saved with the window
Floating panes, popupsNoNoYes (popups 3.2, floating panes 3.7)
Several clients, different windowsYes (screen -x, per display)YesYes (plus grouped sessions)
24-bit colorNo (256 colors)truecolor onYes (RGB terminal feature)
Type into several windows at onceNomultiinputsynchronize-panes
Default scrollback100 lines100 lines2,000 lines
Scripting-X commands, -Q queries-X, -Q92 commands, formats, hooks, control mode
Mousemousetrack (select region)mousetrackOn by default in 3.8: select, resize, scroll
Serial lines (/dev/ttyUSB0)Built inBuilt inRun picocom or cu in a pane
Share with another Unix usermultiuser, needs setuid rootSame, plus auth passwordsSocket permissions + server-access (3.3+)
PluginsNoneNoneTPM and shell plugins
LicenseGPL-3.0GPL-3.0ISC

Sources: our tests of Screen 4.9.1 and tmux 3.8; Screen 5.0 changes from the 5.0.0 release announcement (August 2024) and the GNU Screen manual; package versions from packages.debian.org and formulae.brew.sh, checked October 29, 2026.

Real screenshot · GNU Screen 4.09.01GNU Screen with two split regions: screen -ls in the top region, ps showing two SCREEN processes in the bottom region
GNU Screen 4.09.01 split into two regions with Ctrl+a S. Each session (work, api) is its own SCREEN process, which ps shows in the lower region.
How this was captured

Captured 2026-10-29 05:17 UTC from a real xterm window running GNU Screen 4.09.01 on Ubuntu 24.04. Nothing is mocked up. The commands that set up the screen:

screen -dmS work
screen -dmS api
screen -S work -X screen -t logs
(in the xterm) screen -r work
screen -S work -X select 0
screen -S work -X split
screen -S work -X focus
screen -S work -X select 1
screen -S work -p 0 -X stuff 'screen -ls\n'
screen -S work -p 1 -X stuff 'ps -C screen,SCREEN -o pid,args\n'
Real screenshot · tmux 3.8tmux 3.8 with two panes: tmux ls in the top pane, ps showing one tmux server with three bash children in the bottom pane
tmux 3.8 with the same two sessions: one tmux server process, and every shell in every session is its child.
How this was captured

Captured 2026-10-29 05:18 UTC from a real xterm window running tmux 3.8 on Ubuntu 24.04. Nothing is mocked up. The commands that set up the screen:

tmux new-session -d -s work -x 100 -y 25
tmux new-session -d -s api
tmux split-window -v -t work
tmux send-keys -t work:0.0 'clear; tmux ls' Enter
tmux send-keys -t work:0.1 'clear; S=$(tmux display -p '"'"'#{pid}'"'"'); ps -o pid,args -p $S; ps --ppid $S -o pid,args' Enter

Key binding translation table

Left: every default Screen key that has a tmux counterpart, checked against Screen 4.9.1's own help screen (Ctrl+a ?). Right: the tmux 3.8 default. Pick Ctrl+a below and the tmux column switches to the Screen-style prefix from the next section.

Your prefix
ActionGNU Screentmux
The prefix (command key)Ctrl+aCtrl+b (configurable)
Send the prefix to the programCtrl+a aCtrl+b Ctrl+b
New windowCtrl+a cCtrl+b c
Next / previous windowCtrl+a n / Ctrl+a pCtrl+b n / Ctrl+b p
Last window (toggle)Ctrl+a Ctrl+aCtrl+b l
Window 0 to 9Ctrl+a 0 … Ctrl+a 9Ctrl+b 0 … Ctrl+b 9
Go to window by number (prompt)Ctrl+a 'Ctrl+b '
Pick a window from a listCtrl+a "Ctrl+b w
Rename windowCtrl+a ACtrl+b ,
Kill windowCtrl+a kCtrl+b &
Split top / bottomCtrl+a SCtrl+b "
Split left / rightCtrl+a |Ctrl+b %
Next region / paneCtrl+a TabCtrl+b o or Ctrl+b ↑ and the other arrows
Close the current splitCtrl+a X (window keeps running)Ctrl+b x (kills the pane) or Ctrl+b ! (moves it to its own window)
Only this splitCtrl+a QCtrl+b z (zoom, press again to restore)
Scrollback / copy modeCtrl+a [ or Ctrl+a EscCtrl+b [ (or scroll the mouse wheel)
PasteCtrl+a ]Ctrl+b ]
DetachCtrl+a dCtrl+b d
Command promptCtrl+a :Ctrl+b :
List key bindingsCtrl+a ?Ctrl+b ?
Window infoCtrl+a iCtrl+b i
Redraw the screenCtrl+a lCtrl+b r
Suspend the clientCtrl+a zCtrl+b Ctrl+z
ClockCtrl+a t (time in the message line)Ctrl+b t (big clock in the pane)
Log the window to a fileCtrl+a HNo default key: pipe-pane -o 'cat >>~/tmux.log'
Watch for activity / silenceCtrl+a M / Ctrl+a _No default key: setw monitor-activity on, setw monitor-silence 30
Lock the terminalCtrl+a xNo default key: lock-session
Quit everythingCtrl+a \No default key: tmux kill-server

The full list of tmux keys is on the cheat sheet.

Command-line equivalents

Every pair below was run on Screen 4.9.1 and tmux 3.8. In tmux, new is short for new-session and attach for attach-session.

TaskGNU Screentmux
Start a named sessionscreen -S worktmux new -s work
Start it detached, running a commandscreen -dmS work ./build.shtmux new -d -s work ./build.sh
List sessionsscreen -lstmux ls
Reattachscreen -r worktmux attach -t work
Take over a session attached elsewherescreen -d -r worktmux attach -d -t work
Attach or createscreen -D -RR worktmux new -A -s work
Join a session that is already attachedscreen -x worktmux attach -t work (any number of clients)
Type into a session from a scriptscreen -S work -X stuff 'make\n'tmux send-keys -t work 'make' Enter
New window from a scriptscreen -S work -X screen -t logstmux new-window -t work -n logs
List windowsscreen -S work -Q windowstmux list-windows -t work
Save scrollback to a filehardcopy -h file (inside Screen)tmux capture-pane -p -S - -t work > file
Log all outputscreen -Ltmux pipe-pane -o -t work 'cat >> work.log'
Kill a sessionscreen -S work -X quittmux kill-session -t work
Use another config filescreen -c filetmux -f file
Clean up dead sessionsscreen -wipeNot needed
Open a serial consolescreen /dev/ttyUSB0 115200tmux new 'picocom -b 115200 /dev/ttyUSB0'

More on sessions, including tmux ls output and naming rules, is in the sessions guide.

Use Screen's Ctrl+a prefix in tmux

Quick answer

How do I make tmux use Ctrl+a like Screen?

Add these lines to ~/.tmux.conf, then run tmux source-file ~/.tmux.conf (or start a new server):

~/.tmux.conf
# Use Ctrl+a as the prefix, like GNU Screen
unbind C-b
set -g prefix C-a
# Ctrl+a a sends a literal Ctrl+a (start of line in bash)
bind a send-prefix
# Ctrl+a Ctrl+a toggles the last window
bind C-a last-window

Want Screen's other keys too? This block adds the ones that differ, so your fingers keep working while you learn tmux. It loads without errors on tmux 3.8 and on 3.4 (Ubuntu 24.04):

~/.tmux.conf (Screen-style keys)
bind '"' choose-tree -Zw          # window list
bind A command-prompt -I "#W" { rename-window "%%" }
bind k confirm-before -p "kill-window #W? (y/n)" kill-window
bind S split-window -v            # top / bottom
bind | split-window -h            # left / right
bind Tab select-pane -t :.+       # next pane (replaces the 3.8 window switcher)
bind X kill-pane
bind Q kill-pane -a               # keep only this pane
bind Escape copy-mode
bind H pipe-pane -o 'cat >> ~/tmux-#S-#I.log' \; display 'Logging toggled'
bind '\' confirm-before -p "kill-server? (y/n)" kill-server

.screenrc to .tmux.conf: directive mapping

tmux has no .screenrc importer, but most lines translate one to one. The tmux side was loaded on tmux 3.8 and 3.4.

Goal~/.screenrc~/.tmux.conf
Change the prefixescape ^Aaset -g prefix C-a + bind a send-prefix
Scrollback lengthdefscrollback 10000set -g history-limit 10000
No splash screenstartup_message offNot needed (tmux has none)
Bellvbell offset -g visual-bell off (the default), set -g bell-action any
Status linehardstatus alwayslastline "…"set -g status-left "…", set -g status-right "…"
Per-split title barcaption always "…"setw -g pane-border-status top, setw -g pane-border-format "…"
Auto-detach on hangupautodetach onAlways on: the server keeps running
Message durationmsgwait 2set -g display-time 2000 (milliseconds)
Watch all windows for activitydefmonitor onsetw -g monitor-activity on, set -g visual-activity on
Keep a window after its program exitszombie krsetw -g remain-on-exit on
Shellshell -/bin/zshset -g default-shell /bin/zsh (tmux starts it as a login shell)
$TERM insideterm screen-256colorset -g default-terminal tmux-256color (the default since 3.x when the terminfo entry exists)
24-bit colortruecolor on (5.0+)set -as terminal-features ',xterm-256color:RGB'
UTF-8defutf8 onNot needed (always on)
Mousemousetrack onset -g mouse on (default in 3.8)
Let the terminal's own scrollbar worktermcapinfo xterm* ti@:te@set -ga terminal-overrides ',xterm*:smcup@:rmcup@'
Open windows at startscreen -t logs 1 tail -f app.lognew-window -n logs 'tail -f app.log' (or a startup script)
Bind a function keybindkey -k k1 select 1bind -n F1 select-window -t 1
Share with other usersmultiuser on, acladd bobtmux -S /path/sock server-access -a bob (below)
Window numberingStarts at 0Starts at 0; set -g base-index 1 to start at 1

A full starter config for Screen users, built from the table:

~/.tmux.conf (from a typical .screenrc)
unbind C-b
set -g prefix C-a
bind a send-prefix
bind C-a last-window
set -g history-limit 10000
set -g display-time 2000
setw -g monitor-activity on
set -g visual-activity on
set -as terminal-features ',xterm-256color:RGB'

Every option is documented on the tmux config page; the config generator builds the same thing with a preview.

Sharing a session: screen -x and multiuser vs tmux sockets

Same Unix account: both tools let a second terminal join a running session. In Screen that is screen -x work; in tmux, plain tmux attach -t work works because tmux allows any number of clients.

Different Unix accounts: Screen needs multiuser on and acladd, and its manual says joining another user's session "requires setuid-root". Ubuntu 24.04 installs /usr/bin/screen without the setuid bit (we checked: -rwxr-xr-x), so this does not work out of the box. A setuid-root Screen 5.0.0 was also the subject of the local root exploit CVE-2025-23395, fixed in 5.0.1 (May 2025). tmux needs no special privileges: the host shares a socket file and allows each guest.

host
tmux -S /tmp/pair new -d -s pair
chgrp devteam /tmp/pair && chmod g+rw /tmp/pair
tmux -S /tmp/pair server-access -a bob
guest (bob)
tmux -S /tmp/pair attach -t pair

Read-only guests, group permissions, SSH setup and tmate are covered step by step in remote pair programming with tmux.

Architecture: one server vs one process per session

The screenshots above show the difference. With two Screen sessions, ps lists two SCREEN back-end processes plus the attached front end. With the same two sessions in tmux, there is one server, and every shell in every session is its child.

  • Scripting across sessions. One tmux command reaches everything: tmux list-panes -a lists every pane in every session, and formats such as #{pane_current_command} work everywhere. In Screen you address each session separately with -S name -X.
  • Splits survive a detach. A tmux pane belongs to its window, so a four-pane layout is still there when you reattach from another computer. Screen's regions belong to the display (your terminal); they disappear on detach unless you layout save them.
  • Memory scales differently. Each Screen session is a full process. In our test, 10 sessions cost 11.6 MB in Screen and 1.6 MB in one tmux server (both PSS; see below).
  • Blast radius. The flip side: if the tmux server crashes or is killed, every session goes with it. A Screen crash takes one session.

Several clients can view one tmux session at the same time; since tmux 3.1 a window is sized to the most recently active client (window-size latest) instead of the smallest. To let two people look at different windows of the same session, create a grouped session: tmux new -t work -s work2.

Benchmarks: memory, startup and throughput (measured)

We measured tmux 3.8, tmux 3.4 and GNU Screen 4.9.1 on the same Linux machine, nine runs each, and report the median. Short version: Screen is lighter for a single session and starts faster; tmux is far lighter once you have several sessions, and tmux 3.8 is the fastest at pushing large output through. All of these differences are small next to the programs you run inside them.

Memory for 10 sessions × 4 shellsTotal PSS of all multiplexer processes, MB (lower is better)

tmux: 1 server process. Screen: 10 SCREEN processes, 30.5 MB if you add up their RSS. Source: tmux.app benchmark, 2026-10-28, median of 9 runs

Show the data
ToolPSS (MB)
tmux 3.81.6 MB
tmux 3.42.6 MB
GNU Screen 4.9.111.6 MB
Memory with 10,000 lines of scrollbackServer RSS after 20,000 lines of output, MB (lower is better)

history-limit 10000 (tmux) and defscrollback 10000 (Screen). Screen reserves its scrollback up front. Source: tmux.app benchmark, 2026-10-28, median of 9 runs

Show the data
ToolRSS (MB)
GNU Screen 4.9.14.3 MB
tmux 3.810.6 MB
tmux 3.428.4 MB
Time to a usable sessionFrom starting the client to the shell prompt on screen, ms (lower is better)

No server running beforehand; includes starting the server and the shell. Source: tmux.app benchmark, 2026-10-28, median of 9 runs

Show the data
ToolMilliseconds
GNU Screen 4.9.19.8 ms
tmux 3.425.1 ms
tmux 3.828.7 ms
Time to cat a 32 MiB text fileWall time until the last line is on screen, seconds (lower is better)

Inside an attached 120×40 session. "No multiplexer" is the same shell in the same pty. Source: tmux.app benchmark, 2026-10-28, median of 9 runs

Show the data
ToolSeconds
No multiplexer0.57 s
tmux 3.82.47 s
GNU Screen 4.9.15.15 s
tmux 3.46 s

All results

Medians of 9 runs, with the fastest and slowest run underneath. "No multiplexer" only applies to the cat test.

Measurement (median)tmux 3.8tmux 3.4GNU Screen 4.9.1No multiplexer
Server memory, 1 attached session (RSS)4.4 MB4.4 MB – 4.5 MB4.4 MB4.4 MB – 4.5 MB2.7 MB2.7 MB – 2.7 MB–
Server memory, 1 attached session (PSS)1.8 MB1.7 MB – 1.9 MB1.9 MB1.5 MB – 2.0 MB0.8 MB0.8 MB – 0.9 MB–
Client memory, attached (RSS)4.0 MB4.0 MB – 4.1 MB5.0 MB4.9 MB – 5.0 MB3.1 MB3.0 MB – 3.1 MB–
10 sessions × 4 shells, all servers (RSS)3.9 MB3.9 MB – 4.0 MB4.4 MB4.3 MB – 4.4 MB30.5 MB30.5 MB – 30.5 MB–
10 sessions × 4 shells, all servers (PSS)1.6 MB1.5 MB – 1.6 MB2.6 MB2.5 MB – 2.6 MB11.6 MB11.6 MB – 11.7 MB–
Server processes for 10 sessions1110–
Server RSS with 10,000-line scrollback full10.6 MB10.5 MB – 10.6 MB28.4 MB28.3 MB – 28.5 MB4.3 MB4.3 MB – 4.4 MB–
Time to a usable session28.7 ms27.5 ms – 49.8 ms25.1 ms22.7 ms – 31.9 ms9.8 ms9.2 ms – 14.6 ms–
cat 32 MiB: wall time2.47 s2.23 s – 2.66 s6.00 s5.80 s – 6.24 s5.15 s4.80 s – 5.84 s0.57 s0.53 s – 0.63 s
cat 32 MiB: multiplexer CPU time2.16 s1.98 s – 2.31 s5.59 s5.33 s – 5.66 s4.67 s4.53 s – 4.97 s–
cat 32 MiB: bytes sent to the terminal14.8 MiB10.2 MiB – 19.6 MiB25.9 MiB2.3 MiB – 25.9 MiB32.4 MiB32.4 MiB32.4 MiB – 32.4 MiB
How we measured
  • Machine: 4 vCPU Intel(R) Xeon(R) Processor @ 2.80GHz virtual machine, 15.7 GB RAM, Ubuntu 24.04.5 LTS, Linux 6.18.44-fc-v180. Other jobs were running on the host (load average 2.30 at the start, 1.46 at the end), which is why we report medians and ranges.
  • Versions: tmux 3.8 (built from source with the default -O2), tmux 3.4 (Ubuntu 24.04 package), Screen version 4.09.01 (GNU) 20-Aug-23 (Ubuntu 24.04 package). The shell in every pane is /bin/sh (dash). No config files (tmux -f /dev/null, screen -c /dev/null) except where a test says otherwise.
  • Runs: 9 rounds on 2026-10-28, tools interleaved, each run starting from a fresh temporary HOME, socket directory and server.
  • Memory: resident set size (RSS) and proportional set size (PSS, which splits shared library pages fairly between processes) from /proc, after the session settled. PSS is the honest number when adding up several processes.
  • Startup: a client is started in a fresh 120x40 pty with no server running; the clock stops when the shell prompt appears on that terminal.
  • Throughput: cat of a 32 MiB file (419,431 lines of 80 bytes) typed into an attached session; the clock stops when a marker printed after it is drawn. The outer pty is read as fast as possible by the script, so the cost of a real terminal emulator drawing the text is not included. tmux redraws only what is visible when output outruns the terminal, so it sent fewer bytes; Screen passes every byte through.
  • Reproduce: the harness is a single Python script (bench.py, standard library only) run as python3 bench.py --runs 9 --mb 32; email hello@tmux.app for a copy. The quick check below repeats the memory test with nothing but tmux and /proc.
  • Not measured: Zellij, Byobu, WezTerm, cmux and the other tools on these pages. We only publish numbers we measured ourselves.

Check it yourself in 30 seconds

This repeats the "10 sessions × 4 shells" memory test with nothing but tmux and /proc (Linux). On our machine it printed an RSS of about 4 MB; PSS varies with how many other processes share the same libraries.

tmux
T="tmux -L bench -f /dev/null"
for i in 0 1 2 3 4 5 6 7 8 9; do $T new -d -s s$i -x 120 -y 40; for j in 1 2 3; do $T split-window -t s$i; $T select-layout -t s$i tiled; done; done
sleep 2; grep -E '^(Rss|Pss):' /proc/$($T display -p -t s0 '#{pid}')/smaps_rollup
$T kill-server
GNU Screen
for i in 0 1 2 3 4 5 6 7 8 9; do screen -dmS s$i; for j in 1 2 3; do screen -S s$i -X screen; done; done
sleep 2; for p in $(pgrep -x screen); do grep '^Pss:' /proc/$p/smaps_rollup; done | awk '{kb+=$2} END {print kb " kB PSS"}'
for i in 0 1 2 3 4 5 6 7 8 9; do screen -S s$i -X quit; done

What changed in GNU Screen 5.0

GNU Screen 5.0.0 came out on August 28, 2024, the first major release in years. According to the release announcement it:

  • added truecolor on|off (24-bit color), multiinput (type into several windows at once), auth on|off (password protection) and status (move the message line to any corner);
  • rewrote the authentication code, switched to the system's wcwidth() for character widths, and added the %T (tty) and %O (number of windows) escapes;
  • removed the time, debug, password, maxwin and nethack commands.

5.0.1 (May 12, 2025) was a security release fixing CVE-2025-23395 and four other CVEs; 5.0.2 is the current release (tarball dated July 11, 2026 on ftp.gnu.org).

WhereScreentmux
Ubuntu 24.044.9.13.4
Debian 12 / 134.9.0 / 4.9.13.3a / 3.5a
Debian testing and unstable5.0.23.7c / 3.8
Homebrew5.0.23.8

From packages.debian.org, formulae.brew.sh and Launchpad, checked October 28–29, 2026. So most servers you SSH into today still have Screen 4.9, without 24-bit color. tmux versions per distribution are on the Linux install page.

When GNU Screen is still the right tool

  • Serial consoles. screen /dev/ttyUSB0 115200 opens a serial line directly. tmux cannot; run picocom, minicom or cu inside a tmux pane instead.
  • It is what is installed. On a machine where you cannot install packages and only Screen exists, use it; the keys above get you through. If you can write to your home directory, a tmux binary there needs no root (see building from source).
  • Sessions already running. Do not kill a long job to switch tools. Leave the Screen session alone and start new work in tmux; they do not interfere.
  • Minimal footprint for one session. In our tests one idle Screen session used 2.7 MB against 4.4 MB for tmux, and reached a prompt in 10 ms instead of 29 ms. Both are tiny.

Migration checklist: from Screen to tmux

  1. Install tmux next to Screen

    sudo apt install tmux (or dnf, pacman, brew; see the install guides). Screen and tmux use separate sockets, so running Screen sessions are not touched.

  2. Translate your .screenrc

    Go through your ~/.screenrc line by line with the mapping table, and put the result in ~/.tmux.conf. Start with the Ctrl+a block if you want to keep the prefix.

  3. Learn the five keys that differ most

    Window list Ctrl+b w, rename Ctrl+b ,, kill window Ctrl+b &, split Ctrl+b " and Ctrl+b %, next pane Ctrl+b o. Everything else is on the cheat sheet.

  4. Update scripts that call screen

    Replace screen -dmS name cmd with tmux new -d -s name cmd, -X stuff with send-keys, and -X quit with kill-session (table). Check cron jobs, systemd units and deploy scripts.

  5. Make tmux your login default

    To land in tmux on every SSH login, add this near the end of ~/.bashrc on the server. It attaches to main or creates it, and skips nested and non-interactive shells:

    ~/.bashrc
    if [ -z "$TMUX" ] && [ -n "$SSH_TTY" ] && command -v tmux >/dev/null; then
      tmux new -A -s main
    fi
  6. Let old Screen sessions finish

    Run screen -ls now and then; when the list is empty, you are done. Keep Screen installed if you use serial consoles.

FAQ: GNU Screen vs tmux

How do GNU Screen commands map to tmux?

The main ones: screen -S name → tmux new -s name; screen -ls → tmux ls; screen -r name → tmux attach -t name; screen -d -r name → tmux attach -d -t name; screen -dmS name cmd → tmux new -d -s name cmd; screen -X stuff → tmux send-keys; screen -S name -X quit → tmux kill-session -t name. Inside a session, Ctrl+a becomes Ctrl+b: c and d are the same, " (window list) becomes w, A (rename) becomes ,, S and | (splits) become " and %. The full tables are above.

Is tmux better than GNU Screen?

For most people, yes: panes that survive a detach, one scriptable server, floating panes and popups, 24-bit color on any version, plugins, and much lighter memory use once you run several sessions. Screen is smaller for a single session, starts faster, and is the one to use for serial consoles.

Can I use my Screen key bindings in tmux?

Yes. unbind C-b, set -g prefix C-a and bind a send-prefix give you the Ctrl+a prefix, and the Screen-style block adds ", A, k, S, |, Tab, X and Q. It loads on tmux 3.4 and 3.8.

Does tmux use more memory than Screen?

For one session, a little: 4.4 MB vs 2.7 MB server RSS in our test. For many sessions, much less: 40 shells in 10 sessions took 1.6 MB of PSS in tmux 3.8 and 11.6 MB in Screen, because Screen starts a process per session. Method and all numbers are in the benchmarks.

Can tmux attach to a running Screen session?

No. They are separate programs with separate sockets. Reattach with screen -r, let the job finish, and start new work in tmux. You can run screen -r inside a tmux pane if you want both in one terminal; tmux uses Ctrl+b and Screen Ctrl+a, so the keys do not collide.

Why does tmux handle resizing better than Screen?

When several clients view the same tmux window, it is sized to the most recently active client by default (window-size latest, since 3.1), instead of the smallest one. setw -g aggressive-resize on goes further and sizes each window only by the sessions currently showing it.

Is GNU Screen still maintained?

Yes. 5.0.0 came out in August 2024, 5.0.1 (security fixes) in May 2025 and 5.0.2 in July 2026. Most stable distributions still ship 4.9.

Is tmux installed by default?

Not on most desktops. It is in the official repositories of Debian, Ubuntu, Fedora, RHEL, Arch, Alpine and openSUSE, in Homebrew and MacPorts, and part of the OpenBSD base system. See the install guides.

Keep learning

Something wrong or out of date on this page? Email hello@tmux.app and we will fix it.