orhun/ratty

A GPU-rendered terminal emulator with inline 3D graphics 🐀🧀

Source code at GitHub https://ratty-term.org/

{
  "createdAt": "2026-04-20T21:22:09Z",
  "defaultBranch": "main",
  "description": "A GPU-rendered terminal emulator with inline 3D graphics 🐀🧀 ",
  "fullName": "orhun/ratty",
  "homepage": "https://ratty-term.org/",
  "language": "Rust",
  "name": "ratty",
  "pushedAt": "2026-06-05T11:24:11Z",
  "stargazersCount": 2831,
  "topics": [
    "3d",
    "3d-graphics",
    "command",
    "gpu",
    "gpu-rendering",
    "graphics",
    "ratatui",
    "ratty",
    "rust",
    "templeos",
    "terminal",
    "terminal-emulator",
    "terminal-emulators",
    "terminal-graphics"
  ],
  "updatedAt": "2026-06-06T01:05:07Z",
  "url": "https://github.com/orhun/ratty"
}

Ratty: A GPU-rendered terminal emulator with inline 3D graphics 🧀
^{Inspired by TempleOS | Built with Rust & Ratatui}

“Rodent-obsessed developer creates Ratty to bring 3D graphics to the command line” - The Register
”This New Terminal is Absurd (But Totally Fun)” - It’s FOSS
”10 weird OSS projects you need right now… ” - Fireship

Features

Spinning rat cursor ([customizable]!(#changing-the-cursor))
Traditional 2D and [new 3D mode]!(#3d-mode)!
[Inline 3D objects]!(#inline-3d-objects)
[GPU-backed text rendering]!(#rendering-pipeline)
Image support (via Kitty Graphics Protocol >:()

▶️ Watch the demo video here!
📚 Read the behind the scenes blog post here!

3D mode

Ever wondered what’s behind the terminal? Press Ctrl+Alt+Enter!

Installation

Requirements:

A GPU / graphics stack supported by Bevy and wgpu
Melted cheese (optional but recommended)

crates.io

cargo install ratty

Arch Linux

sudo pacman -S ratty

Binary releases

Prebuilt binaries are available on the GitHub releases page for direct download.

From Git

Requirements:

Rust toolchain with Cargo
on Bazzite / Bluefin: sudo rpm-ostree install gcc fontconfig-devel wayland-devel (then reboot)
on Debian / Ubuntu: sudo apt-get update ; sudo apt-get install gcc pkgconf libfontconfig-dev libwayland-dev
on Fedora: sudo dnf install gcc fontconfig-devel wayland-devel

cargo install --git https://github.com/orhun/ratty

Configuration

The default configuration file is available in [config/ratty.toml]!(config/ratty.toml).

You can copy this file to $HOME/.config/ratty/ratty.toml and customize it.

Changing the cursor

[cursor.model]
path = "CairoSpinyMouse.obj"
scale_factor = 6.0
brightness = 0.5
x_offset = 0.5
plane_offset = 18.0
visible = true

[cursor.animation]
spin_speed = 1.4
bob_speed = 2.2
bob_amplitude = 0.08

For [cursor.model.path]!(config/ratty.toml), Ratty supports both .obj and .glb assets.

Other useful cursor fields are:

scale_factor: scales the model relative to the terminal cell size
brightness: adjusts the cursor material brightness
x_offset: shifts the cursor model horizontally inside the cell
plane_offset: pushes the cursor away from the warped terminal surface in 3D mode
visible: show the custom 3D cursor model instead of only the terminal cursor

Key Bindings

Key	Action
`Ctrl`+`Alt`+`C`	Copy selection
`Ctrl`+`Alt`+`V`	Paste clipboard
`Ctrl`+`Alt`+`Enter`	Toggle 2D / 3D mode
`Ctrl`+`Alt`+`M`	Toggle Mobius mode
`Ctrl`+`Alt`+`Up`	Increase warp
`Ctrl`+`Alt`+`Down`	Decrease warp
`Alt`+`PageUp`	Scroll one page up
`Alt`+`PageDown`	Scroll one page down
`Alt`+`Up`	Scroll one line up
`Alt`+`Down`	Scroll one line down
`Ctrl`+`=`	Increase font size
`Ctrl`+`-`	Decrease font size
`Ctrl`+`Alt`+`0`	Reset font size

Inline 3D objects

Ratty uses its own protocol, the [Ratty Graphics Protocol]!(protocols/graphics.md), to place inline 3D objects in terminal space.

RGP supports:

registering .obj and .glb assets by path
placing them at terminal cell anchors
animation, scale, color, depth and other attributes

There is a Ratatui widget called ratatui-rgp available in [widget/]!(widget/) if you want to build your own terminal applications that involve inline 3D objects.

Examples

[Big rat]!(widget/examples/big_rat.rs)

Places a single oversized rat directly in your terminal:

[Document]!(widget/examples/document.rs)

TempleOS-inspired document demo with editable text and embedded inline 3D objects:

[Draw]!(widget/examples/draw.rs)

Split-pane drawing demo with a 2D canvas on the left and a live 3D preview on the right:

Apps

Here are some applications explicitly built around Ratty’s Graphics Protocol:

ComChan

A blazingly fast serial monitor with plotter TUI and 3D telemetry

Architecture

Rendering pipeline

The terminal surface currently uses ratatui for the UI buffer, parley_ratatui for text shaping/rendering and Bevy for scene presentation.

Current workflow:

Ratatui buffer on CPU
Parley/Vello renders on GPU
Read back RGBA to CPU
Copy into Bevy image
Bevy presents that image in 2D and 3D

Terminal drawing is GPU-rendered through Parley/Vello, but the main terminal image still crosses back through CPU memory before Bevy presents it. This is a GPU-powered bridge, not a fully GPU-resident shared-texture path.

If the project later moves to a fully GPU-resident path, that will require a dedicated Bevy render integration that renders into a Bevy-owned texture on Bevy’s render-world device instead of using the current readback bridge.

Endorsements

“This is like a legitimately cool project but also I just spent like 20 minutes adjusting the config for the rat spinning to see him spin faster and more erratically and it cracked me up” - @vimlena.com

“These kinds of experiments are where creativity is born.” - @Coko7
“No comments. Just support.” - @Raphamorim (creator of Rio terminal)
“tetro-tui running in Ratty” - @Strophox

License

All code is licensed under The MIT License.

^{🦀 ノ( º \_ º ノ) - respect crables!}

Credits

Ratty logo designed by @Strophox & @Harunocaksiz

Copyright

^{The author does not have a rat under the hat!}