← Back to Blog

Ratty — The GPU-Powered Terminal Emulator with Inline 3D Graphics That's Taking the Command Line Into the Third Dimension

2026-05-19

Ratty — The GPU-Powered Terminal Emulator with Inline 3D Graphics

For decades, the terminal has been the domain of blinking green text, monospaced fonts, and a strict adherence to two dimensions. Then Orhun Parmaksız — the prolific Rust developer behind tools like bat, gitoxide, and tokio-console — decided to ask a question nobody asked: what if your terminal had a third dimension?

Meet Ratty (🐀🧀), a GPU-rendered terminal emulator that brings inline 3D graphics straight to your command line. It's built on Rust, Ratatui, and the Bevy game engine, and it's taken the open-source world by storm — racking up over 2,100 GitHub stars in under a month, with coverage from The Register and It's FOSS.

Why Is Ratty Trending?

Ratty hit the scene in late April 2026 and has been riding a wave of viral attention for three reasons:

  1. It's genuinely novel — nobody has shipped a terminal emulator with first-class 3D support before. Ratty renders a spinning 3D rat as your cursor and lets you toggle into a full 3D mode where the terminal surface warps and curves like a TempleOS-inspired display.
  2. It's from a respected creator — Orhun is the author of bat (a cat clone with syntax highlighting), and a core contributor to Ratatui. The Rust community trusts the quality.
  3. It's not just a gimmick — the Ratty Graphics Protocol (RGP) lets developers embed actual 3D .obj and .glb models inline in terminal output, opening up genuinely new use cases like terminal-based CAD and 3D game engines running in the terminal.

Prerequisites

Component Requirement
GPU Any GPU supported by Bevy/wgpu (integrated or dedicated)
OS Linux (primary), macOS (experimental support)
Rust Rust toolchain 1.80+ (for building from source)
Dependencies gcc, pkgconf, libfontconfig-dev, libwayland-dev (Linux)

Installation

Option 1: Cargo Install (Recommended)

cargo install ratty

Option 2: Arch Linux

sudo pacman -S ratty

Option 3: Prebuilt Binary

Download the latest release from the GitHub releases page.

Option 4: Build from Git

# Install system dependencies (Debian/Ubuntu)
sudo apt update && sudo apt install gcc pkgconf libfontconfig-dev libwayland-dev

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

Configuration

Ratty reads its configuration from ~/.config/ratty/ratty.toml. Copy the default config to get started:

mkdir -p ~/.config/ratty
cp $(dirname $(which ratty))/../config/ratty.toml ~/.config/ratty/ 2>/dev/null || \
curl -s https://raw.githubusercontent.com/orhun/ratty/main/config/ratty.toml > ~/.config/ratty/ratty.toml

Key Configuration Sections

  • Window: width, height, scale_factor, opacity (default: 0.8)
  • Terminal: default_cols, default_rows, scrollback (2000 lines)
  • Font: family, style, size (default: DejaVu Sans Mono 18pt)
  • Cursor Model: path to .obj/.glb file, scale_factor, brightness, x_offset
  • Cursor Animation: spin_speed, bob_speed, bob_amplitude
  • Theme: 16-color ANSI palette with foreground/background

The default cursor is a 3D model of Cairo Spiny Mouse that spins in place. You can replace it with any .obj or .glb file:

[cursor.model]
path = "path/to/your-model.obj"
scale_factor = 6.0
brightness = 0.5
visible = true

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

Usage

Basic Usage

Launch Ratty like any other terminal emulator:

ratty

Key Bindings

  • Ctrl+Alt+Enter — Toggle 2D / 3D mode (the terminal surface warps into 3D space)
  • Ctrl+Alt+M — Toggle Möbius mode (loop the terminal into a Möbius strip)
  • Ctrl+Alt+↑/↓ — Increase / Decrease warp intensity
  • Ctrl+Alt+C — Copy selection
  • Ctrl+Alt+V — Paste clipboard
  • Alt+PageUp/PageDown — Scroll page up/down
  • Alt+↑/↓ — Scroll line up/down
  • Ctrl+= / Ctrl+- — Increase / Decrease font size
  • Ctrl+Alt+0 — Reset font size

3D Mode

Press Ctrl+Alt+Enter to toggle 3D mode. The terminal surface warps into a curved display floating in 3D space. You can adjust the warp intensity with Ctrl+Alt+↑/↓. Press Ctrl+Alt+M for Möbius mode — the terminal wraps into a loop.

