# What Is conhost.exe in Windows Terminal? The Backend Engine Explained

> Understand conhost.exe, the headless backend engine powering Windows Terminal. Learn how it manages console screen buffers and I/O with powerful insights from the microsoft/terminal repository.

- Repository: [Microsoft/terminal](https://github.com/microsoft/terminal)
- Tags: deep-dive
- Published: 2026-02-26

---

**`conhost.exe` acts as the headless backend engine that implements console screen buffers and handles I/O between the Windows Terminal UI and the Windows kernel driver `condrv.sys` via the ConPTY pseudo-console interface.**

In the `microsoft/terminal` repository, `conhost.exe` (the Windows Console Host) is not replaced by Windows Terminal but rather repurposed as a silent workhorse. While `wt.exe` provides the modern tabbed interface, it delegates all console semantics to a headless instance of `conhost.exe` launched via the ConPTY APIs.

## Understanding conhost.exe in the Windows Terminal Architecture

Windows Terminal separates presentation from implementation. The frontend process (`wt.exe`) handles rendering, theming, and user interaction, but it does not draw the console itself. Instead, it creates a **pseudo-console (ConPTY)** and launches a **headless `conhost.exe`** process that:

- Attaches to the ConPTY server handle created by the kernel driver `condrv.sys`
- Manages the console screen buffer, scrollback, and input queues
- Parses and emits VT sequences for compatibility with Unix-style terminals

This architecture allows Windows Terminal to modernize the user experience while preserving backward compatibility with legacy console applications that expect classic Windows console behavior.

## Four Critical Roles of conhost.exe in Windows Terminal

### 1. PTY Ownership and Kernel Communication

`conhost.exe` owns the connection to the ConPTY driver. In [`src/winconpty/winconpty.cpp`](https://github.com/microsoft/terminal/blob/main/src/winconpty/winconpty.cpp), the Windows Terminal process resolves the path to `conhost.exe` and constructs a command line that includes the server handle returned by `condrv.sys`. The headless host attaches to this handle and becomes the authoritative source for console state.

### 2. Headless Operation Mode

When launched by Windows Terminal, `conhost.exe` receives the `--headless` flag on its command line (constructed in [`src/winconpty/winconpty.cpp`](https://github.com/microsoft/terminal/blob/main/src/winconpty/winconpty.cpp) lines 188-199). This mode suppresses the creation of a traditional console window, allowing the process to run silently in the background while the Terminal UI handles all visual output.

### 3. I/O Bridging and VT Processing

All input and output is marshaled through the headless host. Keyboard events, mouse movements, and window resizing from the Terminal are sent to `conhost.exe`, which translates them into the internal console API calls. Conversely, text and VT sequences emitted by client applications (like PowerShell or WSL) are parsed by `conhost.exe` and streamed back to the Terminal for rendering.

### 4. Process Lifetime Management

The lifetime of the headless `conhost.exe` is tightly coupled to its clients. As implemented in [`src/host/exe/exemain.cpp`](https://github.com/microsoft/terminal/blob/main/src/host/exe/exemain.cpp) (lines 51-57), the process sets its shutdown priority to zero, ensuring it terminates automatically when the Windows Terminal process (`wt.exe`) and any spawned shells exit. Additionally, [`src/cascadia/WindowsTerminal/main.cpp`](https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/main.cpp) (lines 56-58) verifies that the UI process architecture matches `conhost.exe`, as the PTY driver requires binary compatibility between the two processes.

## How Windows Terminal Launches conhost.exe

The spawning logic resides in [`src/winconpty/winconpty.cpp`](https://github.com/microsoft/terminal/blob/main/src/winconpty/winconpty.cpp). Windows Terminal first resolves the absolute path to the inbox `conhost.exe` (or a side-by-side `OpenConsole.exe` in development builds), then constructs a command line string that passes the PTY dimensions, server handle, and signal pipe to the host.

```cpp
// Build the headless command line for conhost.exe
const auto conhostPath = _ConsoleHostPath();   // → path to conhost.exe

wil::unique_process_heap_string cmd;
RETURN_IF_FAILED(wil::str_printf_nothrow(
    cmd,
    L"\"%s\" --headless %s%s--width %hd --height %hd --signal 0x%tx --server 0x%tx",
    conhostPath,                     // e.g. C:\Windows\System32\conhost.exe
    bInheritCursor ? L"--inheritcursor " : L"",   // optional flags
    textMeasurement,                 // “--textMeasurement …” if needed
    size.X, size.Y,                 // pseudo‑console dimensions
    signalPipeConhostSide.get(),    // handle the client will use to signal
    serverHandle.get()));            // the PTY server handle

```

This command string is then passed to `CreateProcessW` to start the headless backend. Once launched, all subsequent console I/O flows through the pipes and handles specified in this command line.

## Key Source Files for conhost.exe Integration

| File | Purpose |
|------|---------|
| [`src/winconpty/winconpty.cpp`](https://github.com/microsoft/terminal/blob/main/src/winconpty/winconpty.cpp) | Resolves the `conhost.exe` path, builds the headless launch command, and manages the ConPTY server handles. |
| [`src/host/exe/exemain.cpp`](https://github.com/microsoft/terminal/blob/main/src/host/exe/exemain.cpp) | Controls the process lifetime of `conhost.exe`, setting shutdown priority to zero to ensure it exits with its clients. |
| [`src/cascadia/WindowsTerminal/main.cpp`](https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/main.cpp) | Validates architecture matching between the Terminal UI and `conhost.exe` required by the PTY driver. |
| [`src/host/ft_host/InitTests.cpp`](https://github.com/microsoft/terminal/blob/main/src/host/ft_host/InitTests.cpp) | Functional tests that launch an inbox `conhost.exe` to verify ConPTY integration. |
| [`src/host/ut_host/ConsoleArgumentsTests.cpp`](https://github.com/microsoft/terminal/blob/main/src/host/ut_host/ConsoleArgumentsTests.cpp) | Unit tests for parsing the command-line arguments (`--headless`, `--width`, etc.) passed by Windows Terminal. |

## Summary

- **`conhost.exe` provides the backend console engine** that implements screen buffers, input handling, and VT parsing for Windows Terminal.
- **It runs in headless mode** (`--headless`) when launched by the Terminal, suppressing the traditional console window while maintaining full API compatibility.
- **The ConPTY architecture** decouples the UI (`wt.exe`) from the console implementation, with `conhost.exe` acting as the bridge between the kernel driver `condrv.sys` and the Terminal frontend.
- **Process lifetimes are tightly coupled**; `conhost.exe` automatically shuts down when the Windows Terminal process exits, as managed in [`src/host/exe/exemain.cpp`](https://github.com/microsoft/terminal/blob/main/src/host/exe/exemain.cpp).

## Frequently Asked Questions

### Does Windows Terminal replace conhost.exe?

No. Windows Terminal does not replace `conhost.exe`; it repurposes it as a headless backend. While the Terminal provides the modern UI, it relies on `conhost.exe` to handle the actual console screen buffer, input processing, and VT sequence parsing through the ConPTY API.

### Why does conhost.exe still appear in Task Manager when using Windows Terminal?

When you open a tab in Windows Terminal, the application launches a headless instance of `conhost.exe` to host the pseudo-console. This process appears in Task Manager as a background process with no visible window because it runs with the `--headless` flag, handling I/O for the Terminal UI while remaining invisible to the user.

### What is the difference between conhost.exe and OpenConsole.exe in the Terminal repository?

`conhost.exe` is the inbox Windows Console Host shipped with the operating system in `C:\Windows\System32`. `OpenConsole.exe` is the development build of the same codebase within the `microsoft/terminal` repository. According to [`src/winconpty/winconpty.cpp`](https://github.com/microsoft/terminal/blob/main/src/winconpty/winconpty.cpp), Windows Terminal can launch either version depending on build configuration, but both implement the same headless backend functionality.

### Is conhost.exe required for all Windows Terminal sessions?

Yes. Every Windows Terminal session requires a running `conhost.exe` process because the ConPTY driver (`condrv.sys`) requires a console host process to manage the screen buffer and I/O operations. As noted in [`src/cascadia/WindowsTerminal/main.cpp`](https://github.com/microsoft/terminal/blob/main/src/cascadia/WindowsTerminal/main.cpp), the UI process must even match the architecture (x64/arm64) of `conhost.exe` to satisfy the driver's requirements.