TUIs vuelven en 2026: Charm, Ratatui y Textual frente a Electron

Algo curioso está pasando en 2026: las TUIs (Terminal User Interfaces) están volviendo. No como nostalgia retro, sino como una respuesta concreta a una década de aplicaciones Electron pesadas, toolkits nativos fragmentados y diseñadores que se cansaron de pelearse con macOS, Windows y Linux por separado. El detonante reciente fue un ensayo del investigador portugués Alcides Fonseca titulado Why TUIs are back, pero el fenómeno lo veníamos viendo crecer hace rato: Charm, Ratatui, Textual, gum, lazygit, k9s, glow, btop, atuin, posting. Cada semana aparece una herramienta nueva que vive dentro de la terminal y que, sin embargo, se ve moderna.

Este artículo revisa por qué las TUIs están recuperando terreno, qué frameworks lideran el movimiento, qué dicen las cifras de adopción en GitHub, y qué significa para los desarrolladores en LATAM que muchas veces trabajamos en máquinas modestas, con conexiones inestables y servidores remotos por SSH.

Qué pasó: el cansancio de Electron y la fragmentación nativa

Durante los últimos diez años el desarrollo de aplicaciones de escritorio siguió tres caminos paralelos. El primero, los toolkits nativos: Win32, MFC, WPF, WinUI y MAUI en Windows; GTK y Qt en Linux; AppKit y SwiftUI en macOS. El segundo, los navegadores empacados: Electron, Tauri, NW.js. El tercero, las terminales, donde sobrevivieron Vim, Emacs, htop y poco más para usuarios que aceptaban una curva de aprendizaje brutal a cambio de velocidad y automatización.

El primer camino quedó atrapado en su propia historia. Microsoft, como observó Jeffrey Snover, no ha tenido una estrategia de UI coherente desde Charles Petzold: cada framework nuevo deja huecos en el anterior y obliga a reaprender. Apple, que durante décadas fue el referente con sus Human Interface Guidelines, hoy mete íconos en cada menú y rompe la ley de Fitts al hacer casi imposible redimensionar ventanas. Linux, por diseño, asumió la inconsistencia como precio de la libertad.

El segundo camino —Electron— ganó por defecto. Slack, Discord, VS Code, Cursor, Notion, Linear, Figma Desktop, todos corren un Chromium dentro. Funciona, pero con costos: consumo de RAM elevado, falta de consistencia visual con el sistema, atajos de teclado pobres y menús incompletos porque el HTML vive en un sandbox. La gente lo tolera porque la alternativa es escribir tres aplicaciones nativas distintas.

El tercer camino, las TUIs, nunca murió pero estuvo dormido. Lo que cambió en los últimos tres años es que aparecieron frameworks modernos que hacen que construir una TUI sea agradable, no doloroso. Y empezaron a aparecer aplicaciones TUI que no piden disculpas por estar en la terminal, sino que celebran estar ahí.
Las TUIs modernas integran paneles, listas, diff y formularios sin abandonar la terminal.

Contexto e historia: del Norton Commander a Charm

Las TUIs no son nuevas. En los 80 y 90, Norton Commander, Turbo Pascal, Lotus 1-2-3 y WordPerfect ya ofrecían menús, ventanas, diálogos modales y selección por flechas dentro de la terminal MS-DOS. La biblioteca ncurses en Unix llevaba años haciendo lo mismo. Cuando llegó la era gráfica, esas interfaces parecieron antiguas y se asociaron con servidores, scripts y sysadmins.

Lo que cambió la conversación fue una combinación de factores. Las terminales modernas (iTerm2, Alacritty, WezTerm, Kitty, Ghostty) soportan true color de 24 bits, ligaduras de fuentes, imágenes inline (Sixel, Kitty graphics protocol, iTerm2 inline images), y reportes precisos de tamaño y modificadores de teclado vía el Kitty Keyboard Protocol. Eso significa que ya no estamos limitados a 16 colores y caracteres ASCII: una TUI puede mostrar gradientes, gráficas, mini-mapas y hasta render de Markdown con tipografía bonita.