Inline 3D Objects via the Ratty Graphics Protocol (RGP)

Applications can embed 3D objects directly in terminal output using the Ratty Graphics Protocol (RGP). RGP supports:

  • Registering .obj and .glb assets by path
  • Placing them at specific terminal cell anchors
  • Configuring animation, scale, color, depth

There's also a Ratatui widget (ratatui-rgp) in the Ratty repository for building your own terminal applications with inline 3D objects.

Example projects built on RGP:

  • Ratscad — a terminal-based CAD application
  • Ratty-runner — an endless runner game inside the terminal
  • Big Rat — oversized 3D rat placed directly in your terminal
  • Tetro-tui — Tetris running with 3D rendering in Ratty

Architecture

Ratty Architecture

Ratty's rendering pipeline is a multi-stage bridge between CPU-based terminal rendering and GPU-accelerated graphics:

Layer 1 — Terminal Buffer (CPU): Ratatui builds the 2D terminal buffer on the CPU. This handles all standard terminal output — text, layouts, widgets, and scrollback.

Layer 2 — Text Rendering (GPU): Parley and Vello take over for GPU-accelerated text shaping and rendering. Font glyphs are shaped with Parley (a text layout engine) and rasterized with Vello (a GPU compute shader 2D renderer).

Layer 3 — Readback Bridge (CPU→GPU): The RGBA pixel data is read back from GPU memory to CPU memory via the readback bridge, then copied into a Bevy image texture.

Layer 4 — Scene Presentation (GPU): Bevy (the Rust game engine) takes the image texture and presents it — either as a flat 2D surface or as a warped 3D surface in the 3D mode viewport.

3D Cursor Rendering: The 3D cursor model (.obj/.glb) is rendered separately by Bevy's 3D scene renderer, composited over the terminal surface in the final frame.

Note: The current architecture uses a GPU-powered bridge (Parley/Vello on GPU → readback to CPU → copy to Bevy). It's not yet a fully GPU-resident shared-texture path — that would require a dedicated Bevy render integration, but the framework is in place for it.

Verification Checklist

  • Ratty launches and displays a terminal window with a spinning 3D rat cursor
  • Ctrl+Alt+Enter toggles 3D mode
  • Ctrl+Alt+M toggles Möbius mode
  • Font size adjustments work (Ctrl+= / Ctrl+-)
  • Custom .obj cursor model loads correctly
  • Theme colors render correctly (customizable in ratty.toml)
  • Scrollback works (2000 lines by default)
  • Copy/paste works (Ctrl+Alt+C / Ctrl+Alt+V)
  • Ratty Graphics Protocol renders inline 3D models

Comparison: Ratty vs Other Modern Terminals

  • Kitty — GPU-accelerated but 2D only; has Kitty Graphics Protocol for images but no 3D support
  • Alacritty — GPU-accelerated, minimal, fast — but no inline graphics or 3D
  • WezTerm — GPU-accelerated, multiplexer support, image protocol — no 3D
  • Ghostty — GPU-accelerated, native UI — no 3D rendering
  • Rio — GPU-accelerated, web technologies — no 3D
  • Ratty — GPU-rendered, 3D cursor, 3D mode, inline 3D objects via RGP protocol

Ratty is the only terminal emulator that brings a 3D rendering engine directly into the terminal experience. For day-to-day terminal work, you'll likely prefer a traditional emulator — but for creative demos, terminal-based games, CAD tools, and the sheer wow factor, Ratty is unmatched.

Resources

← Retour au Blog

Ratty — L'Émulateur de Terminal Propulsé par GPU avec Graphismes 3D Intégrés Qui Emmène la Ligne de Commande dans la Troisième Dimension

2026-05-19

Ratty — L'Émulateur de Terminal Propulsé par GPU avec Graphismes 3D Intégrés

Pendant des décennies, le terminal a été le domaine du texte vert clignotant, des polices à chasse fixe et d'une adhésion stricte aux deux dimensions. Puis Orhun Parmaksız — le développeur Rust prolifique derrière des outils comme bat, gitoxide et tokio-console — a décidé de poser une question que personne n'avait posée : et si votre terminal avait une troisième dimension ?

