awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
ratatui avatar

ratatui/ratatui

0
View on GitHub↗
18,525 stars·573 forks·Rust·mit·13 viewsratatui.rs↗

Ratatui

Ratatui is a Rust framework for building interactive, stateful terminal user interfaces. It provides a modular architecture that maps application data to visual components, enabling the creation of complex, text-based applications that run directly in the terminal.

The library distinguishes itself through an immediate-mode rendering system that utilizes double-buffering to minimize flickering and reduce communication overhead. It employs a constraint-based layout engine to partition screen space into nested segments, allowing for the construction of sophisticated visual hierarchies that remain responsive to terminal resizing and state changes.

The framework encompasses a comprehensive suite of tools for terminal lifecycle management, including initialization and restoration protocols to ensure consistent environment behavior. It supports a wide range of interface development capabilities, such as input event handling for keyboard and mouse interactions, component styling, and the rendering of various widgets like lists, modals, and text blocks.

Developers can validate interface logic and rendering output through built-in testing utilities that allow for the simulation of events and the capture of buffers without requiring an active terminal session. The library is designed to integrate with standard error handling mechanisms to provide diagnostic context during application execution.

Features

  • Terminal User Interface Frameworks - Provides a comprehensive framework for building interactive, text-based applications that run directly in the terminal.
  • Terminal User Interface Frameworks - Serves as a high-performance toolkit for creating complex, stateful terminal interfaces using a modular widget-based architecture.
  • Rendering Engines - Maps application state to visual widgets and renders them within a frame buffer for terminal displays.
  • Terminal Abstractions - Provides a cross-platform interface that supports multiple terminal output methods to ensure consistent rendering.
  • Layout Constraints - Partitions terminal screen space into nested regions using constraints to organize widgets into structured layouts.
  • Immediate-Mode Rendering - Maps application state to visual components and draws them to a frame buffer during every iteration of the main loop.
  • Terminal-Agnostic Renderers - Provides a generic interface that decouples rendering logic from specific terminal protocols to ensure consistent output across diverse environments.
  • Terminal Input Handlers - Provides a system for capturing and handling keyboard and mouse events to drive interactive application loops.
  • Application - Maintains a continuous execution loop that processes user input and periodic ticks to update application state and refresh the display.
  • Terminal Lifecycle Managers - Manages terminal initialization and restoration protocols to ensure a clean environment and prevent display corruption.
  • Application State Managers - Manages UI screen state and input focus to ensure predictable transitions within the application.
  • Constraint Layout Engines - Implements a layout engine that partitions screen space into nested segments using dynamic hierarchical constraints.
  • Interaction and Event Handling - Captures and processes keyboard and mouse interactions to drive responsive, event-driven command-line tools.
  • Terminal Layout Engines - Organizes screen space into structured grids, nested regions, and modal overlays to present data in a readable format.
  • Terminal Output Monitors - Captures widget output into buffers to verify interface rendering without requiring an active terminal session.
  • Terminal Mode Managers - Resets the terminal to its original configuration before displaying error messages to ensure the interface remains readable after a crash.
  • Double Buffering - Uses off-screen buffers to compare state changes and minimize flickering during terminal output updates.
  • Component Composition Primitives - Constructs user interfaces by nesting modular widgets that derive their visual representation directly from the current application data model.
  • Event-Driven Architectures - Maintains a continuous execution loop that processes input and timer events to trigger state-driven interface refreshes.
  • Test Utilities & Assertions - Provides utilities for simulating input events and asserting state transitions to validate application logic.
  • Component Styling - Applies visual decorations like borders and colors to interface elements to improve readability and hierarchy.
  • List Components - Displays collections of items as vertical lists for structured information or selectable entries.
  • Overlay Components - Supports drawing widgets on top of existing content to create popup windows and overlays.
  • Testing Utilities - Enables validation of interface logic and rendering output by simulating events and capturing buffers without an active terminal.
  • Text Components - Renders text blocks with optional borders and decorations for titles, labels, and informational content.