El segundo factor fue cultural. La popularidad de Vim y Neovim entre desarrolladores jóvenes, la masificación de tmux, el auge de SSH para trabajar en servidores remotos y el regreso del focus mode empujaron a una generación a sentirse cómoda viviendo en la terminal. La consecuencia natural: si paso ocho horas ahí, quiero que mis herramientas también vivan ahí.

Datos y cifras: el ecosistema TUI en 2026

Los números muestran una adopción saludable y creciente. Estos son los frameworks más relevantes:

• Bubble Tea (Go, de Charm) — Más de 32.000 estrellas en GitHub. Basado en la arquitectura Elm (Model-Update-View). Es el framework de TUI más popular del ecosistema Go.- Ratatui (Rust) — Más de 14.000 estrellas. Fork comunitario del difunto tui-rs. Render por buffers, integración con crossterm, termion y termwiz.- Textual (Python) — Más de 27.000 estrellas. CSS para terminales, async nativo, y la rareza de poder correr la misma app en navegador vía Textual Web.- Lipgloss (Go, de Charm) — Layout y estilos declarativos para terminales, también de Charm.- Bubbles (Go) — Componentes pre-armados (listas, inputs, spinners, viewports) sobre Bubble Tea.

Y aplicaciones TUI que están desplazando a sus equivalentes gráficos:

• lazygit — más de 56.000 estrellas, un cliente Git completo en TUI.- k9s — más de 28.000 estrellas, panel de Kubernetes que reemplaza dashboards web.- btop — monitor de recursos con gráficos en color, más de 22.000 estrellas.- atuin — historial de shell sincronizado entre máquinas con búsqueda fuzzy.- posting — cliente HTTP estilo Postman, hecho en Textual.- glow — render de Markdown con tipografía decente dentro de la terminal.

💭 Clave: el patrón es claro: cada vez que una herramienta de productividad para desarrolladores aparece como TUI bien hecha, gana tracción rápido. La razón no es nostalgia, es que la terminal sigue siendo el entorno donde ya estamos trabajando.

Impacto y análisis: por qué las TUIs ganan donde Electron pierde

Hay cinco ventajas concretas que explican el resurgimiento de las TUIs. La primera es velocidad de inicio: una TUI bien hecha arranca en milisegundos. Una app de Electron típicamente tarda entre 1 y 4 segundos en mostrar la primera ventana, y consume entre 200 MB y 1 GB de RAM antes de hacer nada útil. Para una herramienta que ejecutamos veinte veces al día, esa diferencia se acumula.

La segunda es portabilidad real. La misma binaria de lazygit corre en macOS Intel, macOS ARM, Linux x86, Linux ARM, Windows, FreeBSD y dentro de un contenedor Docker. Si la corremos por SSH en un servidor en Frankfurt desde un café en Bogotá con conexión inestable, sigue siendo usable porque solo enviamos texto, no píxeles.

La tercera es automatización. Cualquier TUI puede ser scripteada con tmux, expect, screen o un wrapper en bash. La interfaz misma es texto, así que se puede capturar, parsear y testear con herramientas estándar. Eso es algo que las apps gráficas pierden por completo cuando dejan de tener AppleScript o cuando los scripts se rompen con cada actualización del DOM interno.

La cuarta es workflow por teclado. En una TUI, todo es una tecla o una combinación. No hay menú escondido, no hay botón fuera de la pantalla, no hay diálogo modal con foco perdido. La curva de aprendizaje es más empinada los primeros días y se aplana muy rápido después.

La quinta es mantenibilidad para el desarrollador. Construir una TUI cross-platform es radicalmente más simple que escribir tres aplicaciones nativas o pelearse con Electron y sus actualizaciones de Chromium. Un equipo pequeño puede sostener una TUI durante años con poca fricción.
La arquitectura Elm (Model-Update-View) es el corazón de Bubble Tea y muchas TUIs modernas.

