awesome-repositories.comBlog
© 2026 Bringes Technology SRL·VAT RO45896025·hello@bringes.io
MCPBlogSitemapPrivacyTerms
Textual | Awesome Repository
← All repositories

Textualize/textual

0
View on GitHub↗
34,369 stars·1,100 forks·Python·mit·0 viewstextual.textualize.io↗

Textual

AI search

Explore more awesome repositories

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

Let's find more awesome repositories

Features

  • Terminal Application Frameworks - Provides a base application class to capture user input and manage screen updates in terminal environments.
  • Terminal User Interface Frameworks - Constructs terminal user interfaces using a library of pre-styled widgets and a flexible layout system.
  • Command Palettes - Displays a command palette modal for searching and executing commands using keyboard navigation.
  • Component Hierarchies - Organizes the user interface into a tree of nested objects that manage their own lifecycle, state, and rendering.
  • Declarative UI Frameworks - Enables the creation of sophisticated, interactive user interfaces using a declarative component model.
  • Terminal UI Components - Provides interactive checkbox controls for toggling options within terminal-based applications.
  • Terminal User Interfaces - Provides an event-driven framework for building interactive, graphical-style applications in terminal environments.
  • Application Definitions - Provides a base class to configure CSS paths, driver settings, and initial screen layouts.
  • Reactive Component Models - Updates interface elements automatically in response to underlying data changes.
  • Buttons - Display a focusable button that triggers specific actions through mouse clicks or keyboard input, supporting visual variations for different states.
  • CSS Styling - Applies visual styles and layout rules to widgets using a cascading stylesheet syntax.
  • Reactive State Management - Handles state updates automatically to trigger interface refreshes without manual initialization.
  • Reactive State Systems - Automatically tracks state changes in widget properties to trigger targeted interface refreshes.
  • UI Composition - Implements a compose method that yields widget instances to automatically mount them into the application layout.
  • Snapshot Testing Utilities - Captures and compares terminal output snapshots against expected results to automatically detect visual regressions.
  • Checkboxes - Display a focusable checkbox that stores a boolean value and allows users to change its state using the enter or space keys.
  • Component Querying - Retrieves widgets from the hierarchy using CSS selectors or type-based matching.
  • Data Tables - Provides interactive tabular components with support for sorting, navigation, and custom cell rendering.
  • Event Handlers - Responds to user interactions like key presses and mouse actions by defining event handler methods.
  • Event Handling - Propagates events from a child widget to its parent to allow parent widgets to respond to unhandled input.
  • List Views - Show a vertical list of items that users can navigate, highlight, and select using keyboard shortcuts or mouse interactions.
  • Navigation Controllers - Controls screen visibility by pushing, popping, or switching between different application containers.
  • Radio Buttons - Display a focusable radio button that stores a boolean value and functions within a group to allow single-choice selection from a list.
  • Tabbed Interfaces - Display a tabbed interface that allows users to switch between content sections using mouse clicks or keyboard navigation with dynamic tab management.
  • Terminal Layout Engines - Enables responsive terminal interface design using hierarchical widget structures and styling rules.
  • Text Input Widgets - Display a single-line text input field that supports focus, custom placeholders, and specific data types to restrict user input.
  • Message Buses - Coordinates communication between widgets and background tasks using a non-blocking event loop.
  • Terminal Widget Toolkits - Provides pre-built widgets and controls for rapid construction of keyboard-navigable terminal applications.
  • Concurrency Utilities - Executes long-running tasks concurrently to keep the user interface responsive during heavy computations.
  • Asynchronous Task Orchestrators - Provides systems for managing background operations and concurrency without blocking the main thread.
  • Reactive State Management - Synchronizes application data with user interface components to ensure the display reflects current state.
  • Interaction Testing Frameworks - Executes key presses and mouse clicks within an asynchronous test environment to verify application behavior.
  • Dropdown Menus - Display a compact, focusable dropdown menu that allows users to select a single value from a list of predefined options.
  • Layout Engines - Calculates widget geometry and visual properties by applying cascading style rules to a hierarchical tree of components.
  • Message Handlers - Automatically maps and executes logic when specific events reach a widget.
  • Selectable Lists - Provides interactive vertical lists supporting selection, focus, and custom item states.
  • Selection Lists - Show a vertical list of selectable options that users can navigate and toggle, supporting custom data types and rich text.
  • Text Input Controls - Collects user text input through terminal-based controls designed for data entry.
  • Theming Systems - Registers custom color themes to provide reusable CSS variables for application components.
  • Data Table Components - Shows structured data in a table format with configurable cursors for navigation and selection.
  • Command Providers - Implements custom search and discovery logic for dynamic command sets.
  • Asynchronous Event Loops - Manages concurrent tasks and user input through a non-blocking, single-threaded execution environment.
  • Thread Management - Executes blocking code in separate threads while safely communicating back to the main interface thread.
  • Task Delegation Systems - Offloads blocking operations to background threads to maintain high frame rates in the main interface loop.
  • Button Components - Displays interactive buttons in the terminal with various semantic styles and visual layouts.
  • Event Propagation Systems - Allows parent components to respond to unhandled child interactions through event bubbling.
  • File System Browsers - Show a navigable filesystem tree widget that allows users to browse directories and files within a terminal-based application.
  • Log Viewers - Provides scrollable widgets designed for real-time appending and management of text streams.
  • Markdown Renderers - Provides components for displaying formatted documents with support for typography and code blocks.
  • Masked Inputs - Display a text input field that restricts user entry based on a template mask to provide visual guidance and automatic validation.
  • Text Editors - Display a multi-line text input area that supports text selection, soft wrapping, undo history, and optional syntax highlighting.
  • Tree Views - Show hierarchical data in a focusable tree widget that supports expanding, collapsing, and selecting nodes through keyboard navigation.
  • Widget Styling - Updates terminal display automatically when visual properties are changed on the styles object.
  • Web-Based Terminal Emulators - Serves terminal-based applications directly to web browsers for remote access.
  • Markdown Rendering Components - Renders and interacts with Markdown documents, including automatic table of contents generation.
  • Fuzzy Matching - Calculates match scores against candidate strings to improve search results.
  • Command Discovery - Yields command hits based on user input or default discovery states.
  • Command Palettes - Provides a searchable, fuzzy-matched command interface for efficient keyboard-driven application control.
  • Terminal Application Runners - Executes terminal applications using a dedicated runner that supports file paths and module imports.
  • Terminal Debugging Tools - Connects a separate console to capture system messages and events in real-time.
  • Background Task Managers - Monitors background task states and performs automatic cleanup when associated widgets are removed.
  • Terminal Drivers - Translates high-level UI commands into platform-specific escape sequences for consistent terminal rendering.
  • Concurrent Task Runners - Runs multiple coroutines concurrently and monitors their completion status and lifecycle.
  • Collapsible Containers - Display a container with a title that allows users to show or hide content by clicking or pressing enter on the component.
  • Data Inspectors - Provides interactive containers for viewing and debugging complex data structures.
  • Flexible Layout Systems - Uses fraction units to define flexible widget dimensions that automatically scale based on window size.
  • Footer Widgets - Show a docked footer at the bottom of a container that automatically lists available keybindings for the currently focused widget.
  • Header Widgets - Show a header at the top of a container that automatically pulls the application title, subtitle, icon, and clock.
  • Loading Indicators - Provides animated visual elements to signal background data processing or loading states.
  • Markdown Viewers - Provides components for rendering and navigating structured markdown content within terminal interfaces.
  • Progress Indicators - Show a progress bar widget to track the status of time-consuming tasks, supporting both indeterminate states and percentage-based completion tracking.
  • Radio Button Groups - Provides containers for managing mutually exclusive selection states among multiple options.
  • Real-time Loggers - Provides widgets for streaming and managing live log output with automatic scrolling.
  • Switch Widgets - Provides toggleable boolean input components with keyboard and styling support.
  • Tabbed Navigation Components - Switches between different content views using a row of selectable tabs.
  • View Switchers - Provides containers that manage and toggle visibility between multiple child widgets.
  • Message Systems - Enables communication between widgets by defining custom message classes and posting them to the queue.

    • 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 interface refreshes, eliminating the need for manual re-rendering logic. The layout engine allows developers to define widget geometry and visual properties using cascading style rules, enabling responsive designs that scale proportionally. Furthermore, an asynchronous message bus and non-blocking event loop coordinate communication between widgets and background tasks, ensuring the interface remains responsive during heavy computations.

    The toolkit includes a comprehensive library of pre-styled components, such as data tables, text editors, tree views, and tabbed interfaces, alongside a fuzzy-matching command palette for efficient user navigation. It also provides robust developer tooling, including live CSS editing, snapshot testing for visual regressions, and the ability to serve terminal applications directly to web browsers.