Découvrez Ratty (🐀🧀), un émulateur de terminal rendu par GPU qui intègre des graphismes 3D directement dans votre ligne de commande. Construit avec Rust, Ratatui et le moteur de jeu Bevy, il a conquis le monde open-source — accumulant plus de 2 100 étoiles GitHub en moins d'un mois, avec des articles dans The Register et It's FOSS.

Pourquoi Ratty est-il Tendance ?

Ratty est arrivé fin avril 2026 et connaît un succès viral pour trois raisons :

  1. C'est une véritable nouveauté — personne n'avait livré un émulateur de terminal avec un support 3D de première classe avant. Ratty affiche un rat 3D animé comme curseur et vous permet de basculer dans un mode 3D complet où la surface du terminal se courbe comme un écran à la TempleOS.
  2. Il vient d'un créateur respecté — Orhun est l'auteur de bat (un clone de cat avec coloration syntaxique) et un contributeur majeur à Ratatui. La communauté Rust fait confiance à la qualité.
  3. Ce n'est pas qu'un gadget — le Ratty Graphics Protocol (RGP) permet aux développeurs d'intégrer de véritables modèles 3D .obj et .glb dans la sortie du terminal, ouvrant des cas d'usage comme la CAD depuis le terminal et des jeux 3D dans le terminal.

Prérequis

Composant Prérequis
GPU Tout GPU supporté par Bevy/wgpu (intégré ou dédié)
OS Linux (principal), macOS (support expérimental)
Rust Rust toolchain 1.80+ (pour compilation)
Dépendances gcc, pkgconf, libfontconfig-dev, libwayland-dev (Linux)

Installation

Option 1 : Cargo Install (Recommandé)

cargo install ratty

Option 2 : Arch Linux

sudo pacman -S ratty

Option 3 : Binaire Précompilé

Téléchargez la dernière version depuis la page des releases GitHub.

Option 4 : Compilation depuis Git

# Installer les dépendances système (Debian/Ubuntu)
sudo apt update && sudo apt install gcc pkgconf libfontconfig-dev libwayland-dev

# Compiler et installer
cargo install --git https://github.com/orhun/ratty

Configuration

Ratty lit sa configuration depuis ~/.config/ratty/ratty.toml. Copiez la configuration par défaut :

mkdir -p ~/.config/ratty
cp $(dirname $(which ratty))/../config/ratty.toml ~/.config/ratty/ 2>/dev/null || \
curl -s https://raw.githubusercontent.com/orhun/ratty/main/config/ratty.toml > ~/.config/ratty/ratty.toml

Sections de Configuration Principales

  • Fenêtre : width, height, scale_factor, opacity (défaut : 0.8)
  • Terminal : default_cols, default_rows, scrollback (2000 lignes)
  • Police : famille, style, taille (défaut : DejaVu Sans Mono 18pt)
  • Modèle du Curseur : chemin vers fichier .obj/.glb, scale_factor, brightness, x_offset
  • Animation du Curseur : spin_speed, bob_speed, bob_amplitude
  • Thème : palette ANSI 16 couleurs avec premier plan/arrière-plan

Le curseur par défaut est un modèle 3D de Cairo Spiny Mouse qui tourne sur lui-même. Vous pouvez le remplacer par n'importe quel fichier .obj ou .glb :

[cursor.model]
path = "chemin/vers/votre-modele.obj"
scale_factor = 6.0
brightness = 0.5
visible = true

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

Utilisation

Utilisation de Base

Lancez Ratty comme n'importe quel émulateur de terminal :

ratty

Raccourcis Clavier

  • Ctrl+Alt+Entrée — Activer/Désactiver le mode 3D
  • Ctrl+Alt+M — Activer/Désactiver le mode Möbius
  • Ctrl+Alt+↑/↓ — Augmenter/Réduire l'intensité de la courbure
  • Ctrl+Alt+C — Copier la sélection
  • Ctrl+Alt+V — Coller le presse-papiers
  • Alt+PageUp/PageDown — Défiler page par page
  • Alt+↑/↓ — Défiler ligne par ligne
  • Ctrl+= / Ctrl+- — Augmenter/Réduire la taille de la police
  • Ctrl+Alt+0 — Réinitialiser la taille de la police

Mode 3D