Ejemplo: una TUI mínima en cada lenguaje

Veamos cómo se ve una TUI mínima en los tres frameworks principales. La aplicación es la misma: un contador que sube con la flecha arriba y baja con la flecha abajo, con q para salir.

Bubble Tea (Go)

package main

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

type model struct{ count int }

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

func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    if k, ok := msg.(tea.KeyMsg); ok {
        switch k.String() {
        case "up":   m.count++
        case "down": m.count--
        case "q":    return m, tea.Quit
        }
    }
    return m, nil
}

func (m model) View() string {
    return fmt.Sprintf("Contador: %d\n(↑ subir, ↓ bajar, q salir)\n", m.count)
}

func main() { tea.NewProgram(model{}).Run() }

Ratatui (Rust)

use ratatui::{prelude::*, widgets::*};
use crossterm::event::{self, Event, KeyCode};

fn main() -> std::io::Result {
    let mut term = ratatui::init();
    let mut count = 0i32;
    loop {
        term.draw(|f| {
            let p = Paragraph::new(format!("Contador: {count}\n(↑/↓/q)"))
                .block(Block::default().borders(Borders::ALL));
            f.render_widget(p, f.size());
        })?;
        if let Event::Key(k) = event::read()? {
            match k.code {
                KeyCode::Up   => count += 1,
                KeyCode::Down => count -= 1,
                KeyCode::Char('q') => break,
                _ => {}
            }
        }
    }
    ratatui::restore();
    Ok(())
}

Textual (Python)

from textual.app import App, ComposeResult
from textual.widgets import Static

class Counter(App):
    BINDINGS = [("up", "inc", "+1"), ("down", "dec", "-1"), ("q", "quit", "Salir")]
    count = 0

    def compose(self) -> ComposeResult:
        yield Static(self._render(), id="label")

    def action_inc(self): self.count += 1; self.refresh_label()
    def action_dec(self): self.count -= 1; self.refresh_label()
    def refresh_label(self): self.query_one("#label", Static).update(self._render())
    def _render(self): return f"Contador: {self.count}\n(↑/↓/q)"

Counter().run()

Tres lenguajes, tres estilos, el mismo concepto: el estado vive en un struct/clase, los eventos lo modifican, y el render es una función pura del estado.

Instalación rápida

En LATAM muchas veces trabajamos en distintos sistemas operativos según el cliente o el café donde estemos. Estas son las instrucciones para los tres frameworks en los tres sistemas.

# Bubble Tea (Go) — macOS, Linux, Windows
go get github.com/charmbracelet/bubbletea

# Ratatui (Rust) — macOS, Linux, Windows
cargo add ratatui crossterm

# Textual (Python) — macOS, Linux
pip install textual textual-dev

# Textual (Python) — Windows con PowerShell
py -m pip install textual textual-dev

💡 Tip: si trabajás en Windows, usá Windows Terminal o WezTerm en vez de la consola clásica. La diferencia en colores, fuentes y soporte Unicode es enorme y muchas TUIs dependen de eso para verse bien.

Diagrama: el ciclo de eventos de una TUI moderna

flowchart LR
  A["Input (teclado/mouse/resize)"] --> B["Update(state, event)"]
  B --> C["Nuevo estado"]
  C --> D["View(state)"]
  D --> E["Render al buffer"]
  E --> F["Diff con frame anterior"]
  F --> G["Escribe solo cambios al TTY"]
  G --> A

Este patrón —prestado de Elm y popularizado por Bubble Tea— es lo que permite que las TUIs modernas se sientan rápidas: no se redibuja toda la pantalla en cada frame, solo las celdas que cambiaron.

Qué sigue: TUIs, IA y el futuro híbrido

