Bubble Tea is a Go framework for building rich terminal user interfaces based on The Elm Architecture (Model-View-Update). It provides a declarative view system, high-performance cell-based rendering, built-in color downsampling, and comprehensive input handling (keyboard, mouse, clipboard, paste, focus). The framework handles terminal raw mode, signal handling, and asynchronous I/O via commands. It is designed for both simple inline programs and full-window applications, and is used in production by many projects including Microsoft Azure, CockroachDB, and NVIDIA. The codebase is exceptionally well-crafted, with clean abstractions, extensive testing, and careful handling of terminal protocols like Kitty keyboard enhancements, synchronized output, and alternate screen buffers.
Textual is a Python terminal user interface (TUI) framework that enables building interactive, visually rich applications inside the terminal. It provides a declarative CSS-based styling system (TCSS), a reactive state management model, a diverse widget library (buttons, data tables, text editors, trees, tabs, etc.), and an asynchronous event-driven architecture. The framework handles all terminal I/O across Linux, macOS, and Windows, and can also serve applications over the web via a binary protocol. Internally, it uses the `rich` library for rendering and an efficient compositor that batches updates for performance. The primary entry point is the `App` class in `src/textual/app.py`, from which users subclass and compose widgets via `compose()` methods. Styling can be embedded as `DEFAULT_CSS` or loaded from external `.tcss` files. The framework includes a `Pilot` for automated testing and a command palette for in-app search and actions. Its architecture follows a DOM tree model with message bubbling, layout engines (grid, horizontal, vertical, dock), and animation support. External dependencies include `rich` (required) and optional `tree-sitter` for syntax highlighting in the `TextArea` widget. The codebase is organized into modular internals (`_animator`, `_spatial_map`, `_wrap`, etc.) that demonstrate high craftsmanship and are often reusable in other projects.
Cursive is a mature, backend-agnostic TUI (Text User Interface) framework for Rust. It provides a rich set of composable widgets (dialogs, text views, edit views, select lists, progress bars, etc.), a flexible event system, full styling and theming support, and multiple backend implementations (crossterm, termion, ncurses, pancurses, BearLibTerminal). The architecture is split into `cursive-core` (backend-independent core) and `cursive` (user-facing crate with backends), plus `cursive-macros` for procedural macro support and `cursive-syntect` for syntax highlighting. The framework is designed for both simple scripts and complex real-time applications, with a focus on ease of use and composability. The core `View` trait defines layout, drawing, and event handling, while wrappers like `ViewWrapper`, `OnEventView`, `NamedView`, and `ResizedView` allow behavior composition without inheritance. The event system uses `EventTrigger` for declarative key binding and `Callback` for delayed actions. The style model supports gradients, palettes, effects, and TOML-based themes. The `Printer` abstraction handles coordinate transformations and styled drawing, and the `PrintBuffer` implements efficient double-buffering with diff-based output to minimize terminal writes. The builder module (experimental) enables declarative UI construction from YAML/JSON config files via a `Resolvable` trait and blueprint macros. The codebase is well-structured, extensively documented, and includes numerous examples and integration tests. It demonstrates strong software engineering practices: clean trait-based abstractions, thread-safe state via channels and `Arc`, efficient rendering, and modularity. While there is some code duplication across backends and a few deprecated items (e.g., `ScrollBase`), the overall quality is high and the library is actively maintained with a large user community.
tui-realm is a Rust library/framework for building terminal user interfaces (TUIs) using a component-based, event-driven architecture. It is not a standalone application but a reusable framework that wraps ratatui (formerly tui-rs) and provides an Application loop, Component/AppComponent traits, a Model/Update/View pattern, and a subscription system for routing events between components. The monorepo is organized as a Cargo workspace containing the core `tuirealm` crate, a `tuirealm_derive` procedural macro crate, a standard library of reusable components (`tui-realm-stdlib`: Input, Label, List, Table, etc.), and optional integration crates `tui-realm-textarea` and `tui-realm-treeview`. The framework is designed to reduce boilerplate by centralizing focus management, event routing, and state handling in the Application/View layer, while allowing developers to define custom components and event sources via Ports and Subscriptions.
Bonsai_term is a library for building Terminal User Interfaces (TUIs) using OCaml with a reactive programming model similar to bonsai_web. It provides a complete framework for handling terminal input/output, event processing (keyboard, mouse, resize), rendering views, and managing application state. The architecture follows a functional reactive pattern with clear separation between event handling, state management, rendering, and the main run loop. Key entry points are the start functions in loop.ml which take an application function defining the view and event handler. The system processes terminal events through an event queue, applies user-defined handlers to produce effects, and renders incremental view updates at a target frame rate.
TermUI is a comprehensive TypeScript monorepo providing a full-featured terminal UI framework for building rich, interactive command-line applications. It includes a custom JSX runtime with hooks, reconciliation, and portals; a theme engine (TSS) with CSS-like syntax and 26 built-in themes; a widget library spanning layout, input, display, data visualization, and feedback components; a motion system with spring physics and composable animations; a client-side router; a Zustand-like state store; adapters for external integrations (AI, Git, GitHub, clipboard, keychain); real-time system data hooks (CPU, memory, disk, Docker); a CLI scaffolding tool; and a dev server with hot reload. The framework is designed to offer a React-like development experience for terminal UIs, supporting JSX/TSX, keyboard and mouse input, focus management, accessibility (OSC 133), and unicode/ASCII fallbacks across 14+ packages with over 5000 tests.
Spiel is a terminal-based framework for creating and presenting slide decks using Python. It enables users to define slides as functions that return renderable objects (via Rich), and presents them in a navigable terminal user interface built with Textual. The framework supports features like live reloading during development, slide transitions, and dynamic content generation through a trigger system. The architecture centers around a `Deck` class that manages a sequence of `Slide` objects. Each slide's content is defined by a function that can optionally receive a `Triggers` object for time-based or interactive effects. The presentation is driven by a custom Textual application (`SpielApp`) that handles user input, screen transitions (including slide-to-slide animations), and automatic reloading of the deck when source files change. Key components include the CLI for launching presentations, a flexible slide definition system, and reusable widgets for rendering content such as syntax-highlighted code and images. Notable reusable components include the `Triggers` class for managing interactive state, the `Swipe` transition for slide animations, the `Image` widget for terminal image display, and a set of utility functions (`clamp`, `filter_join`, `chunks`) that solve common programming problems. These components are designed with low coupling and could be extracted for use in other projects with minimal modification.
Baton is a CLI tool for controlling Spotify playback with an integrated TUI for browsing and selecting music. The application uses Cobra for command structure, Viper for configuration, and the gocui library for the terminal interface. It interacts with the Spotify Web API to manage playback, search for content, and handle user library operations. The architecture separates API interactions (api package), command-line interface (cmd package), and TUI components (ui package). While functional, the codebase shows signs of aging due to outdated dependencies and tight coupling in some areas, particularly the API package's reliance on Viper for token management.