Projects sharing features with Ratatui

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

tui-rs is a Rust framework for building rich terminal user interfaces and dashboards. It provides a terminal layout engine for dividing the screen into flexible rectangular regions and a widget library for rendering data in a terminal. The project includes a cross-platform terminal backend abstraction layer to ensure consistent rendering and compatibility across different operating system terminal drivers. The framework covers a wide range of UI components, including data visualization tools such as charts, progress gauges, and sparklines, as well as structural elements like data tables, ite

This project is a framework for building interactive, graphical-style terminal applications. It provides a declarative component model that organizes user interfaces into a tree of nested widgets, each managing its own lifecycle, state, and rendering. By subclassing the base application class, developers can construct complex, keyboard-navigable interfaces that run directly within terminal emulators. The framework distinguishes itself through a reactive architecture and a CSS-based layout engine. It uses a reactive attribute system to automatically track state changes and trigger targeted int

Zellij is a terminal multiplexer and workspace manager designed to organize command-line sessions into persistent, reconfigurable layouts. It functions as a terminal plugin framework, allowing users to extend their environment with modular, event-driven components that interact with the host through a structured message-passing protocol. The project distinguishes itself through a layout-engine-based architecture that decouples visual pane arrangements from process execution, enabling automated and repeatable terminal workflows. It includes integrated support for web-based remote access, facil

gocui is a console user interface library for the Go programming language. It provides a toolkit for building interactive terminal applications using a layout engine that organizes overlapping rectangular views and coordinates. The library features a terminal input handler to capture and map keyboard shortcuts and mouse events to specific application actions. It includes an ANSI escape sequence parser to manage text attributes, colors, and cursor positioning. The framework covers interface view management and overlapping window layering, allowing for a structured arrangement of content. Rend

This project is a framework for building stateful, component-driven terminal user interfaces in Rust. It provides a structured architecture for managing complex command line applications by decoupling rendering logic from application state through a centralized message-passing system. By utilizing a component-based model, it enables developers to construct interactive interfaces that handle event routing, focus management, and lifecycle orchestration in a predictable manner. The framework distinguishes itself through its focus on modularity and developer productivity. It employs trait-based c

This project is a framework for composing terminal interfaces through declarative styling and a grid-based layout engine. It provides a comprehensive toolkit for building responsive command-line applications by managing ANSI escape sequences, color profiles, and text rendering to ensure consistent visual output across different terminal environments. The library distinguishes itself through its ability to automatically detect terminal capabilities and background themes, allowing it to adjust color schemes and downsample profiles for optimal readability. It utilizes a layered composition model

gui.cs is a .NET terminal user interface toolkit and framework used to build interactive, cross-platform text-based applications. It provides a structured system for composing terminal views using a view hierarchy and a dedicated layout engine. The library distinguishes itself through a component-based widget system and a constraint-based layout engine that allows interfaces to remain responsive across different terminal window dimensions. It employs a virtual-screen buffer to minimize flickering during redraws and uses state-driven theme configurations to maintain persistent visual styles.

Terminal.Gui is a cross-platform .NET toolkit for building interactive text-based user interfaces. It provides a component-based architecture, a terminal rendering engine, and a declarative layout system to create console applications that run consistently across Windows, macOS, and Linux. The framework distinguishes itself with a comprehensive set of interactive console widgets, including data grids, hex editors, and hierarchical tree components. It supports advanced visual capabilities such as 24-bit True Color, Sixel image support, and a relative-coordinate layout system that adapts to ter

LogicFlow is an SVG-based flowchart editing framework and visual graph editor used for building customizable business process diagrams. It serves as a customizable diagramming engine for rendering business process models, entity relationship diagrams, and unified modeling language charts. The system is characterized by a plugin-based architecture that allows developers to define specialized graphical elements and register pluggable modules. A distinctive feature is its overlay system, which positions standard HTML components on top of the SVG canvas to create interactive menus and control pan

Reflex is a full-stack web framework that enables the development of complete web applications using only Python. It provides a unified environment where server-side logic and client-side interfaces are synchronized through a shared, event-driven architecture. By using a declarative component language, the framework compiles code into reactive frontend elements and backend event handlers, allowing developers to manage the entire application lifecycle within a single codebase. The framework distinguishes itself through its reactive state management and integrated AI-assisted development tools.

This project is a declarative UI pattern library and reference implementation for structuring layouts, navigation flows, and data collections across Apple platforms. It provides a collection of practical implementation patterns and component examples for building user interfaces using the SwiftUI framework. The library serves as a cross-platform reference for rendering visual content on iOS and macOS. It includes a view implementation guide that covers managing navigation, handling user inputs, and embedding web content. The codebase covers broad capability areas including layout management

Tamagui is a cross-platform user interface framework designed to build high-performance, themeable applications that share logic and styling across web and mobile environments. It functions as a comprehensive design system orchestrator, providing a collection of type-safe components that compile to optimized atomic CSS for the web and native code for mobile platforms. By utilizing a build-time compiler, the framework eliminates runtime overhead, ensuring consistent visual output and interaction behavior regardless of the target platform. The framework distinguishes itself through its advanced

xterm.js is a high-performance terminal emulator library designed for web applications. It provides a core rendering engine and a modular interface that allows developers to embed fully functional, interactive command-line interfaces directly into browser environments. By processing standard terminal data streams and managing internal buffer states, the library enables the creation of rich, text-based user interfaces that support standard terminal protocols. The project distinguishes itself through a highly extensible architecture that allows for deep customization of terminal behavior. Devel

