WezTerm: GPU-Accelerated Terminal Emulator and Multiplexer in Rust

What WezTerm Is and Who It Is For

WezTerm is a terminal emulator and multiplexer that runs on macOS, Windows, and Linux. It is implemented in Rust and uses GPU acceleration for rendering. The README describes it as a spare-time project by its author, @wez, and asks users to bear that context in mind when filing issues or expecting timely responses.

The target audience is developers who want a single terminal application that works identically across all major platforms, handles multiplexing without a separate tool like tmux, and uses GPU rendering for its display pipeline. The project is a Rust workspace with many component crates: wezterm-gui handles the graphical interface, wezterm-mux-server manages the multiplexer layer, wezterm-ssh provides SSH integration, and termwiz is a terminal library used internally.

Repository Structure and Rust Workspace Layout

The top-level `Cargo.toml` defines a Rust workspace with members including `wezterm`, `wezterm-gui`, `wezterm-mux-server`, `wezterm-ssh`, `wezterm-client`, `wezterm-surface`, `wezterm-uds`, `wezterm-escape-parser`, `wezterm-dynamic`, `wezterm-blob-leases`, `wezterm-open-url`, `termwiz`, and others.

The `config/` crate handles the Lua-based configuration system that WezTerm is known for. The `bidi/` crate handles bidirectional text rendering. The `term/` crate provides terminal emulation logic, and `vtparse/` handles VT/ANSI escape sequence parsing.

Documentation lives in `docs/` and is built with MkDocs via `ci/build-docs.sh`. The user-facing guide is published at wezterm.org and is not duplicated inside the repository itself. All installation instructions, key bindings, and configuration references are at that external site rather than in the README.

Building WezTerm from Source

The README directs users to wezterm.org/installation for prebuilt binaries. For developers building from source, the Makefile provides the standard targets:

cargo build -p wezterm
cargo build -p wezterm-gui
cargo build -p wezterm-mux-server

The `BUILD_OPTS` variable passes additional flags if needed. The test suite runs with cargo-nextest:

cargo nextest run

Two crates have additional test targets in the Makefile: `wezterm-escape-parser` and `wezterm-cell` and `wezterm-surface` have separate `cargo check` invocations listed. The `strip-ansi-escapes` crate is also built as part of the standard Makefile `build` target.

Formatting uses nightly Rust: `cargo +nightly fmt`. The Cargo workspace uses resolver version 2.

Release Cadence and Maintenance Reality

The most recent tagged release in the repository is `20240203-110809-5046fc22`, published on 2024-02-03. Two other releases from January 2024 are also listed. Despite this gap in releases, the repository received its most recent push on 2026-09-28, indicating ongoing development work.

This creates an unusual situation: the source tree is actively changed, but users relying on tagged releases or prebuilt installers from the official site are working from a build that is over two years old. The README acknowledges the project is maintained in spare time and asks users to use GitHub Discussions and the Matrix room for questions rather than expecting fast issue turnaround.

Sponsorship via GitHub Sponsors, Patreon, Ko-Fi, and Liberapay is mentioned as a way to support the project and validate the time invested in it.

Multiplexer Support and SSH Integration

WezTerm includes a built-in multiplexer, which distinguishes it from terminal emulators that are purely display clients for external tools like tmux or screen. The `wezterm-mux-server` crate implements the server-side of this multiplexer, and `wezterm-client` handles the client side. The SSH integration lives in `wezterm-ssh`.

The Cargo workspace excludes `termwiz/codegen` and `wezterm-char-props/codegen` from the default build, indicating these are code generation tools run separately rather than part of the runtime. The `wezterm-uds` crate suggests Unix domain socket communication between the client and server components.

All specifics about configuring the multiplexer, SSH domains, and pane management are documented at wezterm.org rather than in the repository README, so users need to cross-reference the external documentation site.

WezTerm Versus Alacritty

Alacritty is another GPU-accelerated terminal emulator written in Rust. Unlike WezTerm, Alacritty is a terminal emulator only; it deliberately excludes multiplexer features and tab management from its scope, deferring those to external tools.

WezTerm includes multiplexer, SSH, and tab support built in. The trade-off is complexity: WezTerm's Rust workspace contains many more crates than Alacritty's. Users who want a minimal, compositor-delegating terminal without extra features may find Alacritty more predictable. Users who want one binary that handles tabs, panes, multiplexing, and remote sessions in a single GPU-rendered process are the target for WezTerm.

The license for WezTerm is listed as NOASSERTION in the repository metadata. The LICENSE.md file is present in the repository. Prospective users should review its contents and verify the license terms before adopting WezTerm in a commercial context.

Editorial conclusion

WezTerm suits developers who want a GPU-rendered, multiplexer-capable terminal on any of the major platforms and are comfortable with the trade-off of a spare-time project. The last tagged release was from February 2024, even though commits continue in 2026. For anyone who needs a stable release cadence or official support, that gap is worth verifying before committing to WezTerm as a daily driver. Check the GitHub Discussions and the Matrix room to assess how quickly current issues are being resolved before adopting it in a team environment.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. wezterm/wezterm on GitHub