El siguiente paso del movimiento es la integración con agentes de IA. Herramientas como Claude Code, aider, opencode y continue ya viven en la terminal porque ahí también vive el código del usuario. Esperamos ver más TUIs que combinen edición, chat con LLMs, ejecución de comandos y vista de logs en un mismo binario, sin abrir un navegador.

⚠️ Ojo: las TUIs no van a reemplazar todo. Para diseño gráfico, video, edición de fotos o juegos, la GUI sigue siendo necesaria. El movimiento TUI gana en herramientas de desarrollador, sysadmin, devops y data, no en software para usuarios finales no técnicos.

Otra tendencia interesante es la de TUIs que también pueden correr en navegador. Textual Web permite servir una TUI vía WebSockets a un cliente HTML que renderiza el mismo árbol de widgets. Esto borra la línea entre app de terminal y app web, y abre la puerta a herramientas que se distribuyen como un binario y se acceden remotamente sin instalar nada.

Para LATAM la propuesta es atractiva: máquinas modestas, conexiones inestables, mucho trabajo remoto vía SSH y una preferencia creciente por tooling open source. Una TUI bien hecha es más justa con esos contextos que una app de Electron de 800 MB que pelea con el WiFi del coworking.

📖 Resumen en Telegram: Ver resumen

Preguntas frecuentes

¿Qué es una TUI exactamente?

Una TUI (Terminal User Interface) es una aplicación interactiva que se ejecuta dentro de una terminal de texto y ofrece elementos visuales como menús, ventanas, listas, formularios y diálogos, controlados típicamente por teclado. Se diferencia de un CLI tradicional en que mantiene una pantalla activa con estado, en vez de imprimir líneas y salir.

¿Por qué están volviendo las TUIs en 2026?

Porque los toolkits nativos están fragmentados (Microsoft cambia de framework cada cinco años, Apple rompe sus propias guías), Electron consume demasiados recursos y los desarrolladores ya viven en la terminal. Frameworks modernos como Bubble Tea, Ratatui y Textual hacen que construir una TUI bonita y portable sea fácil.

¿Una TUI es más rápida que una app Electron?

En general sí. Una TUI bien hecha arranca en milisegundos y consume decenas de megabytes de RAM, mientras que una app Electron típica tarda segundos en abrir y consume cientos de megabytes o más. Para herramientas de uso frecuente la diferencia es notable.

¿Puedo usar TUIs por SSH?

Sí, esa es una de sus mayores ventajas. Como solo transmiten texto, funcionan bien sobre conexiones lentas o inestables, sin necesidad de X forwarding ni escritorio remoto. Es una de las razones por las que herramientas como k9s, lazygit y htop son tan populares en infraestructura.

¿Qué framework debería usar para mi primera TUI?

Depende del lenguaje en el que estés cómodo. Si usás Go, Bubble Tea es la opción dominante. Si usás Rust, Ratatui es el estándar de facto. Si usás Python, Textual es el más completo y tiene la mejor documentación. Los tres tienen ejemplos abundantes y comunidades activas.

¿Las TUIs reemplazarán las apps de escritorio?

No para todo. Las TUIs ganan terreno en herramientas para desarrolladores, sysadmins, devops y data. Para diseño gráfico, video, edición de imágenes o software para usuarios no técnicos, las GUIs siguen siendo la opción correcta.

Referencias

• Why TUIs are back — Alcides Fonseca — Ensayo original que motivó este artículo.- Bubble Tea (GitHub) — Framework Go basado en arquitectura Elm para construir TUIs.- Ratatui (GitHub) — Biblioteca de Rust para TUIs, sucesora comunitaria de tui-rs.- Textual (GitHub) — Framework Python con CSS para terminales y soporte web.- lazygit (GitHub) — Cliente de Git en TUI, uno de los ejemplos más populares del movimiento.

📱 ¿Te gusta este contenido? Únete a nuestro canal de Telegram @programacion donde publicamos a diario lo más relevante de tecnología, IA y desarrollo. Resúmenes rápidos, contenido fresco todos los días.