Ratty: GPU-Rendered Terminal with 3D Graphics (2026)

Ratty, a GPU-rendered terminal emulator that supports inline 3D graphics, launched today and is trending #1 on Hacker News with 530 points. Built by Orhun Parmaksız in Rust and inspired by TempleOS, Ratty lets developers embed 3D models directly into terminal output through a custom Ratty Graphics Protocol. Toggle between traditional 2D terminal view and an immersive 3D perspective where the entire terminal becomes a navigable 3D canvas—powered by Ratatui for UI, Vello for GPU text rendering, and Bevy for 3D scene management.

If you’ve ever opened Blender just to preview a .glb file in a directory, you get why this matters.

GPU-Rendered Terminal with 3D Graphics

Ratty uses a three-layer architecture that bridges traditional terminal emulation with modern 3D graphics. The first layer handles terminal fundamentals: portable-pty manages pseudo-terminal operations while vt100 parses escape sequences like any standard terminal emulator. Nothing revolutionary here.

The second layer is where things get interesting. Ratatui manages the UI buffer on the CPU, then hands off to Parley and Vello for GPU-based text shaping and rendering. After Vello performs its GPU magic, data gets read back from GPU to RGBA format—a temporary compromise the developer notes could be optimized by keeping everything GPU-resident.

The third layer completes the picture: Bevy game engine combines the 2D terminal output with 3D objects, handling both traditional 2D view and the immersive 3D perspective. This architecture follows TempleOS‘s philosophy of freely mixing text, images, and 3D models at a low level, but with modern Rust and GPU acceleration.

Practical Use Cases Beyond the Novelty

The Hacker News discussion (174 comments) cuts through the “but why?” skepticism quickly. The most compelling use case? Browsing directories containing 3D models—.obj, .glb, .stl, .step files—and previewing them inline without launching Blender or CAD software. That’s not a gimmick, that’s workflow friction removed.

Data scientists want this for 3D plotting. Instead of generating static PNG files or opening matplotlib windows, they could render interactive 3D plots as part of analysis scripts. Game developers see potential for terminal-based 3D game prototyping. Debugging benefits too: visualizing tree structures, graphs, neural networks, or spatial data as actual 3D representations during debugging makes complex relationships visible.

The skeptics compare it to Compiz’s wobbly windows—flashy but ultimately abandoned. They have a point about maturity (this is v0.2.0), but the focused use case of “3D model file browsing” is specific enough to sustain a niche even if mainstream terminals never adopt RGP.

How to Use Ratty Graphics Protocol

RGP (Ratty Graphics Protocol) provides commands to register 3D assets, place them at terminal coordinates, and control animation, scaling, and color. Basic usage looks like this:

# Register a 3D model asset
RGP register_asset spaceship.glb asset_id=ship

# Place it at terminal coordinates (column 10, row 5)
RGP place_object asset_id=ship x=10 y=5 z=0 scale=2.0

# Animate rotation
RGP animate asset_id=ship rotation_y=360 duration=2.0

The companion ratatui-rgp widget library lets existing Ratatui TUI apps add 3D graphics without rebuilding from scratch. Ratatui’s ecosystem includes 3,700+ packages and 26.3M downloads, so the integration potential is substantial. If your TUI app would benefit from spatial visualization, the widget provides a straightforward path.

Installation and Basic Usage

Ratty requires a Rust toolchain and GPU with wgpu/compute shader support. Installation is straightforward for Rust users:

# Install via Cargo
cargo install ratty

# Or on Arch Linux
pacman -S ratty

# Launch and toggle to 3D mode
ratty
# Press Ctrl+Alt+Enter to switch to 3D view

Toggle between 2D and 3D modes with Ctrl+Alt+Enter. The Ctrl+Alt+M shortcut activates Mobius warp mode, which is fun for demos but disorienting for actual work. Customize behavior via ~/.config/ratty/ratty.toml—you can replace the spinning rat cursor with your own .glb file, adjust animation speeds, and configure visual properties.

Inspired by TempleOS and Terminal Renaissance

Ratty is explicitly inspired by TempleOS, Terry Davis’s operating system that featured inline 3D graphics in its command-line environment. Davis built TempleOS with 640×480 16-color graphics and included “Eagle,” a flight simulator demonstrating the mixing of text and 3D. His stated goal was to “recapture the rapidly changing environment of the Commodore 64 era” and encourage “odd-ball software.”

As Orhun Parmaksız explains: “Rather than rendering 2D graphics in a 3D space, I wanted to render 3D graphics in a 2D terminal, following what Terry Davis did with TempleOS.” Ratty modernizes this philosophy using Rust, GPU acceleration, and the Bevy game engine. It’s part of a broader terminal renaissance—Kitty, Alacritty, Warp, and Ghostty are all pushing terminal capabilities beyond basic text scrolling.

Limitations and Considerations

Ratty is v0.2.0 released today. Expect bugs, API changes, and missing features. The GPU dependency means it won’t work over SSH—remote work is common, so this limits accessibility for distributed teams. The current version lacks VSync synchronization, which can cause screen tearing on some systems.

The CPU↔GPU memory transfer architecture isn’t fully optimized yet. Data gets read back from GPU to CPU, then sent back to GPU for final composition. A fully GPU-resident pipeline would be more efficient, but that’s future work.

Use Ratty for specific visualization tasks, not as a daily driver replacement for Alacritty or Kitty. The community skepticism about “waste of resources” isn’t entirely unfounded—GPU acceleration for text rendering is overkill unless you’re actually using the 3D features.

Key Takeaways

• Ratty brings real 3D graphics to terminals through a custom Ratty Graphics Protocol, the first terminal emulator to do this
• Best use case: browsing directories with 3D models (.obj, .glb, .stl) and previewing them inline without external viewers
• Architecture combines Ratatui (TUI), Vello (GPU text), and Bevy (3D engine) in a three-layer rendering pipeline
• Requires local GPU with wgpu/compute shader support; won’t work over SSH
• Experimental v0.2.0 maturity—use for visualization experiments, not production infrastructure
• Inspired by TempleOS’s philosophy of mixing text and 3D, part of broader terminal renaissance
• Install: cargo install ratty or pacman -S ratty (Arch Linux)