Interface de Terminal: BubbleTea (Go) vs. Ratatui (Rust)

Duas opções robustas para criar interfaces de usuário de terminal hoje são BubbleTea (Go) e Ratatui (Rust). Uma oferece um framework opinativo no estilo Elm; a outra, uma biblioteca flexível de modo imediato.

Este post resume o que cada um é, mostra um exemplo mínimo de ambos e sugere quando escolher um ou outro. E sim, também fornece alguns links úteis. Para um contexto mais amplo sobre ferramentas de desenvolvimento, veja Ferramentas de Desenvolvimento: O Guia Completo para Fluxos de Trabalho Modernos.

A interface Crush UI (captura acima) é implementada usando o framework BubbleTea.

O que é o BubbleTea?

BubbleTea é um framework Go para TUIs baseado na Arquitetura Elm. Você descreve seu aplicativo com um modelo (estado) e três partes: Init (comando inicial), Update (lida com mensagens, retorna novo modelo e comando opcional) e View (renderiza a UI como uma string). O framework executa o loop de eventos, converte pressionamentos de teclas e E/S em mensagens e redesenha quando o modelo muda. Então: o que é BubbleTea? Em resumo, é a maneira divertida e com estado de criar aplicativos de terminal em Go, com uma única fonte de verdade e atualizações previsíveis.

O BubbleTea está pronto para produção (v1.x), tem dezenas de milhares de estrelas no GitHub e milhares de importadores conhecidos, e funciona inline, em tela cheia ou misto. Você normalmente o combina com Bubbles para componentes (entradas, viewports, spinners) e Lip Gloss para estilização. Se você está construindo um TUI em Go, um bom primeiro passo é seguir a estrutura de projeto Go comum para que seu cmd/ e pacotes permaneçam claros à medida que o aplicativo cresce.

Um programa mínimo do BubbleTea parece com isso: um modelo, Init, Update (lidando com mensagens de teclas) e View retornando uma string. O tempo de execução faz o resto.

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 := "O que devemos comprar?\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 + "\nPressione q para sair.\n"
}

func main() {
    if _, err := tea.NewProgram(model{
        choices:  []string{"Comprar cenouras", "Comprar aipo", "Comprar couve-rábano"},
        selected: make(map[int]struct{}),
    }).Run(); err != nil {
        fmt.Printf("erro: %v", err)
        os.Exit(1)
    }
}

Aplicativos notáveis construídos com BubbleTea incluem Crush (agente de codificação com IA baseado em TUI da Charm), Glow, Huh e muitas ferramentas do ecossistema dos projetos Go mais populares. Para aplicativos Go mais complexos, você pode adicionar injeção de dependência e testes unitários; as mesmas ideias se aplicam a modelos e comandos do BubbleTea.

O que é o Ratatui?

Ratatui é uma biblioteca Rust para TUIs que usa renderização de modo imediato: em cada quadro, você descreve toda a UI (widgets e layout) e o Ratatui a desenha. O que é Ratatui? É um toolkit leve e não opinativo — não impõe um modelo estilo Elm ou uma estrutura de aplicativo específica. Você mantém seu próprio estado, executa seu próprio loop de eventos (geralmente com crossterm, termion ou termwiz) e chama terminal.draw(|f| { ... }) para renderizar. Então, a diferença entre estilo Elm e modo imediato é exatamente isso: no estilo Elm, o framework possui o loop e você reage via Update/View; no modo imediato, você possui o loop e redesenha toda a UI a partir do estado atual em cada quadro.

O Ratatui é usado por mais de 2.100 crates e é confiável por empresas como Netflix (ex. bpftop), OpenAI, AWS (ex. amazon-q-developer-cli) e Vercel. A versão 0.30.x é a atual, com documentação robusta e backends opcionais. É uma boa escolha quando você quer controle total sobre entrada e renderização, ou quando já está no ecossistema Rust. Para mais projetos Rust, veja os 23 Projetos Rust Mais Populares no GitHub.

Um aplicativo mínimo do Ratatui: inicializa o terminal, executa um loop que desenha e depois lê eventos, e restaura o terminal ao sair.

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("Olá, Ratatui! Pressione q para sair.").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(())
}

Então: quando devo escolher BubbleTea vs Ratatui? Escolha BubbleTea quando quiser o caminho mais rápido para um TUI polido em Go, com um único modelo e Update/View claros, e quando sua equipe ou ecossistema for Go (ex. você já usa ORMs Go ou Ollama em Go). Escolha Ratatui quando precisar de controle máximo, estiver em Rust, ou estiver construindo TUIs sensíveis ao desempenho ou com recursos limitados; seu design de modo imediato e backends opcionais oferecem essa flexibilidade.

Resumo

Ambos são excelentes escolhas; a linguagem preferida e o quanto de estrutura queremos do framework devem orientar a decisão.

Links úteis

• Top 19 Projetos Go em Alta no GitHub - Janeiro 2026
• Top 23 Projetos Rust em Alta no GitHub - Janeiro 2026
• Injeção de Dependência em Go: Padrões & Melhores Práticas
• SDKs Go para Ollama - comparação com exemplos
• Comparando ORMs Go para PostgreSQL: GORM vs Ent vs Bun vs sqlc
• Estrutura de Projeto Go: Práticas & Padrões
• Testes Unitários em Go: Estrutura & Melhores Práticas

Recursos Externos

• Bubble Tea – A Arquitetura Elm para TUIs em Go
• Ratatui – Introdução
• Ratatui – Renderização (modo imediato)
• Charm Crush – Agente de codificação TUI
• Ratatui no crates.io