Terminals & emulators

Status: 🟩 COMPLETE (🟦 LIVING — Warp and AI-native terminals are evolving fast) Last updated: 2026-06-19 Plain-English tagline: The application you actually type into — the window on the screen — distinct from the SHELL inside it (PowerShell, bash, zsh). Picking the right terminal saves friction every day.

In plain English

Most newcomers conflate two things:

The terminal (or terminal emulator) — the program with the window, tabs, font, colors, and copy/paste behavior
The shell — the interactive program running INSIDE that window that interprets commands (PowerShell, bash, zsh, fish)

You start the terminal; it opens with a default shell inside; you type commands; the shell runs them. You can change the terminal OR the shell independently.

This entry is about TERMINALS (the outer program). For shells (the inner program), see PowerShell vs Bash.

In 2026, the meaningful options:

OS	Best terminals
Windows	Windows Terminal (Microsoft, free, default modern choice)
macOS	iTerm2 (free, mature), Warp (newer, AI-integrated, free + Pro), Ghostty (newer, fast, free), Apple’s built-in Terminal.app (usable but limited)
Linux	Whatever ships with your distro (gnome-terminal, konsole), or Alacritty (fastest), or Warp if available
Cross-platform	Warp, Wezterm, Hyper — all polished, all paid or free tiers

You don’t need to pick perfectly. The terminal that ships with your OS is fine for daily work. Upgrading to Windows Terminal (Windows) or iTerm2/Warp (macOS) is a quick win, but no terminal will be the bottleneck in your workflow.

Why it matters

Three concrete reasons a good terminal pays off:

You’ll spend HOURS in it. Every npm command, every git command, every CI log tail, every server start happens here. Quality-of-life improvements (tabs, search, font rendering, copy/paste behavior) compound.
Some legacy terminals are PAINFUL. Apple Terminal.app and cmd.exe are both functional but feel like the 1990s. Modern alternatives are dramatically better.
AI terminals are emerging. Warp’s AI command suggestion + explanation, Ghostty’s speed, Wezterm’s scriptability — the landscape is changing. Worth knowing what’s out there.

The trade-off: switching terminals takes 30-60 minutes (install, configure font, copy keybindings). For someone who codes daily, this is recovered in the first week.

What a terminal actually does

A terminal emulator is responsible for:

Rendering text — taking the shell’s text output and drawing it as pixels
Capturing input — keystrokes go to the shell as input
Handling control sequences — colors, cursor moves, screen clears (the “ANSI escape codes”)
Window features — tabs, split panes, find-in-output, scrollback, theming
Copy/paste, mouse, key bindings — the host-OS UX layer

It does NOT:

Execute commands (that’s the shell)
Know about Git, npm, or any specific tool
Understand the structured content of what’s printed (text in, text out)

This is why “terminal emulator” is the precise name: it EMULATES the old hardware terminals (VT100, etc.) that originally controlled mainframes via serial cables.

The terminals worth knowing

Windows Terminal

Microsoft’s modern terminal for Windows 11 (and Windows 10 via the Store). Tabs, multiple profiles (PowerShell + Bash + WSL + cmd in one window), GPU rendering, theming.

winget install Microsoft.WindowsTerminal

Set it as the default in Windows 11: Settings → System → For developers → Terminal: Windows Terminal.

Profiles are configured in JSON (Settings → Open JSON file). A useful profile:

{
  "name": "Git Bash",
  "commandline": "C:\\Program Files\\Git\\bin\\bash.exe -i -l",
  "icon": "C:\\Program Files\\Git\\mingw64\\share\\git\\git-for-windows.ico",
  "startingDirectory": "%USERPROFILE%"
}

Tab dropdown lets you launch any profile in a new tab.

iTerm2 (macOS only)

The de-facto standard Mac terminal for ~15 years. Free, open-source, deeply configurable.

Highlights:

Tabs and split panes
Session restoration (close and reopen with all tabs intact)
Excellent search (“find in scrollback”)
AppleScript integration
Profiles per project (different fonts, colors per workspace)

Install: brew install --cask iterm2.

In 2026, iTerm2 is being slowly displaced by Warp and Ghostty among newer Mac users. But for stability + ecosystem, it’s still solid.

Warp

A newer, cross-platform terminal (macOS first, Windows + Linux growing) with AI-integrated features:

AI command suggestions (“how do I list files modified in the last 24 hours?”)
AI command explanation (paste a command, get a description)
“Blocks” — output is grouped per command, navigable as units
Modern font rendering and themes
Collaborative sessions (paid feature)

Free tier; Pro is $20/mo. For developers who use AI heavily, Warp is increasingly the daily driver.

The catch: Warp is closed-source. Some developers prefer the open Wezterm or Ghostty for privacy reasons.

Ghostty

A 2024-released terminal by Mitchell Hashimoto (founder of HashiCorp). Open-source, native, very fast, no nonsense.

Native rendering (no Electron)
Fast startup
Cross-platform (mac, Linux, Windows soon)
Simple, minimalist UI

