Shitty rewrites Zutty into a GPU-accelerated, memory-unsafe terminal

A Show HN post introduces Shitty, a terminal emulator whose executable is named st. The author describes it as a hard fork and complete rewrite of Zutty, the terminal originally created by Tom Szilagyi; Shitty keeps that lineage but replaces the renderer, platform integration, testing strategy and project identity. It is written in C++23 and built with Clang, keeps terminal state on the CPU, and renders cells through native GPU backends: Vulkan on Linux, Metal on macOS. The README frames it plainly as fast and memory-unsafe: "Blazingly fast. Memory-unsafe and faster than yours." The project describes, but does not publish figures for, a benchmark that cats 100MB of data through each terminal's GUI on an Apple-silicon MacBook, with every terminal equalized first to Menlo 12pt, the same 14x28px cell, an 80x24 grid, and 500 lines of scrollback, taking the best wall time of three runs; the README states the methodology and points to a dev/compare.py script that reproduces it, but the extracted text does not carry the actual timing results. One named comparison point is included: on the random-bytes stress test (invalid UTF-8 designed to hit the parser's worst case), the README says kitty does not draw the payload at all and instead reacts to the embedded escape sequences with title changes and bells. Shitty claims a conformance suite of more than 5,000 tests, harvested from over a dozen other terminals' test suites, including kitty, esctest, xterm's vttests, vttest, tack, libvterm, libtsm, alacritty, ghostty, contour, konsole and mosh, driven black-box through a real PTY. The parser is described as fuzzed with committed corpora, with cat /dev/urandom treated as a routine benchmark rather than a crash risk. Feature claims include grapheme-cluster-aware Unicode handling (emoji sequences, variation selectors, combining marks, wide CJK), a self-contained binary with embedded fallback fonts that starts with no fonts installed, and sandboxing by default: applications cannot read terminal selections or drive the host window unless explicitly allowed. Protocol support spans VT52 through VT5xx controls and common xterm extensions, primary and alternate screens with scrollback reflow, 16-colour through 24-bit colour, several keyboard and mouse protocols, and OSC 52/OSC 8 clipboard and hyperlink handling. The README states two things Shitty does not do: bidirectional text layout and inline graphics protocols such as sixel. On licensing, the project is moving from an imported GPL codebase to an MIT-only one; new contributions are dual-licensed GPLv3-or-later and MIT, but distribution of the combined work remains subject to the GPL while GPL-only imported material stays in the tree, and no timeline for completing the move is given. Installation is offered via a Homebrew tap (brew install pg83/tap/shitty) on macOS, a Nix flake (nix build, nix run, nix develop), or manual build; Linux additionally needs FreeType, HarfBuzz, Wayland client headers, xkbcommon and Vulkan headers and loader, while macOS needs SPIRV-Cross and draws on CoreText, Cocoa, Metal and IOSurface from the system SDK.

Key facts

Shitty (binary name st) is a hard fork and complete rewrite of Tom Szilagyi's Zutty, written in C++23 and rendered via Vulkan on Linux or Metal on macOS.
The README claims a conformance suite of more than 5,000 tests harvested from over a dozen terminal test suites, including kitty, alacritty, ghostty and konsole.
A described benchmark cats 100MB through each terminal's GUI with matched settings (Menlo 12pt, 14x28px cell, 80x24 grid, 500-line scrollback), but the extracted text gives the setup, not the actual timing numbers.
On a random-bytes stress payload, the README says kitty does not render it and instead only reacts with title changes and bells.
The project is mid-migration from an imported GPL codebase to MIT-only; distribution stays GPL-bound while GPL-only imported material remains in the tree, with no completion date stated.

Why it matters

GPU-backed rendering plus a large imported conformance suite is a specific pitch in a crowded field of terminal emulators (kitty, alacritty, ghostty, contour and others), and the project positions itself directly against them rather than as a generic new entrant. The one concrete comparison the README offers, kitty failing to draw a random-bytes payload it was fed, is a correctness claim about a named competitor, not a speed number.

Who it affects

Developers and other terminal power users on Linux (Wayland, Vulkan) or macOS (Metal) who care about startup time, low latency and predictable resource use, and who are willing to run a young, explicitly memory-unsafe C++ codebase for it.

How to use it

On macOS, install via the Homebrew tap brew install pg83/tap/shitty, which tracks the latest release; a portable st-darwin-arm64.tar.gz binary is attached to every GitHub release. On Linux and elsewhere, build from source (C++23 via Clang, Python 3, Ragel 6, glslangValidator, librsvg, pkg-config, utf8proc 2.9+, plus FreeType, HarfBuzz, Wayland headers, xkbcommon and Vulkan headers/loader) or use the provided Nix flake (nix build, nix run, nix develop). The executable is st; font, geometry, scrollback size and keyboard/mouse protocol options are set via command-line flags or the SHITTY_FONT_SIZE environment variable.

Ed. The executable is named st, which is already the name of suckless's terminal in most package managers. Anyone who has both installed gets to resolve that themselves.

How solid is it

The author cites over 5,000 tests pulled from more than a dozen other terminals' conformance suites and run black-box through a real PTY, plus a fuzzed parser tested against committed corpora and treated as robust even against cat /dev/urandom. What the extracted text does not include is the actual benchmark result: the 100MB-cat comparison describes only the equalized measurement setup, not the wall-clock numbers or the full list of terminals measured against, so the speed claim in the tagline is not independently checkable from this text alone.

Risks and caveats

The project describes itself as memory-unsafe by design, a tradeoff made explicitly for speed rather than a hidden defect. Licensing is unsettled: while the stated goal is an MIT-only codebase, GPL-only material imported from the original Zutty snapshot remains in the tree, which keeps the combined work under GPL for now, and no date is given for when that will change. The README also states plainly that Shitty does not currently support bidirectional text layout or inline graphics protocols such as sixel, and some older DEC and xterm extensions are intentionally left unsupported.

“Blazingly fast. Memory-unsafe and faster than yours.”

— Shitty's README