rivo/tview
Tview
tview is a library for building interactive text-based user interfaces in Go. It functions as a toolkit for managing event loops, user input, and screen rendering, providing a framework of pre-built widgets and an integrated layout engine for creating command-line applications.
The project distinguishes itself through a comprehensive layout system that uses grid and flexbox models to create responsive designs. It also supports UI layer stacking to manage multiple screens and modal overlays.
The framework includes a diverse suite of interactive components for data display, such as tables and hierarchical tree views, as well as input forms featuring text fields, checkboxes, and autocomplete suggestions. Visual capabilities extend to Unicode box-drawing, inline text styling for colors and attributes, and the rendering of images via pixel approximation and dithering.
Features
- Terminal Application Development - Functions as a comprehensive framework for building interactive command-line applications with rich widgets and layouts in Go.
- Interactive Component Suites - Provides a comprehensive suite of interactive widgets for building complex, data-driven command-line applications.
- Terminal User Interfaces - A core capability for rendering interactive text-based layouts and widgets within a terminal window.
- Layout Design - Includes a system for organizing terminal interface elements using grid and flexbox for responsive screen designs.
- Interactive Input Frameworks - Offers a toolkit for managing event loops and user interaction flows to build complex terminal environments.
- TUI Primitive Rendering - Implements low-level rendering by mapping graphical primitives and Unicode box-characters to screen coordinates.
- Focusable Primitives - Provides a framework for defining graphical primitives that manage their own focus state and rectangular positioning.
- TUI Component Primitives - Defines interactive widgets as independent objects that manage their own internal state and drawing logic.
- Cross-Platform TUI Frameworks - Provides a comprehensive suite of interactive terminal widgets including tables, trees, and forms.
- Responsive Layout Engines - Implements a responsive layout engine using flexbox and grid systems to calculate widget positions in the terminal.
- Flexbox Layouts - Features a flexbox-based layout system for organizing elements using proportional scaling and fixed dimensions.
- Flexible Grid Layouts - Implements a proportional grid system for positioning components with a mix of absolute and adaptive dimensions.
- Event-Driven Input Handlers - Ships an event-driven input handler that processes keyboard, mouse, and paste events via an asynchronous loop.
- Event-Queue Polling - Implements a centralized event-queue polling mechanism to handle keyboard and mouse input for a responsive UI loop.
- TUI Render Loops - Implements a core lifecycle manager that polls the event queue and triggers widget redraws on the screen.
- Go TUI Libraries - Provides a rich set of pre-built widgets and layout engines for building interactive TUIs in Go.
- Grid Layout Engines - Features a grid layout engine for organizing terminal components into responsive rows and columns with proportional sizing.
- Inline-Tag Styling - A system for formatting output with colors, bold or italic attributes, and hyperlinks using inline style tags.
- Layout Managers - Integrates multiple layout strategies, including grids and flexboxes, to organize interface components.
- Flexbox - Provides a flexbox layout system to distribute terminal interface elements horizontally or vertically with weighted scaling.
- Terminal Layout Engines - Implements a terminal layout engine for composing responsive interfaces using hierarchical widgets and grid/flexbox models.
- Complex Data Views - Offers a set of navigable tables, trees, and multi-color text areas for structured data browsing.
- Character-Based Image Approximation - A process for displaying images in the terminal by approximating pixels with graphical characters and applying dithering.
- Interactive Configuration Forms - Provides interactive forms, checkboxes, and dropdown menus to collect user settings inside the terminal.
- Box-Drawing Utilities - A capability to create visual borders and layout structures within a terminal using Unicode box-drawing and punctuation characters.
- Data Display Components - Provides a suite of data display components including scrollable text views, tables, and navigable lists.
- Screen Layering - Provides a mechanism for stacking multiple interface screens and toggling visibility to handle modal overlays and page transitions.
- Terminal Image Renderers - A feature for rendering visual image content directly within a text-based user interface.
- Form Input Components - Provides a collection of form input components combining text fields, selections, and checkboxes.
- Terminal-Based Dashboards - Provides tools for constructing real-time monitoring dashboards with formatted text and images in the console.
- Modal Dialogs - Features centered modal dialog windows with customizable text and buttons for user prompts.
- Overlay Management - Implements a system for managing the lifecycle of interruptive modal windows and critical alerts.
- Selectable Lists - Provides interactive vertical lists that support keyboard and mouse selection and focus management.
- Text Rendering - A feature for printing text with specific alignment and width constraints using inline style tags.
- Terminal Data Visualizations - Enables presenting structured data through navigable tables, tree views, and lists within a text-based interface.
- Tree Views - Includes a hierarchical tree view widget for displaying and navigating nested data structures.
- UI Layer Stacking - Supports stacking multiple interface screens to manage modal overlays and page transitions.
- Form Layouts - Provides form layout systems for aligning input controls and buttons using grid or flexbox containers.
- Command Line Tools - Library for building terminal UIs.
- TUI Libraries - Go library with interactive widgets.