Less mature than iTerm2, less feature-rich than Warp, but compelling if “fast and clean” is your priority.

Wezterm

Cross-platform, open-source, configurable in Lua. Power-user terminal with deep extension capabilities.

The OS defaults

Windows: cmd.exe — for compatibility only; don’t use as your daily driver
macOS: Terminal.app — functional, slow, ugly fonts; replace with iTerm2 or Warp
Linux: gnome-terminal / konsole — fine, ship with the distro

A solid baseline configuration

Regardless of which terminal you pick, configure:

1. A good monospace font

Built-in fonts are usually fine but pixel-shaped fonts (Menlo, Consolas) have aged. Modern picks:

JetBrains Mono (free) — clear, has ligatures
Geist Mono (free, from Vercel)
Fira Code (free) — popular for ligatures
MonoLisa (paid) — designer favorite

Set the font size around 13-14pt for daily comfort. The terminal you spend hours in shouldn’t strain your eyes.

2. A color scheme

Dark themes are easier on the eyes for long sessions
High contrast — body text vs background must be readable
Match your VS Code theme for visual consistency
Popular schemes: Tokyo Night, Catppuccin, One Dark, Nord, Solarized Dark

3. Keyboard shortcuts you’ll use

Action	Windows Terminal	iTerm2	Warp
New tab	Ctrl+Shift+T	Cmd+T	Cmd+T
New pane	Alt+Shift+D	Cmd+D	Cmd+D
Switch tab	Ctrl+Tab	Cmd+→/←	Cmd+→/←
Find in output	Ctrl+Shift+F	Cmd+F	Cmd+F
Copy	Ctrl+Shift+C	Cmd+C	Cmd+C
Paste	Ctrl+Shift+V	Cmd+V	Cmd+V
Clear screen	Ctrl+L	Cmd+K	Cmd+K

The copy/paste differs from a normal editor (it’s Cmd+C / Cmd+V on Mac; Ctrl+Shift+C / Ctrl+Shift+V on Windows/Linux because plain Ctrl+C is “interrupt running process” in bash). Many terminals offer both, configured.

4. Profiles per project (optional, advanced)

Some terminals support PER-PROJECT or PER-PROFILE settings: different working directory, font, colors. Useful if you switch between many projects. Most users don’t bother.

5. Scrollback buffer size

Default scrollback (10,000-50,000 lines) is plenty. Increase if you regularly need older output. Decrease if memory is constrained.

6. Bell behavior

Terminal bells (ASCII 7, “\a”) play a sound or flash by default. Most developers disable both. In Windows Terminal: "bellStyle": "none" per profile.

VS Code’s integrated terminal

