Textualize/textual

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.
• 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.
• CLI Development - Listed in the “CLI Development” section of the Awesome Python awesome list.
• Terminal Widget Toolkits - Provides pre-built widgets and controls for rapid construction of keyboard-navigable terminal applications.
• 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.
• 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.
• Concurrency Models - Manages concurrent tasks and user input through a non-blocking, single-threaded execution environment.
• 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 and Markup Tools - 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 Emulators - 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.
• 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.

Star history