cmd.exe / ConPTY — ANSI escape code support

Sequences that work here

Canonical reference pages for the escape sequences this terminal handles cleanly. Each links to a full page with byte forms, citations, and per-language examples.

• SGR 0 — Reset / Normal\x1b[0m

  Clear all text attributes and colors back to the terminal default.

• SGR 30–37 — Foreground color (8 basic)\x1b[31m (red, similarly 30–37)

  Set foreground to one of black/red/green/yellow/blue/magenta/cyan/white.

• SGR 38;2;R;G;B — 24-bit truecolor foreground\x1b[38;2;R;G;Bm

  Pick any of 16,777,216 foreground RGB colors directly.

• CUP — Set cursor position\x1b[row;colH

  Move the cursor to absolute row/column (1-indexed).

• ED — Erase in display (\x1b[2J clear screen)\x1b[NJ

  Erase part or all of the screen.

Quirks & version notes

Per-terminal caveats you'll want to know before relying on a sequence in production.

ENABLE_VIRTUAL_TERMINAL_PROCESSING — the legacy opt-in flag

Before 1709, console apps had to opt in to VT parsing by calling `SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_PROCESSED_OUTPUT)`. Python's `colorama.just_fix_windows_console()` (since v0.4.6) and `pwsh.exe`'s prompt setup do this for you; raw `python.exe` / `node.exe` / `go run` on 1809+ get VT enabled implicitly because ConPTY is in the pipeline. Bare C: `#include <windows.h>` + `SetConsoleMode(GetStdHandle(STD_OUTPUT_HANDLE), 0x0001 | 0x0004)`. PowerShell: `[Console]::OutputEncoding = [System.Text.Encoding]::UTF8` + nothing else needed. If you're shipping a CLI that must work on Win7 / Server 2008 R2, fall back to the `colorama`-style Win32-API path.

ConPTY translation is lossy — Win32-console quirks survive

Since 1809, every cmd window is fronted by ConPTY: it owns a screen buffer, runs the parser, and emits VT bytes upstream. Legacy programs that still call `WriteConsoleOutput` or query screen-buffer state through `GetConsoleScreenBufferInfo` work by ConPTY synthesising responses. Two known lossy cases: (1) `WriteConsoleOutput` with non-default attributes is approximated to the nearest VT SGR — sub-cell precision is dropped; (2) bracketed-paste mode bytes can leak into apps that didn't request them, because ConPTY can't tell which child process expects which DEC private mode (microsoft/terminal#3866). Workaround: detect ConPTY via `IsConsoleHandle + GetConsoleMode` returning `ENABLE_VIRTUAL_TERMINAL_INPUT` and emit only modern VT.

`prompt $E[1;31m…$E[0m` — embedding ESC in cmd.exe prompts

cmd.exe's `prompt` builtin expands `$E` to a literal `\x1b` byte, so `prompt $E[1;31m$P$E[0m$G` paints the working-directory prompt red. Set it permanently via `setx PROMPT "$E[1;31m$P$E[0m$G"`. In BAT scripts you can also use `for /F %%a in ('echo prompt $E ^| cmd') do set ESC=%%a` to capture an ESC byte into a variable. Modern PowerShell users use `$PSStyle.Foreground.Red` instead; cmd users have no native colour API, only this prompt-substitution trick.

`chcp 65001` for UTF-8 — and the EOF gotcha

cmd.exe defaults to the OEM codepage (cp437 in US English locale), so emoji and most non-ASCII text in coloured output render as mojibake. `chcp 65001` switches the active codepage to UTF-8; persist it with `setx /M PYTHONUTF8 1` (Python) or via `Settings → Time & Language → Language & Region → Administrative language settings → Change system locale → Beta: Use Unicode UTF-8` (Windows 10 1903+, machine-wide). The historical EOF gotcha: under cp65001 some C runtime versions read EOF prematurely on `getchar()` — fixed in MSVC v142+ but still bites mingw-built binaries. SGR escape bytes themselves are codepage-insensitive (they're ASCII), so colour works on any codepage.

Truecolor: yes since 1709, but conhost.exe quantizes to 16

Windows 10 1709+ parses `\x1b[38;2;R;G;Bm` truecolor SGR. In Windows Terminal you get the actual 24-bit pixel; in legacy conhost.exe (the host you see when you launch cmd directly from `C:\Windows\System32\cmd.exe`, not via `wt.exe`) the truecolor value is quantized to the nearest of 16 console-palette colours. Apps that care should query `$COLORTERM=truecolor` (Windows Terminal sets it; conhost.exe doesn't) or — better — emit 256-indexed colour as the safer baseline. ConPTY on 1809+ passes the truecolor bytes through unchanged; the quantisation happens at the rendering layer above, not in the parser.

$TERM is unset — detect via `OS=Windows_NT`

cmd.exe doesn't set `$TERM` — terminfo-based detection (`tput colors`, `infocmp`) silently fails. Instead, cross-platform CLIs check `process.platform === 'win32'` (Node), `os.name === 'nt'` (Python), `runtime.GOOS === "windows"` (Go), `cfg!(windows)` (Rust). For finer-grained "running under Windows Terminal vs raw conhost" detection, look at `$WT_SESSION` (set by Windows Terminal only) or `$TERM_PROGRAM=Windows_Terminal`. Bare cmd / conhost has neither, just `OS=Windows_NT`. Inside WSL the picture flips: there `$TERM` is set normally by the Linux shell and the Windows host is invisible.

Citations

• Console VT sequences (Microsoft Learn)
• ConPTY introduction (Windows Command Line blog)
• SetConsoleMode reference
• cmd.exe prompt customisation

Other terminals with landing pages

• xterm
• Linux console (fbcon)
• macOS Terminal.app
• iTerm2
• Windows Terminal
• kitty
• alacritty
• WezTerm
• Ghostty
• GNOME Terminal
• Konsole
• tmux
• GNU screen
• See the full terminal matrix