VS Code has a terminal built in (Ctrl+`). It’s a real shell, not a simulation. Most developers use it as their primary terminal because:

No window-switching to run commands while looking at code
Inherits the project’s working directory automatically
Same theming as the editor
Tabs, split panes, multiple profiles all supported

Downsides:

Less performant than dedicated terminals for heavy output
Lacks some features (rich theming, deep customization)
Limited to one window per VS Code instance

Common pattern in 2026: primary work in VS Code’s terminal; dedicated terminal (Windows Terminal / iTerm2 / Warp) for tasks outside the editor (running long jobs, system admin, shell exploration).

A concrete example: setting up Windows Terminal for Bible Quest

# 1. Install
winget install Microsoft.WindowsTerminal
 
# 2. Open Settings → Profiles → click "+" → New profile
# 3. Or edit settings.json directly:

{
  "defaultProfile": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",  // PowerShell
 
  "profiles": {
    "list": [
      {
        "guid": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
        "name": "PowerShell",
        "commandline": "powershell.exe",
        "startingDirectory": "C:\\Users\\georg\\st-marks-bible-quest",
        "colorScheme": "Tokyo Night",
        "fontFace": "JetBrains Mono",
        "fontSize": 14
      },
      {
        "name": "Git Bash",
        "commandline": "C:\\Program Files\\Git\\bin\\bash.exe -i -l",
        "startingDirectory": "C:\\Users\\georg\\st-marks-bible-quest",
        "colorScheme": "Tokyo Night",
        "fontFace": "JetBrains Mono",
        "fontSize": 14
      }
    ]
  },
 
  "schemes": [
    // Paste from windowsterminalthemes.dev or similar
  ]
}

Open Windows Terminal — it lands in the Bible Quest folder, in PowerShell, with a clean font and dark theme. New tab via Ctrl+Shift+T defaults to the same. Switch to Git Bash via the dropdown when needed.

This is a 10-minute setup that you use thousands of times.

Common gotchas

Ctrl+C cancels the running command, NOT copies text. This is a holdover from real terminals — copying is Ctrl+Shift+C (Win/Linux) or Cmd+C (Mac). Plain Ctrl+C sends an interrupt signal to whatever’s running.
Ctrl+L (or Cmd+K) clears the screen, but scrollback is preserved. The buffer still holds previous output; scroll up to see it. clear (Unix) or cls (Windows cmd) clears just the visible.
Ctrl+D quits the shell (sends EOF). Useful for closing tabs quickly; surprising if you typed it by mistake.
Ctrl+Z suspends the running process (Unix shells). Doesn’t kill it — it’s parked. Type fg to resume. Most novices think it’s “undo”; it’s not.
Multiple terminals = multiple shell states. Each tab has its own current directory, env vars, history. Setting $env:FOO = "bar" in one tab doesn’t affect others.
Background processes don’t survive the terminal closing. Closing a tab with npm run dev running kills the dev server. Use nohup or screen/tmux for persistent sessions if needed.
Copy/paste behavior differs from editors. Especially on Windows: highlighting copies, right-click pastes (by default in many terminals). Can confuse Mac users.
Wide Unicode (emoji, CJK) renders inconsistently. Some terminals handle 𝓤𝓷𝓲𝓬𝓸𝓭𝓮 beautifully; others have alignment issues. Modern terminals (Windows Terminal, iTerm2, Warp, Ghostty) are good. Old terminals struggle.
True color (24-bit) is now standard. If your prompt or tool renders weird colors, your terminal may be in 8-color or 256-color mode. Set COLORTERM=truecolor in your shell env.
TERM env var matters. Tools like vim, tmux, less read it. Common values: xterm-256color, screen-256color. Setting it wrong breaks colors.
Terminal apps have their own font rendering. A font that looks great in VS Code may look thin or pixelated in your terminal. Test before committing.
Tabs vs windows. A terminal can open many TABS in one window (typical) or many separate WINDOWS. Tabs are usually better for keyboard navigation; windows for visual side-by-side.
Split panes are powerful but underused. Most modern terminals let you split a tab into multiple panes (one shell each). Useful for “dev server here, tests there, git there.”
Mouse support is configurable. Some terminals capture mouse for the running program (e.g., vim, htop use it). Others always let the OS handle it (for selecting text). Setting matters per tool.
Cursor shape preferences. Block, underline, or bar cursor — personal taste. Most terminals let you pick + control blinking.
Don’t forget bracketed paste. Modern shells use bracketed paste to insert pasted text safely (treating it as data, not commands). If a multi-line paste behaves weirdly, this is the culprit.
screen and tmux are terminal multiplexers. They let one connection (or one terminal session) host many “virtual terminals.” Useful for SSH’ing into a server and detaching/reattaching sessions. Rarely needed for local development.
AI-integrated terminals (Warp) can leak commands. Anything you type is potentially sent to the AI service. Read the privacy policy; use local-mode if available.
Cmd+K on iTerm2/Warp clears scrollback (more aggressive than Ctrl+L). Useful but easy to do accidentally.
Resizing the terminal mid-session can mess up some TUIs. vim and htop redraw correctly. Some less-clever tools (older top, raw output) don’t.
Profile switching loses cwd. Switching from one profile to another in Windows Terminal opens a new tab with the profile’s startingDirectory, not your current cwd. Surprising the first time.
Old cmd.exe lacks features modern shells have. Tab completion, history search, colored output, multi-line editing — all weak or missing. Don’t use cmd.exe as your daily driver in 2026.
alacritty is fast but minimal. No tabs (use tmux), no GUI config (TOML files), no native scrolling search. Great if you live in a tiling window manager; awkward for newcomers.
Terminal startup time matters. A terminal that takes 2 seconds to open is annoying. Heavy .bashrc/.zshrc files often slow startup. Profile with time bash -i -c exit (Unix).
Hyper.js was a major terminal that lost momentum. Built on Electron, customizable in JS. Slowed down ~2022. Not recommended for new setups.
Tabs in a tabbed terminal vs separate windows is a workflow choice. Tabbed users keep many tabs; window users keep one terminal per task. Either works.
Selecting text on Windows Terminal uses block mode by Alt+drag. Useful for selecting columns.
The “Open in Terminal” right-click option in Windows Explorer/macOS Finder is convenient. Set in OS settings; defaults to the system terminal but can be customized.
For Bible Quest specifically: Windows Terminal + PowerShell + JetBrains Mono is the working baseline. Switching to Warp for AI assistance is fine but not necessary.

When to switch terminals

Switch from the default terminal to a modern one when:

Your daily workflow involves the terminal more than 20 minutes/day
The default’s UX bothers you (font, no tabs, slow scrolling)
You want AI-integrated suggestions (Warp specifically)
You’re configuring a new machine and want the better baseline

Don’t switch if:

Your default works fine
You’d be the only one on a team using a unique terminal (consistency helps when pair-programming)
You’re already comfortable in VS Code’s integrated terminal

Sources

Windows Terminal docs
iTerm2
Warp — AI-integrated terminal
Ghostty — Hashimoto’s modern terminal
Wezterm — Lua-configurable cross-platform terminal
Alacritty — fastest GPU terminal
terminaltrove.com — discovery site for terminal apps and tools
tmux — terminal multiplexer
JetBrains Mono — the recommended monospace font

Tech & AI, Explained

Explorer

terminals-and-emulators