Learn Tmux - Prefix Key & Default Keybindings

#Introduction

In episode 3 we covered the session, window, and pane lifecycle — how tmux wraps your processes in a session tree that stays alive even when the terminal is closed. None of those actions appear out of nowhere: tmux is a machine driven by keybindings, and every keybinding runs through a single gateway called the prefix key. This episode dissects that gateway in full, because understanding the prefix is the difference between memorizing shortcuts and understanding how tmux works.

The prefix key is the main reason tmux feels unfriendly on day one, and at the same time the reason it feels so powerful in week two. Once you understand that tmux lives between you and the shell — it siphons off part of the keyboard input, interprets it as commands, and forwards the rest to the application inside the pane — any keybinding you find in the docs becomes easy to read. In tmux 3.7b (the latest stable release at the time of writing) this behavior hasn't changed at all, and that's precisely its strength: what you learn today still applies years from now.

Why does this matter in real work? Because in the middle of a production incident, on a log-flooded staging server, or when SSH-ing into a server you must keep alive, you don't have time to open a cheat sheet. Keybindings must live in your muscle memory. In this episode we cover the prefix key concept, the difference between prefixed and normal keybindings, how to change the prefix to Ctrl+A, Alt, or CapsLock, the must-memorize keybinding map, and two ways to rediscover keybindings you forgot: prefix + ? and tmux list-keys. Let's get started.

#The Prefix Key Concept: Gateway to Tmux Commands

The prefix key is the gateway key: tmux commands are not sent directly to the application — tmux waits for you to press the prefix first, then the command key. Think of it like the Shift key — it does nothing on its own, but it changes the meaning of every letter you press afterward. prefix + c means "create a new window", while pressing c without the prefix just types a regular c into the shell. One key, two meanings, distinguished by whether the prefix is present.

tmux's default prefix is Ctrl+B. The historical reason: Ctrl+B isn't used by the bash shell for navigation people commonly use (though readline knows it as "move backward one character"), so the risk of colliding with applications inside a pane is relatively low. Its drawback is clear: its position in the bottom-left corner of the keyboard forces your hand to travel far from the home row, and for users coming from GNU Screen, the Ctrl+A combination feels more natural. As a result, almost all tmux users adjust the prefix early on — and that's the topic of the next section.

One technical detail you need to understand: after you press the prefix, tmux opens a timing window waiting for the next key. Press the prefix then c sequentially, not simultaneously — if you press Ctrl+B and C in the same keystroke, what gets read is most likely just Ctrl+C (interrupt). This is the most common beginner mistake and the source of much frustration.

#Normal Keybinding vs Prefix Keybinding

Not all tmux keybindings require a prefix. tmux organizes keybindings into key tables, and the table you'll see most often is the prefix table. Bindings in this table only activate after the prefix is pressed. There are also prefix-free keybindings marked with the -n flag (short for "no prefix") — these work immediately when the key is pressed, without waiting for the gateway.

Prefix-free keybindings are very useful for function keys that terminal apps rarely use — for example bind -n F8 run-shell "htop". But use them carefully: every -n binding is a candidate for conflict with applications running inside the pane. The bash shell, vim, htop, and others have their own keybindings; if the two collide, one of them will "swallow" the key. The general principle: tmux's defaults use the prefix to minimize these conflicts, and you should only drop the prefix for keys nobody actually uses.

#Changing the Prefix: Ctrl+A, Alt, and CapsLock

Changing the prefix is the first ritual almost every tmux user performs, and this decision deserves careful thought because it will accompany you for years. There are three common directions, each with its own trade-offs:

• Ctrl+A — close to the home row, but collides with readline (Ctrl+A in bash means "jump to the start of the line"). Its advantage: if you migrated from GNU Screen, your muscle memory is already trained.
• Alt / Meta — for example M-a or M-q. Alt is rarely used by modern applications, so conflicts are minimal. Its drawback: some terminals need configuration for Alt to behave as a meta key.
• CapsLock — remapped to Ctrl at the OS level (e.g. xcape on Linux or Karabiner-Elements on macOS), then using Ctrl+A as the prefix. This is the most ergonomic solution, but requires setup outside tmux.

Whatever you choose, the mechanism in tmux is the same: change the prefix option, unbind the old binding, and define send-prefix.

#Changing to Ctrl+A

Here's the standard configuration for moving from Ctrl+B to Ctrl+A:

~/.tmux.conf: prefix Ctrl+A~/.tmux.conf: prefix Alt

set -g prefix C-a
unbind C-b
bind C-a send-prefix

set -g prefix M-a
unbind C-b
bind M-a send-prefix

Those three lines have complementary roles. set -g prefix C-a changes the prefix key. unbind C-b discards the old keybinding — without this line, both Ctrl+B and Ctrl+A become prefixes, which is confusing. The last line is the one most often forgotten: bind C-a send-prefix defines the "repeated prefix" — when you press Ctrl+A twice, the raw Ctrl+A character is forwarded to the application inside the pane. This matters because many applications inside tmux — especially readline and vim — use Ctrl+A for navigation. Without send-prefix, you lose the ability to send a literal Ctrl+A to those applications.