Bottom is a cross-platform system monitoring tool that provides real-time visibility into hardware performance and process activity within a terminal-based interface. Built as a command-line utility, it tracks metrics for processor, memory, storage, and network usage while offering tools to inspect, organize, and terminate active system processes. The application utilizes a modular layout engine that allows users to arrange independent data-visualization widgets into a custom grid. This interface is powered by an immediate-mode rendering approach and an event-driven input loop, ensuring the d

x-cmd is an AI agent orchestrator, cloud infrastructure CLI, and cross-platform package manager that provides an enhanced POSIX shell toolkit. It integrates large language models directly into the terminal for chatting, code generation, and the execution of agentic workflows, while offering a framework for building interactive terminal user interface components. The project distinguishes itself by deploying containerized AI agents within isolated sandboxes, provisioning them with specialized skills and headless browser automation capabilities. It further streamlines development through a unif

Ink is a declarative framework for building interactive command-line applications using a component-based architecture. It functions as a console renderer that maps component trees to terminal output buffers, allowing developers to manage stateful interfaces through standard component reconciliation. By translating high-level layout and style properties into terminal control codes, it enables the creation of responsive, dynamic interfaces within the console. The framework distinguishes itself by integrating a cross-platform layout engine that applies a flexible box model to the character-base

LibGDX is a Java-based framework designed for cross-platform game development, enabling the creation and deployment of 2D and 3D games across desktop, mobile, and web environments from a single codebase. It functions as a comprehensive library that abstracts hardware-accelerated graphics, audio, input, and file system access, providing a unified interface for developers to manage game logic and application lifecycles. The framework distinguishes itself through a high-performance architecture that prioritizes efficiency and native interoperability. It utilizes a batch-oriented graphics pipelin

Agent-skills is a collection of structured instructions and behavioral personas designed to standardize how AI coding agents perform engineering tasks. It functions as a workflow orchestrator that maps natural language intent to repeatable technical sequences and verification checklists. The project distinguishes itself through the use of specialized markdown-defined roles, such as security auditors or test engineers, to apply targeted domain expertise. It employs an evidence-based verification model that requires runtime data or passing tests as mandatory exit criteria to ensure AI-generated

Gitui is a terminal user interface and repository manager built with Rust. It provides a keyboard-driven visual environment for performing version control operations without the need to type manual command line arguments. The application enables the management of Git branches, commits, and remote synchronization, alongside capabilities for stashing temporary work and managing submodules. It includes support for GPG commit signing to verify identity through cryptographic signatures. Users can customize the experience through keyboard shortcut rebinding and visual theme adjustments. The interf

Claude Code is a command-line interface and multi-agent orchestration framework designed for autonomous software engineering. It enables AI agents to perform codebase modifications, debugging, and Git workflow management while coordinating multiple specialized agents to decompose and execute complex engineering tasks in parallel. The system distinguishes itself through a high degree of isolation and safety, utilizing Git worktrees to create independent working directories for concurrent agents and implementing a tiered permission system that combines user rules, project policies, and OS-level

Bubbles is a terminal user interface toolkit and component library providing a set of pre-built, reusable widgets for creating interactive command-line applications. It functions as a framework for building complex tools that require real-time updates and keyboard navigation. The library includes a variety of specialized interface elements such as fuzzy-filterable item lists, single-line and multi-line text inputs, and tabular data grids. It also provides visual feedback components including animated loading spinners, progress meters, countdown timers, and stopwatches. Additional capabilitie

Survey is a Go interactive prompt library and terminal user interface toolkit used to build command line interfaces that collect structured data. It provides a framework for rendering keyboard-navigable menus and forms across different operating systems. The toolkit includes components for gathering user confirmation, capturing text and password entries, and presenting paginated lists of choices. It supports multi-line input by integrating with the system's external text editor and provides contextual help displays to guide users. The library implements input validation logic to ensure respo

react-blessed is a React renderer for the blessed library that enables the construction of interactive command-line interfaces using a component-based architecture. It functions as a terminal user interface framework that maps a virtual component tree to a terminal environment, allowing React's declarative state management to control blessed terminal widgets and layout nodes. The system supports the integration of custom renderers through a dedicated creation function to change how nodes are instantiated. It provides a mechanism to retrieve original terminal library objects through references

Asciimatics is a cross-platform terminal user interface framework and console wrapper. It functions as a curses-compatible library providing a toolkit for building interactive text-based applications, an ASCII art generator, and a terminal animation engine. The project distinguishes itself through a visual effects engine capable of rendering sprites, particle systems, and anti-aliased lines. It includes specialized systems for creating moving text-based graphics and tools for converting image files into character-based representations. The framework covers core terminal management including

This project is a terminal user interface library for Node.js, designed to facilitate the construction of interactive command-line applications. It provides a comprehensive toolkit of high-level widgets that abstract complex terminal escape codes and rendering logic, allowing developers to build functional interfaces using reusable components. The framework distinguishes itself by implementing a box-model-based layout engine and a virtual DOM-style reconciliation system. These mechanisms enable responsive design patterns—such as percentage-based sizing and relative positioning—to function wit

Harlequin is a terminal-based SQL IDE that runs queries against DuckDB and SQLite databases, with a plug-in adapter system for connecting to additional database engines. It provides a full-screen text editor with syntax highlighting and fuzzy autocomplete for writing SQL, and displays query results in a scrollable table within the terminal. The application distinguishes itself through a tree-based data catalog that lets you browse database schemas, local files, and remote S3 objects, with the ability to insert or copy paths directly into the query editor. It supports custom key bindings throu