Star history

Star history chart for ratatui/ratatuiStar history chart for ratatui/ratatui

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with Ratatui

These projects share indexed features with Ratatui. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • tui-rs-revival/ratatuitui-rs-revival avatar

    tui-rs-revival/ratatui

    21,091View on GitHub↗

    Ratatui is a Rust framework and cross-platform terminal renderer used to build rich terminal user interfaces. It functions as a toolkit for creating interactive command-line displays, dashboards, and data visualizations. The library employs an immediate mode rendering approach, where the interface is redrawn every frame based on the current application state. It uses a widget-based layout system to compose complex text-based interfaces. The framework includes a rectangle-based layout engine and a backend-agnostic drawing system to decouple UI logic from specific terminal emulators. It furthe

    Rust
    View on GitHub↗21,091
  • anomalyco/opentuianomalyco avatar

    anomalyco/opentui

    12,131View on GitHub↗

    Opentui is a terminal user interface framework for building interactive command line applications. It provides a component-based system featuring a flexbox layout engine, a virtual node component tree, and a low-level 2D cell array renderer. The project is distinguished by a sophisticated keyboard binding engine that maps complex multi-stroke sequences and chords to named commands using prioritized, reactive layers. It also implements a plugin architecture that allows external modules to inject custom UI components into designated layout slots and extend input logic at runtime. Its capabilit

    TypeScript
    View on GitHub↗12,131
  • nsf/termbox-gonsf avatar

    nsf/termbox-go

    4,786View on GitHub↗

    termbox-go is a Go terminal user interface library and cross-platform terminal emulator abstraction. It provides a system for creating text-based graphical interfaces by managing a terminal cell buffer and handling raw input events. The library functions as a terminal cell buffer manager and input handler. It maintains an internal grid of characters and colors, using a back buffer to synchronize updates to the physical screen and translate keyboard and mouse events into structured data. Its capability surface covers text user interface rendering and terminal display management, including cur

    Go
    View on GitHub↗4,786
  • ratatui-org/ratatuiratatui-org avatar

    ratatui-org/ratatui

    21,277View on GitHub↗

    Ratatui is a terminal rendering engine and library for the Rust language used to build interactive text-based user interfaces. It provides a framework for creating command-line dashboards and visual applications by rendering widgets and layouts directly to a terminal screen. The project utilizes a backend-agnostic interface to decouple UI logic from terminal drivers and employs a constraint-based layout engine to divide screen space into nested rectangular areas. It manages rendering through an immediate-mode drawing loop and a buffer-based system to minimize screen flicker. The library supp

    Rust
    View on GitHub↗21,277
Compare all 30 related projects→

Frequently asked questions

What does ratatui/ratatui do?

Ratatui is a Rust framework for building interactive, stateful terminal user interfaces. It provides a modular architecture that maps application data to visual components, enabling the creation of complex, text-based applications that run directly in the terminal.

What are the main features of ratatui/ratatui?

The main features of ratatui/ratatui are: Terminal User Interface Frameworks, Rendering Engines, Terminal Abstractions, Layout Constraints, Immediate-Mode Rendering, Terminal-Agnostic Renderers, Terminal Input Handlers, Application.

Which projects share features with ratatui/ratatui?

Projects with overlapping indexed features include: tui-rs-revival/ratatui — Ratatui is a Rust framework and cross-platform terminal renderer used to build rich terminal user interfaces. It… anomalyco/opentui — Opentui is a terminal user interface framework for building interactive command line applications. It provides a… nsf/termbox-go — termbox-go is a Go terminal user interface library and cross-platform terminal emulator abstraction. It provides a… ratatui-org/ratatui — Ratatui is a terminal rendering engine and library for the Rust language used to build interactive text-based user… fdehau/tui-rs — tui-rs is a Rust framework for building rich terminal user interfaces and dashboards. It provides a terminal layout… textualize/textual — This project is a framework for building interactive, graphical-style terminal applications. It provides a declarative…