What does CBT (\x1b[Z) do that Backspace doesn't?

CBT moves the cursor backward to the previous *tab stop*; Backspace (BS, \x08) moves backward by exactly one column. With the default 8-column grid and the cursor at column 17, \x1b[Z lands at column 9 in one step, whereas BS would take 8 emissions. CBT is the parameterized inverse of HT (\t) and the mirror of CHT (\x1b[I), see csi-cht. If the cursor is already on or before the first remaining tab stop, CBT is a no-op — it never crosses column 1. Tab stops are themselves controlled by HTS (\x1bH, see esc-hts) and TBC (\x1b[g / \x1b[3g, see csi-tbc), so a custom layout changes where CBT lands.

Why does \x1b[Z sometimes do nothing in my terminal?

Three common causes. (1) The cursor is already at column 1 — CBT clamps and reports no movement. (2) The application or a prior \x1b[3g (TBC clear-all, see csi-tbc) wiped every tab stop, so there's nothing to retreat to and CBT is a no-op. (3) You're inside pre-ConPTY cmd.exe, which advertises partial CSI support and silently drops uncommon final bytes like Z — modern Windows Terminal handles it correctly. Verify with DSR \x1b[6n (see csi-dsr) before and after the CBT to see whether the column number actually changed.

CBT — Cursor Backward Tabulation (CSI Z)

Move the cursor back N tab stops — the reverse of pressing Tab.

Byte forms

Every common string-literal form so you can paste-and-search either direction.

\\x1b[\x1b[NZ

\\033[\033[1Z

\\e[\e[1Z

ESC [ESC [ N Z

hex1b 5b <N> 5a

Description

Cursor Backward Tabulation. Final byte Z (0x5a) moves the cursor backward to the previous tab stop, repeated N times (default 1 if the parameter is omitted). It is the mirror of CHT (CSI Ps I) and the moral opposite of pressing the Tab key (HT, 0x09). If the cursor is already at column 1 or before the first remaining tab stop, it stays put. Default tab stops live every 8 columns unless the application has cleared or shifted them with TBC (\x1b[Ng) and HTS (\x1bH). CBT is rarely emitted by humans, but matters for terminfo capability cbt and for any TUI replaying recorded keystrokes (Shift-Tab in form fields, etc.).

Spec citation: ECMA-48 §8.3.7 (CBT)

Examples

bash

printf 'a\tb\tc\033[2Z|'   # cursor jumps back 2 tab stops, then writes |

python

import sys; sys.stdout.write('\x1b[2Z')

fmt.Print("\x1b[2Z")

javascript

process.stdout.write('\x1b[2Z')

printf("\x1b[2Z");

Used in

Real-world tools that emit this sequence — anchors the bytes to commands you've already used.

vim / neovim Shift-Tab in insert mode (`:imap <S-Tab>`)vim's default `<S-Tab>` insert-mode binding emits `\x1b[Z` to dedent by one `shiftwidth` — visible with `:set verbose=15` while pressing Shift-Tab on an indented line. `:set softtabstop=0` flips the behaviour to a literal CBT pass-through, useful in Makefile recipes
readline `menu-complete-backward` (Shift-Tab in bash)GNU readline's `menu-complete-backward` widget — bound to `"\e[Z"` (CBT) by default in bash 4.3+ — cycles candidates in reverse without emitting CBT to the terminal itself; the binding *consumes* the keypress and updates the line editor
fzf `--bind shift-tab:toggle+up`fzf treats `\x1b[Z` as `shift-tab` and routes it to its widget table — used in `~/.fzf.bash` recipes that bind Shift-Tab to toggle-multi-select with cursor-up in one keystroke. Same code path in skim and zoxide's fuzzy picker
ncurses form library navigationform fields rendered by ncurses' `<form.h>` use `\x1b[Z` for backward field navigation — `form_driver(form, REQ_PREV_FIELD)` internally maps to CBT emission when the form is in its default tab-driven mode. Visible in nmtui, alpine config dialogs
terminfo `cbt` cap (queryable via `tput cbt`)`tput cbt` looks up the `cbt` capability and emits the terminal-specific CBT byte sequence — `xterm-256color`, `screen-256color`, `tmux-256color` all map to `\x1b[Z`. Useful in shell scripts that need a portable Shift-Tab emission without hardcoding the bytes

Frequently asked

Short answers to the questions developers actually search for this sequence.

What does CBT (\x1b[Z) do that Backspace doesn't?: CBT moves the cursor backward to the previous *tab stop*; Backspace (BS, \x08) moves backward by exactly one column. With the default 8-column grid and the cursor at column 17, \x1b[Z lands at column 9 in one step, whereas BS would take 8 emissions. CBT is the parameterized inverse of HT (\t) and the mirror of CHT (\x1b[I), see csi-cht. If the cursor is already on or before the first remaining tab stop, CBT is a no-op — it never crosses column 1. Tab stops are themselves controlled by HTS (\x1bH, see esc-hts) and TBC (\x1b[g / \x1b[3g, see csi-tbc), so a custom layout changes where CBT lands.
Why does \x1b[Z sometimes do nothing in my terminal?: Three common causes. (1) The cursor is already at column 1 — CBT clamps and reports no movement. (2) The application or a prior \x1b[3g (TBC clear-all, see csi-tbc) wiped every tab stop, so there's nothing to retreat to and CBT is a no-op. (3) You're inside pre-ConPTY cmd.exe, which advertises partial CSI support and silently drops uncommon final bytes like Z — modern Windows Terminal handles it correctly. Verify with DSR \x1b[6n (see csi-dsr) before and after the CBT to see whether the column number actually changed.

Common typos / look-alikes

Wrong forms developers commonly paste from Stack Overflow that look right but aren't — with the canonical correction inline.

\x1b[Z to insert a Shift-Tab keypress into stdinCBT \x1b[Z is an OUTPUT sequence — moves cursor back by tab stop; the INPUT byte for Shift-Tab is also \x1b[Z but it travels in the opposite direction
Same byte sequence, different meaning depending on direction. When the terminal RECEIVES \x1b[Z it backs up the cursor to the previous tab stop (CBT). When the terminal SENDS \x1b[Z (in response to a Shift-Tab keypress) it's an input event the application reads from stdin. The common bug is shell-scripting a printf '\x1b[Z' to feed a Shift-Tab into a child program — the child sees CBT happen on screen instead of receiving a key event, because the byte is written to the TTY output channel, not the input PTY. To inject Shift-Tab into a child, write to its input PTY (expect, socat - exec:child,pty, tmux send-keys), not to stdout.
\x1b[Z from column 1 expecting it to wrap to previous rowCBT clamps at column 1 — emits NO row-change; for cross-row move, pair with CUU \x1b[1A
CBT only moves within the current row; from column 1 it's a no-op (cursor stays). The common assumption-from-printers is that backward-tab wraps to the previous row's last tab stop — this is wrong on every screen-oriented terminal. To emulate row-wrap behaviour you must compose: query DSR \x1b[6n to check current column, and if 1, emit CUU \x1b[1A to move up plus CHA \x1b[<last_tab>G to land on the last tab stop of the row above. Most TUI authors instead use CUF/CUB for non-tab-aware navigation and reserve CBT for forms-editor field navigation where row-wrap isn't expected.
\x1b[3g (clear all tab stops) followed by \x1b[Z expecting CBT to fall back to column 1after \x1b[3g (TBC mode 3) CBT becomes no-op from ALL columns since there are no stops to land on — re-emit HTS \x1bH at desired stops before using CBT
TBC \x1b[3g clears ALL tab stops including the implicit 8-column defaults. CBT then has nothing to find and becomes a no-op regardless of starting column. The same trap occurs after DECSTR \x1b[!p (soft reset clears tab stops too on some terminals) and RIS \x1bc (always clears). The fix: after any operation that touches tab stops, re-establish the column ruler with a CUP+HTS loop (\x1b[1G\x1bH\x1b[9G\x1bH\x1b[17G\x1bH...) before relying on CBT. Or just avoid \x1b[3g entirely — \x1b[g (TBC mode 0, current column only) is almost always what you actually want.

Terminal support

xterm: yes
Linux console (fbcon): yes
macOS Terminal.app: yes
iTerm2: yes
Windows Terminal: yes
cmd.exe / ConPTY: partial
kitty: yes
alacritty: yes
WezTerm: yes
Ghostty: yes
GNOME Terminal: yes
Konsole: yes
tmux: yes
GNU screen: yes

xterm	Linux console (fbcon)	macOS Terminal.app	iTerm2	Windows Terminal	cmd.exe / ConPTY	kitty	alacritty	WezTerm	Ghostty	GNOME Terminal	Konsole	tmux	GNU screen
yes	yes	yes	yes	yes	partial	yes	yes	yes	yes	yes	yes	yes	yes

Related sequences

In the family cookbook

C0 cookbook · 3. HT — horizontal tab and the TBC / HTS lineage