Ratty Terminal Emulator Brings Inline 3D Graphics to the CLI

I've spent a lot of time inside terminals. Most of the time it's text, maybe some ANSI art or a TUI app. But 3D graphics? That's new. Ratty (ratty-term.org) is a terminal emulator that renders 3D objects inline, right alongside your shell prompt. It uses GPU acceleration to do it, and it's not a gimmick — it's a serious rethinking of what a terminal can be.

How Ratty Terminal Emulator Works

Ratty is an open-source terminal emulator written in Rust. It uses OpenGL (via GLFW) to render the terminal grid, but it also exposes a simple API that lets programs draw 3D scenes directly in the terminal window. Think of it like cat on a .glb file and seeing the model spinning inline. The project's README shows a rotating 3D rat (the mascot) right in the terminal. The rendering is performed on the GPU, so it's fast and smooth. Ratty also supports standard terminal features like multiple tabs, Unicode, and 24-bit color. It's not an X11 or Wayland terminal — it uses its own windowing via GLFW, so it works on Linux and macOS (Windows support is planned).

Community Reactions to Ratty's GPU-Accelerated 3D

The HN thread is full of nostalgia and excitement. One commenter wrote:

"UNIX still trying to catch up with Xerox workstations in the REPL experience, or general Lisp machines for that matter. Inline graphics from 1981" — linking to a video of a Xerox Alto with a graphical REPL.

Another user asked about rendering capabilities, pointing out that most solutions for 2D images in terminals are "pretty bad" and wondering if Ratty can do better. The sentiment is that this is a step toward making the terminal more expressive without resorting to a full GUI. There's also lighthearted banter: "Can I really render a 3D rat on my terminal? If I can then I'm sold." The project clearly taps into a desire for richer interactivity in the command line.

Why Ratty's Approach Matters

Ratty isn't the first attempt to put graphics in the terminal. There's Sixel, there's ReGIS, there's the whole framebuffer console approach. But those are limited by escape sequences or lack of hardware acceleration. Ratty's approach is different: it owns the window and uses the GPU. That means it can do real-time 3D with lighting and shading. The trade-off is that it's not a drop-in replacement for xterm — you have to write programs that use its specific API. But for tools that benefit from in-context visualization (like data science plots, CAD previews, or game dev debugging), this is huge.

The comparison to Xerox workstations and Lisp machines is apt. Those systems had graphical REPLs where you could manipulate images and geometry inline. We lost that when we moved to character-cell terminals and then to web UIs. Ratty is a move toward reclaiming that fluidity. It's not trying to be a web browser (unlike some other terminal projects). It's specifically about augmenting the text terminal with high-performance graphics where it makes sense.

Building CLI Tools with Ratty's 3D API

If you're building CLI tools or dev tooling, Ratty opens up new interaction models. Imagine:

• A git log that shows a 3D commit tree you can spin and zoom
• A ps that shows CPU usage as a heatmap on a 3D model of your CPU die
• A cargo build that shows a 3D progress bar that's actually a rotating gear

More practically, you could use it for data visualization. Here's a minimal example (from the Ratty docs) that renders a rotating cube:

use ratty::*;

fn main() {
    let mut term = Ratty::new().unwrap();
    loop {
        term.clear();
        let scene = Scene::new()
            .add(Mesh::cube(1.0).color(Color::rgb(0.2, 0.5, 0.8)))
            .rotate(f64::sin(time) * 0.02, 0.01, 0.0);
        term.render(&scene);
        std::thread::sleep(Duration::from_millis(16));
    }
}

The API is Rust-native, but they could expose it via IPC so other languages can use it. The key is that this runs inside the same window as your shell, not a separate viewer. That's the differentiation.

The rendering capabilities aren't just for 3D. As one HN commenter noted, it should also handle high-quality 2D images well, since it's using GPU blitting. So if you've been frustrated with cat-ing images via chafa or viu (which use Sixel or Kitty's graphics protocol), Ratty could offer a more reliable, higher-performance alternative. The only limit is that each terminal instance is its own window — it doesn't work over SSH because the rendering is local and GPU-bound. That's a fundamental constraint: remote sessions can't tap into the local GPU easily. But for local work, that's fine.

Is Ratty Terminal Emulator Right for You?

If you're a developer who lives in the terminal and builds CLI tools, yes. Ratty gives you a new primitive for visual output that goes beyond ASCII art and emoji. If you need to display 3D models, plots, or animations inline without opening a separate application, this is worth watching. If you only use SSH or tmux over remote connections, Ratty's local-only approach means you won't benefit directly right now. But the ideas it introduces could influence broader terminal standards in the future. For terminal-tooling builders, Ratty is a project to watch. It brings rich visual feedback without leaving the command line.

---

Links: HN thread, Ratty website, Xerox Alto demo, Sixel, Kitty terminal graphics protocol, GLFW