10 Terminal Projects You’ve Probably Never Heard Of

If you follow terminal development, you've no doubt heard of Ghostty, Kitty, WezTerm or Warp.

But besides those well-known names, a strange little ecosystem has emerged. People are building terminals with AI agents as first-class citizens. Others are rendering 3D objects inside the terminal. Some are trying to turn the terminal into an IDE. Still others strip it back to the bare minimum or preserve DOS-era workflows.

Now, most of these projects will never replace your daily driver. Indeed, some of them you probably shouldn't. But that's not the point. The point is that these projects are worth knowing about, because they're quietly redefining what a "terminal" is even allowed to be.

Here are ten of the more obscure, niche, and emerging ones, grouped by what they're actually trying to prove.

AI-first / agentic terminals

In essence, you could say that every modern terminal is just an application trying to emulate a 1978 VT100 in a faster or fancier way. Yet some projects are trying to do much more. They're trying to redefine the terminal around AI agents as first-class citizens, not just another process writing to stdout.

Terax

Terax — Terminal-first AI-native dev workspace Terax is a lightweight AI terminal with a built-in editor, AI agents, voice input, and live web preview. 7 MB on disk…

Terax, for instance, squeezes a terminal, an editor, a file explorer, AI agents, and a live web preview into one Rust + Tauri + React app — and somehow keeps the footprint down to around 7MB. What makes it interesting isn't the AI itself; it's the "local-first" philosophy underneath it. AI diffs can be reviewed before they ever touch disk, which is exactly the kind of trust boundary agentic tools tend to skip.

Embedded content

Think of it as a lightweight Cursor/Warp hybrid crossed with a tiling terminal IDE — minus the Electron weight. It's the terminal as the primary orchestration layer for coding agents, not a side panel bolted onto one.

teru 照

teru — AI-first terminal emulator. 1.6MB. Zero GPU. teru is an AI-first terminal emulator built in Zig. 1.6MB single binary. No GPU. Built-in multiplexer, native Claude…

Teru is extremely niche, and I mean that as a compliment. It's written in Zig, CPU-rendered via SIMD with no GPU involved at all, and ships its own multiplexer, process-graph visualization, and a native "AI agent protocol" with MCP server integration.

Whereas mainstream terminals optimize for rendering, latency, tabs, and font shaping, teru optimizes for something else entirely: coordinating multiple AI agents at once — deciding which one runs where and how they hand off work to each other. It's effectively treating the terminal as an operating environment for autonomous agents rather than a text renderer — tmux, terminal, agent runtime, and compositor merged into one executable.

Herdr

Herdr: one terminal for the whole herd Herdr is to coding agents what tmux is to terminals: an agent multiplexer that runs where your agents run. Real panes…

If Terax and teru are terminals with AI bolted deep into their core, Herdr flips the framing entirely: it's not a terminal at all, it's an agent multiplexer — tmux, but for coding agents instead of shells. Real panes, real processes, except each pane is an agent doing its own thing, running wherever your agents happen to run.

It's a small but telling glimpse of where this whole space is headed: once you have more than one agent working for you at once, you need the same primitives we've used for decades to juggle multiple shells. We just didn't expect tmux's spiritual successor to be herding agents instead of panes.

wterm

wterm | Terminal Emulator for the Web A terminal emulator for the web. Renders to the DOM, powered by Zig/WASM.

Vercel recently open-sourced… a browser-native terminal! It's a strange sentence to type, but here we are! wterm isn't an app you launch — it's a terminal-emulator library: a Zig core compiled to WASM, rendering to the real DOM instead of a canvas, meant to be dropped into a Javascript app the way people currently reach for xterm.js. No native binary, no install, and DOM rendering means you get text selection, find, and accessibility for free instead of having to reimplement them.

That distinction — library, not app — matters more than it sounds once you consider where a lot of agentic workflows are heading: ephemeral cloud sandboxes, ChatGPT-style code execution panes, CI environments you poke at even from a phone. Every one of those needs a terminal embedded in a web page, not a binary someone has to install first.

Graphics & rendering experiments

A different subculture entirely are those terminals that treat the terminal as a graphics medium first, and a text stream second.

Ratty

Ratty — A GPU-rendered terminal emulator with inline 3D graphics 🐀🧀 R tty is a GPU-rendered terminal emulator with a spinning rat cursor, multiple 3D presentation modes and support for…ra

A very good case in point is Ratty. This is probably the closest thing to "what if TempleOS met modern GPU rendering?" in this entire list — a comparison made by the author himself. It's GPU-rendered, built on Ratatui, supports the Kitty graphics protocol, and — I promise I'm not making this up — has a dedicated 3D terminal mode, inline 3D objects, and a literal rat cursor.

It's intentionally playful and anti-minimalist, and it's part of a growing question a lot of terminal authors are quietly asking: why are terminals still pretending graphics don't exist? You can trace a line from Sixel through the Kitty graphics protocol, notcurses (see below), and terminal shaders, straight toward terminals becoming semi-graphical environments. Ratty just goes all-in on this!