The same pattern applies to the Alt choice: set -g prefix M-a, unbind C-b, bind M-a send-prefix. Note that send-prefix is always paired with the new prefix, not the old one.

#The Must-Memorize Keybinding Map

Now that you understand the concept, it's time to fill your muscle memory. Don't memorize the whole list — memorize this map first, and let prefix + ? help you in between.

#Pane and Window Navigation

Panes and windows are your daily workspace. To create new space: prefix + % splits the pane vertically (to the right), prefix + " splits it horizontally (downward). To move between panes, prefix + panah moves focus in the target direction, and prefix + o moves it in creation order. For windows, prefix + n and prefix + p move to the next/previous window, while prefix + 0 through prefix + 9 jump straight to a window by number.

#Resize, Zoom, and Detach

prefix + Ctrl+panah resizes the active pane by one cell in that direction — hold it to keep resizing. prefix + Alt+panah does it five cells at a time. When you need total focus on one pane — say, reading a long error log — prefix + z zooms: the active pane fills the screen and the rest are hidden. Press prefix + z again to restore the layout. And prefix + d detaches you from the session without stopping the processes inside it — the foundation of every production workflow we covered in episode 3.

#Help and Command Prompt

The two most life-saving keybindings are prefix + ? and prefix + :. prefix + ? shows all active keybindings in copy mode — scrollable with the arrow keys, and q to exit. prefix + : opens the tmux command prompt, where you can run any tmux command directly, like new-window, set -g prefix C-a, or source-file ~/.tmux.conf. Both are safety nets: when you forget something, tmux never hides it from you.

#Finding Keybindings: prefix + ? and tmux list-keys

These two paths mean you never have to memorize all keybindings, because tmux can always show you the contents of its dictionary. prefix + ? is the interactive way: it opens the full list in copy mode, ready to scroll. tmux list-keys is the programmatic way — its output is plain text that can be filtered, studied, even used as automation material.

tmux list-keys
tmux list-keys | rg "new-window"
tmux -V

The second line shows a very useful pattern: since list-keys produces text, you can filter it with rg. For example, to find all keybindings involving windows: tmux list-keys | rg "window". To see only the prefix table: tmux list-keys -T prefix. The first line's output — like bind-key -T prefix c new-window — is the canonical form that matches exactly the syntax in the config file, so reading this output is also a way to learn to write configuration.

#Common Pitfalls

1. Pressing prefix and key simultaneously. Ctrl+B then c must be sequential with a short pause, not combined. Combining them is usually read as Ctrl+C (interrupt) by the shell.

2. Changing the prefix without unbind C-b. The old prefix stays active, so you end up with two colliding gateways. Always follow the set -g prefix, unbind, then bind ... send-prefix pattern.

3. Memorizing the whole keybinding list at once. This is the fastest road to frustration. Memorize five first: c, %, arrows, z, d. Let prefix + ? be your safety net, and the rest will stick on their own with use.

4. Assuming every keybinding needs a prefix. -n keybindings (e.g. the F-row keys) work without a prefix. If a key seems "on fire" in your application, first check whether a -n binding is catching it with tmux list-keys | rg "^-n".

5. Forgetting the prefix is not forwarded to the application inside the pane. When you need to send the literal prefix character to an application (e.g. Ctrl+A to screen or readline), press the prefix twice via send-prefix, not just once more.

6. Changing the prefix but not reloading the config. Changes in ~/.tmux.conf don't activate automatically. Re-source with tmux source-file ~/.tmux.conf, and in episode 6 we'll install the prefix + r keybinding so reloading is a single keystroke.

#Conclusion

This episode laid the foundation of your interaction with tmux. You understand that the prefix key is the gateway that distinguishes "typing to the application" from "giving commands to tmux", you know how to read prefixed vs prefix-free (-n) keybindings, and you can change the default prefix Ctrl+B to Ctrl+A, Alt, or CapsLock with the set -g prefix + unbind + send-prefix pattern. You also carry the must-know keybinding map — pane and window navigation, resize, zoom prefix + z, detach prefix + d, help prefix + ?, and command prompt prefix + : — plus two discovery tools that will never leave you lost.

Key points to take away:

• The prefix key changes the meaning of the next key; default tmux keybindings live in the prefix table.
• -n keybindings work without a prefix and should be used sparingly because they risk conflicting with applications.
• Change the prefix with a three-line pattern: set -g prefix, unbind the old one, bind ... send-prefix.
• Memorize five core keybindings (c, %, arrows, z, d); find the rest via prefix + ?.
• tmux list-keys is a programmatic dictionary you can filter with rg.

Now you can move around inside tmux without getting lost. In episode 5 we enter the territory that distinguishes tmux from an ordinary terminal: copy mode, scrollback, and clipboard management — how to browse thousands of lines of output, copy text vi-style, and get it out into the system clipboard. See you in episode 5!