Shitty: New C++23 Terminal Emulator Debuts on Show HN
08 Aug 2026
A new open-source terminal emulator, provocatively named Shitty, has debuted on Show HN, positioning itself around speed rather than memory-safety guarantees. The project is a hard fork and complete rewrite of Zutty, the terminal emulator originally created by Tom Szilagyi.
What Shitty is
Shitty is built for low latency, fast startup, and predictable resource use. It is written in C++23 and built with Clang. Rather than relying on typical CPU-bound text rendering, it keeps terminal state on the CPU but renders cells using native GPU compute backends — Vulkan on Linux and Metal on macOS.
On the compatibility side, Shitty uses UTF-8 internally and exports TERM=xterm-256color to child processes, aligning it with common terminal expectations for existing CLI tools.
Licensing in transition
The project is currently moving away from its imported GPL baseline toward an MIT-only codebase. In the interim, new contributions are dual-licensed under GPLv3-or-later and MIT. The report does not specify a timeline or milestones for completing this migration, so downstream users may face temporary licensing ambiguity until the transition is finalized.
Performance claims — and their limits
The only performance data point offered comes from a single test: 100MB of data was piped through the GUI on an Apple-silicon MacBook, using an 80x24 grid and 500 lines of scrollback. No latency figures, frame rates, or throughput numbers accompany this test, and there are no comparison benchmarks against established terminal emulators like Alacritty, iTerm2, or Kitty. As a result, performance claims are currently unverified by third parties.
What's missing today
Shitty does not currently implement bidirectional text layout or inline graphics protocols such as sixel. This could limit its usefulness for workflows involving right-to-left languages or graphics-heavy CLI applications. The report also notes no available information on the size or activity level of Shitty's contributor community.
Why founders should care
- Developers building performance-sensitive developer tools may find Shitty's native GPU rendering approach (Vulkan/Metal) worth monitoring, though its actual latency advantage over competitors remains unproven without independent benchmarks.
- The shift toward MIT licensing could make Shitty more attractive for commercial integration down the line, which may matter to founders evaluating open-source dependencies for their stacks — though the exact completion timeline is unclear.
- Because Shitty is written in C++23 without stated memory-safety guarantees, founders considering it for production tooling should likely weigh the probability of exposure to memory-safety issues common in low-level systems code, especially compared to memory-safe alternatives.
- Teams targeting internationalized or graphics-heavy CLI products should probably treat current gaps — no bidi text support, no sixel — as a near-term blocker rather than a minor limitation.
- Given the absence of comparative benchmarks, founders evaluating Shitty for adoption would be well-served to run their own tests before relying on its speed claims for critical workflows.
Bottom line
Shitty enters the terminal emulator space with a clear thesis: prioritize speed and native GPU rendering over some safety and compatibility guarantees. Its Zutty lineage offers a head start on core terminal logic, but the lack of independent benchmarks, an unfinished licensing transition, and missing features like bidi and sixel support mean the project is still early. Founders intrigued by its performance angle should treat current claims as directional rather than definitive until more data emerges.