Rio Terminal

Meet Rio | Rio Terminal A modern terminal for the 21st century.

Rio is a Rust and WGPU-based terminal experimenting with rendering architecture and animation in ways that feel more like a graphics engine side project than a terminal emulator roadmap. It's quieter about it than Ratty, but the underlying drive is the same: rendering doesn't have to be boring just because the content is text.

Contour Terminal Emulator

Contour Terminal Emulator Technical Landing Page for Contour Terminal Emulator

Contour is the more disciplined sibling in this category: a C++/OpenGL terminal that pairs GPU rendering with an unusually strict adherence to the decades-old escape-sequence protocol every terminal is supposed to speak under the hood (the stuff that makes cursor movement, colors, and screen redraws behave correctly, even in obscure edge cases most emulators quietly get wrong). Where Ratty and Rio are chasing "what's possible", Contour is chasing "what's correct, but fast" — proving that GPU rendering and protocol purity aren't mutually exclusive.

Minimal / framework experiments

Several recent terminals aren't really terminal projects first — they're proving out UI frameworks. The terminal simply happens to be an ideal stress test: fast rendering, text shaping, scrolling, input latency and platform integration all in one application.

Termy

Termy — A fast, native terminal Edit description

Termy is a minimal terminal built on Zed's GPUI framework — interesting less for what it does and more for what it's testing: whether GPUI holds up outside of Zed itself, in a smaller, intentionally clean Rust-native UI. A lot of the newer terminal projects out there are really UI framework experiments wearing a terminal as a costume, and Termy is a great example of that.

Retro & protocol-purist terminals

And then there's the other end of the spectrum entirely: terminals that aren't reinventing anything, they're preserving something many of us forgot existed.

Tera Term

GitHub — TeraTermProject/teraterm Contribute to TeraTermProject/teraterm development by creating an account on GitHub.

Tera Term is a classic, Japanese-origin terminal emulator that's still heavily used in embedded and serial-communication circles. It's not trying to be exotic — it's just quietly preserved serial-era workflows, macro scripting, and telnet/SSH hybrid culture long after most of us stopped thinking about such things. A lot of "retro" terminal experimentation elsewhere in this list still traces its lineage back to tools like this one.

Foot

foot foot - A fast, lightweight and minimalistic Wayland terminal emulator

foot, on the other hand, is the purist's answer to the graphics arms race happening everywhere else in this list. It's written in C, built for Wayland from the ground up rather than bolted onto it, and deliberately skips GPU acceleration in favor of efficient CPU-side rendering — the bet being that for a terminal, low input latency and a tiny memory footprint matter more than fancy pixel pipelines.

Where Ratty and Rio ask "how much can we add to a terminal", foot asks the opposite question: how little do you actually need? It's not a museum piece — it's actively maintained and genuinely usable as a daily driver today — but it's proof that the "do one thing, do it fast" school of terminal design is still very much alive alongside all the GPU experimentation.

Honorable mentions

Two more worth knowing, even though they didn't make the top ten as terminals in their own right. mlterm was uncannily ahead of its time for something this old — vertical text, multiple encodings, inline images, Sixel, multilingual rendering — it feels like a forgotten "future terminal" from 2008.

mlterm(Multi Lingual TERMinal emulator) Download mlterm(Multi Lingual TERMinal emulator) for free. mlterm is a multi-lingual terminal emulator , which supports…

And notcurses isn't a terminal emulator at all, but a library enabling video, sprites, compositing, and high-color TUIs — a huge chunk of the terminal graphics culture you see in this list traces back to it.

GitHub — dankamongmen/notcurses: blingful character graphics/TUI library. definitely not curses. blingful character graphics/TUI library. definitely not curses. — dankamongmen/notcurses

Embedded content

Where terminal development is heading

Today's weird terminal projects are tomorrow's mainstream features.

Zoom out and most of these projects are converging in the same direction. The traditional terminal model — a stream of glyphs, a PTY (pseudo-terminal) abstraction, ANSI escape codes — is remarkably durable, yet surprisingly limiting. So people are pulling at every loose thread: graphics, shell integration, structured panes, AI-native protocols, process-aware terminals, terminal-as-IDE, terminal-as-agent-runtime.

Watching these projects feels a little like the browser experimentation of the early 2000s, when everyone suddenly realized the existing abstraction might not be the final form after all. Most of the projects in this article won't become your next daily terminal.

But if history is any guide, today's weird experiments often become tomorrow's defaults. GPU rendering, shell integration, image protocols and AI-assisted workflows all started as niche ideas before quietly making their way into mainstream terminals. That's why it's worth paying attention to the fringe: not because these projects will replace Ghostty or Kitty, but because they're often the first glimpse of where terminal development is heading next.

If you like my terminal content, check out Terminal Sessions for more!

Terminal Sessions A publication for terminal enthusiasts. Discover productivity tips, customization ideas, hidden gems, and approachable…

Hi! 👋 I'm Tom. I'm a software engineer and a stress and burnout coach. If you want to get in touch, check out https://tomdeneire.be