Terminal UI: BubbleTea (Go) vs. Ratatui (Rust)

Zwei starke Optionen für das Erstellen von Terminalbenutzeroberflächen heute sind BubbleTea (Go) und Ratatui (Rust). Eine bietet Ihnen einen opinionierten, Elm-stiligen Rahmen; die andere eine flexible, immediate-mode-Bibliothek.

Dieser Beitrag fasst zusammen, was jedes ist, zeigt ein minimales Beispiel für beide und schlägt vor, wann Sie welches wählen sollten. Ja, er gibt auch einige nützliche Links.

Crush UI (Screenshot oben) wird mit dem BubbleTea-Framework implementiert.

Was ist BubbleTea?

BubbleTea ist ein Go-Framework für TUIs, basierend auf The Elm Architecture. Sie beschreiben Ihre Anwendung mit einem Modell (Zustand) und drei Komponenten: Init (Anfangsbefehl), Update (Nachrichten verarbeiten, neuen Modell und optionalen Befehl zurückgeben) und View (UI als String rendern). Das Framework führt den Ereignisloop aus, wandelt Tastatureingaben und I/O in Nachrichten um und aktualisiert die Darstellung, wenn sich der Modell ändert. Also: Was ist BubbleTea? Kurz gesagt, es ist der spaßige, stateful Weg, Terminalanwendungen in Go zu erstellen, mit einem einzigen Quell der Wahrheit und vorhersehbaren Updates.

BubbleTea ist produktionsreif (v1.x), hat tausende von GitHub-Sternen und tausende bekannte Importer, und funktioniert inline, Vollbild oder gemischt. Sie verwenden ihn typischerweise mit Bubbles für Komponenten (Eingaben, Viewports, Spinner) und Lip Gloss für Styling. Wenn Sie eine Go-TUI erstellen, ist ein solider erster Schritt, die gängigen Go-Projektstrukturen zu befolgen, damit Ihre cmd/ und Pakete klar bleiben, während die Anwendung wächst.

Ein minimales BubbleTea-Programm sieht so aus: ein Modell, Init, Update (Nachrichten verarbeiten) und View, das eine Zeichenfolge zurückgibt. Der Laufzeitumgebung übernimmt den Rest.

package main

import (
    "fmt"
    "os"
    tea "github.com/charmbracelet/bubbletea"
)

type model struct {
    choices  []string
    cursor   int
    selected map[int]struct{}
}

func (m model) Init() tea.Cmd { return nil }

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.String() {
        case "ctrl+c", "q":
            return m, tea.Quit
        case "up", "k":
            if m.cursor > 0 { m.cursor-- }
        case "down", "j":
            if m.cursor < len(m.choices)-1 { m.cursor++ }
        case "enter", " ":
            if _, ok := m.selected[m.cursor]; ok {
                delete(m.selected, m.cursor)
            } else {
                m.selected[m.cursor] = struct{}{}
            }
        }
    }
    return m, nil
}

func (m model) View() string {
    s := "Was sollten wir kaufen?\n\n"
    for i, choice := range m.choices {
        cursor := " "
        if m.cursor == i { cursor = ">" }
        checked := " "
        if _, ok := m.selected[i]; ok { checked = "x" }
        s += fmt.Sprintf("%s [%s] %s\n", cursor, checked, choice)
    }
    return s + "\nDrücken Sie q, um zu beenden.\n"
}

func main() {
    if _, err := tea.NewProgram(model{
        choices:  []string{"Kartoffeln kaufen", "Sellerie kaufen", "Kohlrabi kaufen"},
        selected: make(map[int]struct{}),
    }).Run(); err != nil {
        fmt.Printf("Fehler: %v", err)
        os.Exit(1)
    }
}

Hervorragende Anwendungen, die mit BubbleTea erstellt wurden, umfassen Crush (Charm’s TUI-basierten KI-Code-Agent), Glow, Huh und viele Tools aus dem Ökosystem der top trending Go Projekte. Für komplexere Go-Anwendungen könnten Sie Abhängigkeitsinjektion und solide Einheitstests hinzufügen; die gleichen Ideen gelten für BubbleTea-Modelle und Befehle.

