gyscos/Cursive
Cursive
Cursive is a cross-platform terminal user interface toolkit and framework for building interactive applications in Rust. It provides a modular system for creating text-based graphical interfaces, utilizing a dedicated engine to manage the main display loop and view hierarchies.
The toolkit features a backend-agnostic abstraction layer to ensure consistent rendering and input handling across different operating systems. It distinguishes itself through a palette-based theme engine that supports runtime theme loading and true color rendering, as well as the ability to generate user interface hierarchies directly from configuration files.
The framework covers a broad range of capabilities including complex layout management with split panels and tabs, and a variety of interactive components such as modal dialogs, progress indicators, and selectable lists. It supports rich content rendering for images and syntax highlighting, and employs a focus-cycle event routing system to manage keyboard navigation and global callbacks.
State management is handled through asynchronous UI updates and identifier-based access, allowing developers to modify specific views dynamically from background tasks.
Features
- Rust TUI Frameworks - A comprehensive toolkit for building interactive text user interfaces in the Rust programming language.
- Cross-Platform TUI Frameworks - Provides a framework for building interactive text-based user interfaces that work across multiple operating systems.
- Terminal User Interfaces - Provides a full framework and engine for building, styling, and managing interactive text-based user interfaces.
- Cross-Platform Terminal Utilities - Ensures consistent visual behavior and rendering for terminal applications across different operating systems.
- Terminal Abstractions - Provides a backend-agnostic abstraction layer that normalizes terminal capabilities and input handling across different operating systems.
- Terminal UI Frameworks - Provides a component-based architecture for creating interactive command-line interfaces with complex layouts.
- TUI Layer Composition - Stacks visual components like text blocks and checkboxes to define screen layout and content.
- Terminal Layout Engines - Implements a layout engine to organize complex screen arrangements using split panels, tabs, and nested views.
- View Hierarchies - Organizes user interface elements into a parent-child tree of nested containers and widgets for structured rendering.
- Flexible Layout Systems - Implements a flexible layout system using proportional units for responsive terminal UI design.
- Layout Organizing Containers - Uses resizable dividers, tabs, and split panels to structure the terminal workspace layout.
- Modular UI Compositions - Constructs complex interactive terminal applications by combining modular, independent view components.
- Rust TUI Toolkits - Offers a comprehensive toolkit for developing terminal-based interfaces with event and state management in Rust.
- TUI Component Rendering - Renders a wide array of terminal-based interface elements including tables, trees, and tabs.
- View Stack Managers - Controls interface depth by pushing and popping view layers in a managed stack.
- UI Layer Stacking - Manages multiple interface screens by stacking components to handle popups and transitions.
- Terminal UI Layouts - Provides components for arranging interface elements within flexible containers for terminal-based applications.
- View Identification - Tags UI elements with unique identifiers to enable mutation and retrieval from application logic.
- Dynamic Theme Loading - Provides runtime loading of external theme files to dynamically change visual styles and enable true color rendering.
- Global Input Listeners - Captures keyboard and mouse events to trigger application-wide actions independently of the current focus.
- Keyboard and Mouse Event Capture - Captures and maps keyboard and mouse input to callbacks and manages focus transitions.
- Task Progress Indicators - Renders progress bars with custom ranges and colors to visualize the completion status of tasks.
- Interactive CLI Tooling - Enables the design of interactive CLI tools featuring menus, forms, and dialogs with real-time status updates.
- Widget Focus Navigations - Provides keyboard-driven focus navigation to cycle through interactive GUI widgets sequentially.
- Rich Content Renderers - Renders rich content including images, HTML markup, calendars, and hexadecimal views directly within the terminal.
- Keyboard Navigation Interception - Intercepts key presses to execute custom logic before the default event handler processes them.
- Asynchronous UI Refresh - Refreshes views and progress indicators using data received from asynchronous background tasks.
- Virtual Color Palettes - Employs a palette-based theme engine using placeholder color tokens that resolve to runtime-configurable theme colors.
- Decorative Text Effects - Decorates text with custom colors and gradients using a palette-based system for visual emphasis.
- Identifier-Based View Mutation - Allows dynamic modification of view content and data access using unique view identifiers.
- Architectural State Synchronizers - Implements a system to synchronize UI state changes between background tasks and the main display loop via decoupled event messaging.
- Global Event Callbacks - Implements a system for defining and clearing global functions that respond to application-wide events.
- Global State Managers - Maintains a global application state shared across various UI components.
- Linear Positioning - Positions multiple UI elements side-by-side or in columns using horizontal and vertical layout containers.
- Interactive UI Elements - Implements interactive input interfaces with buttons and selection menus to collect user data.
- Interface Theming - Implements mechanisms for overriding default visual styles, colors, and border variables.
- Linear Layouts - Organizes interface elements in single horizontal or vertical rows with relative stretching.
- Modal Dialogs - Provides overlay components for focused user interaction and notifications via centered modal windows.
- Select Inputs - Provides dropdown-style select components for choosing values from a predefined list.
- Focus Management - Provides a system for managing keyboard focus and navigation cycles through interactive elements.
- Dimension Controllers - Provides programmatic control over fixed widths and heights of UI elements to maintain structure.
- Rich Text Renderers - Provides components to render text with markup decorations and support for non-ASCII characters and international languages.
- Specialized Data Components - Renders complex data structures including tables, trees, and calendars directly within the terminal interface.
- Syntax Highlighters - Includes syntax highlighters that render code snippets by mapping language patterns to visual styles.
- Tabbed Navigation - Organizes multiple views into selectable tabbed sections to facilitate interface navigation.
- Terminal Data Visualizations - Renders structured information including tables, trees, and progress bars using text-based graphics in the terminal.
- Text Input Fields - Implements editable text fields for capturing single-line and multi-line string input from the user.
- Text Markup Parsers - Parses and displays formatted text using a dedicated system to apply visual styles and gradients.
- User Input Capture - Collects user data via text fields and sliders to drive the internal application logic.
- TUI Scroll Views - Wraps content in scroll views to control positioning and handle scrolling events.
- Window Management Components - Provides framed window containers for organizing content with titles and interactive buttons.
- Instance Identifiers - Uses unique identifiers assigned to view instances to allow targeted updates and communication from external callbacks.
- Developer Tools - Library for building rich TUI applications.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