Appuyez sur Ctrl+Alt+Entrée pour activer le mode 3D. La surface du terminal se courbe en un écran flottant dans l'espace 3D. Ajustez l'intensité avec Ctrl+Alt+↑/↓. Appuyez sur Ctrl+Alt+M pour le mode Möbius — le terminal s'enroule en boucle.

Objets 3D Intégrés via le Ratty Graphics Protocol (RGP)

Les applications peuvent intégrer des objets 3D directement dans la sortie du terminal en utilisant le Ratty Graphics Protocol (RGP). RGP supporte :

  • L'enregistrement d'assets .obj et .glb par chemin
  • Le placement à des ancres de cellules terminales spécifiques
  • La configuration d'animation, d'échelle, de couleur et de profondeur

Un widget Ratatui (ratatui-rgp) est disponible dans le dépôt Ratty pour construire vos propres applications terminal avec objets 3D intégrés.

Exemples de projets sur RGP :

  • Ratscad — une application de CAD dans le terminal
  • Ratty-runner — un jeu de course sans fin dans le terminal
  • Big Rat — un rat 3D surdimensionné placé dans votre terminal
  • Tetro-tui — Tetris avec rendu 3D dans Ratty

Architecture

Architecture de Ratty

Le pipeline de rendu de Ratty est un pont multi-étapes entre le rendu terminal CPU et les graphismes GPU accélérés :

Couche 1 — Buffer Terminal (CPU) : Ratatui construit le buffer terminal 2D sur le CPU. Cela gère toute la sortie terminal standard — texte, mises en page, widgets et scrollback.

Couche 2 — Rendu de Texte (GPU) : Parley et Vello prennent le relais pour le rendu de texte accéléré par GPU. Les glyphes sont façonnés avec Parley et rasterisés avec Vello (un moteur de rendu 2D par shader GPU).

Couche 3 — Pont de Lecture (CPU→GPU) : Les données de pixels RGBA sont lues de la mémoire GPU vers la mémoire CPU via le pont de lecture, puis copiées dans une texture d'image Bevy.

Couche 4 — Présentation de la Scène (GPU) : Bevy (le moteur de jeu Rust) prend la texture d'image et la présente — soit comme une surface 2D plate, soit comme une surface 3D courbée dans le viewport du mode 3D.

Rendu du Curseur 3D : Le modèle 3D du curseur (.obj/.glb) est rendu séparément par le moteur de scène 3D de Bevy, composité par-dessus la surface du terminal dans l'image finale.

Note : L'architecture actuelle utilise un pont GPU (Parley/Vello sur GPU → lecture vers CPU → copie vers Bevy). Ce n'est pas encore un chemin de texture entièrement résident GPU — cela nécessiterait une intégration de rendu Bevy dédiée, mais le cadre est en place.

Checklist de Vérification

  • Ratty se lance et affiche une fenêtre de terminal avec un curseur rat 3D animé
  • Ctrl+Alt+Entrée active/désactive le mode 3D
  • Ctrl+Alt+M active/désactive le mode Möbius
  • Les ajustements de taille de police fonctionnent (Ctrl+= / Ctrl+-)
  • Un modèle de curseur .obj personnalisé se charge correctement
  • Les couleurs du thème s'affichent correctement (personnalisable dans ratty.toml)
  • Le scrollback fonctionne (2000 lignes par défaut)
  • Le copier/coller fonctionne (Ctrl+Alt+C / Ctrl+Alt+V)
  • Le Ratty Graphics Protocol rend les modèles 3D intégrés

Comparaison : Ratty vs Autres Terminaux Modernes

  • Kitty — Accéléré GPU mais 2D uniquement ; Kitty Graphics Protocol pour les images mais pas de 3D
  • Alacritty — Accéléré GPU, minimal, rapide — pas de graphismes intégrés ni 3D
  • WezTerm — Accéléré GPU, support multiplexeur, protocole d'image — pas de 3D
  • Ghostty — Accéléré GPU, interface native — pas de rendu 3D
  • Rio — Accéléré GPU, technologies web — pas de 3D
  • Ratty — Rendu GPU, curseur 3D, mode 3D, objets 3D intégrés via RGP

Ratty est le seul émulateur de terminal qui intègre un moteur de rendu 3D directement dans l'expérience terminal. Pour le travail quotidien, vous préférerez probablement un émulateur traditionnel — mais pour les démos créatives, les jeux dans le terminal, les outils CAD et l'effet waouh pur, Ratty est inégalé.

Ressources