Alacritty is a fast, cross-platform, GPU-accelerated terminal emulator written in Rust. It uses OpenGL/GLES for rendering, providing low-latency text display with support for modern terminal features like true color, ligatures, hyperlinks, and a vi-like cursor mode. The architecture is split into multiple crates: `alacritty` (binary with event loop, window management, and rendering), `alacritty_terminal` (reusable library for terminal emulation including grid, cell model, PTY abstraction, and escape sequence parsing), `alacritty_config` (configuration loading and merging), and `alacritty_config_derive` (proc-macro for failure-resistant config deserialization). The terminal core is decoupled from the GUI, making it embeddable in other projects. Configuration is TOML-based with support for imports, live reload, and CLI overrides. The project includes an IPC mechanism for runtime window creation and config updates, and a comprehensive regression test suite using recorded terminal sessions and serialized grid snapshots.
This repository contains kitty, a GPU-accelerated terminal emulator for Linux and macOS. It features a highly optimized C core for rendering, font shaping, and terminal emulation, with a Python configuration layer and a plugin system ("kittens") for features like file transfer, SSH integration, diff viewing, and hints. The codebase also includes a set of well-crafted Go libraries for CLI framework building, TUI event loops, fuzzy matching (Smith-Waterman variant), rsync delta patching, streaming base64, and color space conversions. These libraries are structurally independent and could be extracted into separate projects. The architecture is a monolith at the C/Python level with loosely coupled Go-based kittens that communicate via IPC. Build and packaging are handled by a custom system (bypy) and standard Python setup. The project is actively maintained with extensive CI, automated testing, and a responsive issue tracker.
Hyper is a cross-platform terminal emulator built on Electron, React, Redux, xterm.js, and node-pty. It provides a fast, extensible terminal experience with a plugin system that allows users to customize the UI, keymaps, menus, and behavior via npm-installed plugins. The application architecture follows a classic Electron main/renderer split: the main process handles window management, shell sessions, auto-updates, and configuration, while the renderer runs a React/Redux UI with xterm.js for terminal rendering. Communication between processes is done through a typed RPC layer. The codebase demonstrates strong engineering practices including a Redux effects middleware for side effects, a data batching mechanism to reduce IPC overhead from PTY output, and a plugin decoration pattern that wraps React components with higher-order components. The repository also includes a CLI tool for plugin management and build scripts for packaging and notarization. While the code is well-structured and professionally maintained, it carries some technical debt from deprecated dependencies like @electron/remote and seamless-immutable, and the plugin API introduces coupling risks.
WezTerm is a GPU-accelerated cross-platform terminal emulator and multiplexer written in Rust. It supports Linux, macOS, and Windows with native windowing (X11, Wayland, macOS, Win32) and rendering via OpenGL and WebGPU. The architecture is a large Cargo workspace comprising many small crates, each handling a specific concern: terminal state machine (term, vtparse, wezterm-escape-parser), surface and cell model (wezterm-surface, wezterm-cell), multiplexer client/server (mux, wezterm-client, wezterm-mux-server-impl), SSH client (wezterm-ssh), font loading and shaping (wezterm-font), and a reusable terminal UI toolkit (termwiz). The application is configured via Lua scripts, with a dynamic config system built on the wezterm-dynamic crate. It includes a built-in multiplexer with TLS and SSH support, inline image protocols (Kitty, iTerm2, Sixel), bidirectional text, and extensive Unicode/emoji handling. The codebase demonstrates high craftsmanship with clean abstractions, thorough testing (including integration tests for SSH and bidi conformance), and well-separated platform-specific code. Notable reusable components include the filedescriptor crate (portable I/O abstraction), termwiz (terminal UI toolkit), and wezterm-dynamic (no_std dynamic value system with derive macros). Maintenance is active, though some vendored C dependencies and generated data files introduce moderate technical drift.
Tabby (formerly Terminus) is a cross-platform terminal emulator built with Electron and Angular 15. It serves as a modern replacement for terminal applications like Windows conhost, PowerShell ISE, PuTTY, macOS Terminal, and iTerm. The application provides integrated SSH, Telnet, and serial clients, local shell support (cmd, PowerShell, WSL, bash, etc.), split panes with drag-and-drop, a fully customizable hotkey system, themes, and an encrypted vault for credentials. The architecture is a monorepo of Angular modules (tabby-core, tabby-terminal, tabby-ssh, etc.) that communicate through dependency injection providers. A plugin system allows third-party packages to extend functionality via well-defined abstract classes (HotkeyProvider, ProfileProvider, TerminalDecorator, etc.). The web variant (tabby-web) provides a browser-based SSH/Telnet client but lags behind the desktop version. The codebase is mature with extensive i18n support, CI/CD pipelines, and community contributions, but shows some drift with Angular 15 being several versions behind current and some legacy naming (terminus- prefix).
Notcurses is a C library for building rich terminal user interfaces (TUIs) with full pixel graphics, multimedia support, and a widget toolkit. It provides both a full-screen rendered mode and a direct mode for simple output. The library abstracts terminal capabilities (terminfo, escape sequences, pixel protocols like Sixel and Kitty) and offers a composable plane system with z-ordering, transparency, scrolling, and damage-based rendering. It includes built-in widgets such as reels, selectors, menus, progress bars, plots, trees, and tabbed containers, as well as a multimedia backend (FFmpeg/OpenImageIO) for image/video decoding and streaming. The architecture is centered around a core C library with official C++ and Python bindings, plus command-line tools (ncplayer, nctetris, notcurses-demo, notcurses-info, etc.) that demonstrate its capabilities. Input handling uses an automaton-based parser for escape sequences and mouse protocols. The codebase is substantial and well-tested, though some areas show incomplete features and platform-specific complexity.
Upterm is a terminal emulator for the 21st century, built as an Electron desktop application with TypeScript and React. It provides an IDE-like terminal experience with features such as autocompletion (for git, npm, brew, and many other commands), output prettyfiers (JSON tree, git grep, image display), multiple tabs and split sessions, a custom shell parser, and a plugin system. The application uses node-pty for pseudo-terminal management and Monaco Editor for the prompt input. It also includes a full VT100/xterm-compatible terminal emulator (Output.ts) that handles ANSI escape sequences, scrolling, cursor movements, and SGR attributes. Architecturally, Upterm follows a modular pattern with services (FontService, HistoryService, GitService, etc.) that communicate via RxJS observables, a plugin manager that registers autocompletion providers and prettyfiers, and a shell layer that parses commands and manages jobs. The codebase is well-structured and demonstrates non-obvious craftsmanship in areas like the history trie for fuzzy matching, man page parsing for flag extraction, and the terminal buffer implementation. However, the project is explicitly deprecated and unmaintained. The README states it is no longer accepting pull requests or issues. The codebase relies on outdated dependencies (Node 8.11.0, Electron 2.0.10, React 16.2.0) and has several incomplete features and security concerns (e.g., execFile with user-controlled input). Despite its quality, the technical drift is high, and the repository should be considered a reference or learning resource rather than a production-ready tool.