Was ist Ratatui?

Ratatui ist eine Rust-Bibliothek für TUIs, die immediate-mode-Rendern verwendet: bei jedem Frame beschreiben Sie die gesamte Benutzeroberfläche (Widgets und Layout), und Ratatui rendert sie. Was ist Ratatui? Es ist ein leichtgewichtiges, unopinioniertes Toolkit – es legt keine Elm-stilige Modell oder eine bestimmte App-Struktur auf. Sie behalten Ihren eigenen Zustand, führen Ihren eigenen Ereignisloop (typischerweise mit crossterm, termion oder termwiz) aus, und rufen terminal.draw(|f| { ... }) auf, um zu rendern. Also ist der Unterschied zwischen Elm-stil und immediate mode genau dieser: bei Elm-stil besitzt das Framework den Loop und Sie reagieren über Update/View; bei immediate mode besitzen Sie den Loop und rendern die gesamte UI aus dem aktuellen Zustand jedes Frame.

Ratatui wird von 2.100+ Crates verwendet und von Unternehmen wie Netflix (z. B. bpftop), OpenAI, AWS (z. B. amazon-q-developer-cli) und Vercel vertraut. Version 0.30.x ist aktuell, mit starken Dokumentationen und optionalen Backend-Systemen. Es ist eine gute Wahl, wenn Sie volle Kontrolle über Eingabe und Rendering benötigen oder wenn Sie bereits im Rust-Ökosystem sind.

Eine minimale Ratatui-App: Sie initialisieren den Terminal, führen eine Schleife aus, die zeichnet und dann Ereignisse liest, und restaurieren den Terminal beim Beenden.

use crossterm::event::{self, Event, KeyCode};
use ratatui::{prelude::*, widgets::Paragraph};
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut terminal = ratatui::init();
    loop {
        terminal.draw(|frame| {
            let area = frame.area();
            frame.render_widget(
                Paragraph::new("Hallo, Ratatui! Drücken Sie q, um zu beenden.").alignment(Alignment::Center),
                area,
            );
        })?;
        if event::poll(Duration::from_millis(250))? {
            if let Event::Key(key) = event::read()? {
                if key.code == KeyCode::Char('q') {
                    break;
                }
            }
        }
    }
    ratatui::restore();
    Ok(())
}

Also: Wann sollte ich BubbleTea vs Ratatui wählen? Wählen Sie BubbleTea, wenn Sie den schnellsten Weg zu einer polierten TUI in Go mit einem einzigen Modell und klarem Update/View benötigen und wenn Ihr Team oder Ökosystem Go ist (z. B. Sie verwenden bereits Go-ORMs oder Ollama in Go). Wählen Sie Ratatui, wenn Sie maximale Kontrolle benötigen, im Rust-Ökosystem sind oder leistungsintensive oder ressourcenbeschränkte TUIs erstellen; seine immediate-mode-Design und optionale Backend-Systeme geben diese Flexibilität.

Zusammenfassung

Beide sind hervorragende Wahl; die bevorzugte Sprache und wie viel Struktur wir von dem Framework wollen, sollten die Entscheidung leiten.

Nützliche Links

• Top 19 Trending Go Projects on GitHub - January 2026
• Top 23 Trending Rust Projects on GitHub - January 2026
• Dependency Injection in Go: Patterns & Best Practices
• Go SDKs for Ollama - comparison with examples
• Comparing Go ORMs for PostgreSQL: GORM vs Ent vs Bun vs sqlc
• Go Project Structure: Practices & Patterns
• Go Unit Testing: Structure & Best Practices

Externe Ressourcen

• Bubble Tea – The Elm Architecture for Go TUIs
• Ratatui – Introduction
• Ratatui – Rendering (immediate mode)
• Charm Crush – TUI coding agent
• Ratatui on crates.io