tui-cs/Terminal.Gui

Terminal.Gui is a cross-platform .NET library for building interactive terminal-based user interfaces. It provides a comprehensive suite of UI controls, including text and code editors, data grids, and complex layouts, all rendered via ANSI escape sequences or raster graphics protocols. The system features a modernized, instance-based application model with robust input handling for keyboard and mouse events, alongside advanced drawing primitives for colors, gradients, and Unicode text.

91 changes.

This period marks the comprehensive rewrite of Terminal.Gui into version 2, introducing an instance-based application model, a modernized input and command system, and a declarative layout engine. The codebase was significantly expanded with new UI components, including graph and table views, while the configuration and drawing subsystems were refactored for AOT compatibility and performance.

50 changes.

This period focused on a comprehensive refactoring of the terminal input and output subsystems, introducing new abstraction layers for keyboard, mouse, and screen rendering. The work established a modernized, testable architecture for handling console interactions and visual updates, supported by extensive unit and integration tests. Additionally, the codebase expanded to support advanced features like raster image rendering and Markdown display.

A new Character Map scenario has been added to the UICatalog examples. This scenario demonstrates building a custom control that displays Unicode characters, tests unicode character rendering in Terminal.Gui, and illustrates how to implement infinite scrolling and header styling for a TableView.

Examples/UICatalog/Scenarios/CharacterMap · high confidence

Adds new UI components for selecting values: FlagSelector and its generic counterpart for selecting multiple non-exclusive flags from an enum; OptionSelector and its generic counterpart for selecting a single option from a list; and the shared SelectorBase class that manages navigation, focus, and activation logic for these controls.

Terminal.Gui/Views/Selectors · high confidence

Users can now view images in terminals that support the Kitty graphics protocol, providing an alternative to Sixel for high-performance, flash-free panning and zooming of images. This new capability includes automatic detection of Kitty-compatible terminals (such as Kitty and Ghostty) and a dedicated encoder to handle image transmission and placement updates efficiently.

Terminal.Gui/Drawing/Kitty · high confidence

Added new classes in the Terminal.Gui.Drawing.Sixel namespace to enable rendering images via the Sixel protocol. This includes SixelEncoder for converting bitmaps to Sixel format, SixelSupportDetector for checking terminal compatibility, and supporting types (SixelSupportResult, SixelToRender) to manage the rendering pipeline.

Terminal.Gui/Drawing/Sixel · high confidence

A new \SpectreView\ component and \SpectreMarkupBridge\ are introduced in the \Terminal.Gui.Interop.Spectre\ package. \SpectreView\ is a read-only view that renders \Spectre.Console\ \IRenderable\ objects, handling layout, auto-sizing, and segment drawing. The bridge provides bidirectional conversion between \Spectre.Console\ \Style\ and \Terminal.Gui\ \Attribute\ objects, mapping colors and text decorations (bold, italic, underline, etc.) between the two frameworks.

Terminal.Gui.Interop.Spectre · high confidence

The UICatalog application now includes an 'Animation' scenario that demonstrates how to render animated GIF images using threading. This new example showcases the \ImageView\ component's ability to handle multi-frame images and update the display at regular intervals, providing a practical template for developers looking to implement animated visual elements in their terminal-based applications.

Examples/UICatalog/Scenarios/AnimationScenario · high confidence

The UICatalog demo now includes a new 'Images' scenario that demonstrates cell and raster image rendering with runtime capability detection. Users can toggle between cell-based and raster-based image display, select raster protocols (Auto, Kitty, Sixel), and view a live 'Fire' animation rendered as a raster image. The scenario also includes helper classes for color distance calculation (CIE76, Lab) and palette building (MedianCut, ConstPalette) to support image processing within the demo.

Examples/UICatalog/Scenarios/Images · high confidence

The Markdown view now supports syntax highlighting for fenced code blocks, allowing code to be colorized based on the specified programming language. This is achieved through a new \ISyntaxHighlighter\ interface and a \TextMateSyntaxHighlighter\ implementation that leverages the TextMateSharp library to provide 50+ language support. The update includes a \StyledSegment\ class to carry semantic roles and explicit attributes, and a \MarkdownAttributeHelper\ to resolve visual styles for different Markdown elements. Users can now assign a highlighter to the \Markdown\ view to enable colored code blocks, with automatic fallback to unstyled rendering if the native library is unavailable.

Terminal.Gui/Drawing/Markdown · high confidence

Added a set of AI agent configuration and guidance files to the repository root, including .aider.md, .cursorrules, .windsurfrules, AGENTS.md, and CLAUDE.md. These files provide critical instructions for AI coding agents, specifically warning them to discard pre-2025 training data about Terminal.Gui, as v2 is a complete rewrite. The files contain a v1 to v2 corrections table, correct minimal application patterns, and detailed coding conventions (e.g., target-typed new, collection expressions, guard clauses) to ensure AI-generated code aligns with the modernized codebase.

(repo-wide) · high confidence

Users can now use the new CharMap view to browse and select Unicode codepoints. This component displays a scrollable grid of glyphs with row and column headers, supporting keyboard and mouse navigation, context menus, and wheel scrolling. The implementation includes a dedicated API client for fetching Unicode data and defines Unicode ranges for non-BMP characters.

Terminal.Gui/Views/CharMap · high confidence

A new C\# script, OutputView.cs, has been added to the docfx build pipeline. This tool allows users to generate static HTML or ANSI text representations of Terminal.Gui views for documentation purposes. It supports command-line arguments to specify the view name, output file path, terminal dimensions, and ANSI formatting. The script initializes the Terminal.Gui application, renders the specified view once, and outputs the result, enabling automated generation of view documentation.

docfx/scripts/OutputView · high confidence

Two new Roslyn-based CLI tools have been added to the repository to automate C\# code cleanup tasks. The BackingFieldReorderer script reorders class members to place backing fields immediately before their corresponding properties. The PartialSplitter script analyzes large classes and splits them into multiple partial files based on functional grouping heuristics (e.g., Mouse, Keyboard, Drawing). These tools are located in the Scripts directory and provide a way to automatically refactor C\# code structure.

Scripts/BackingFieldReorderer, Scripts/PartialSplitter · high confidence

Introduced a new \CollectionNavigation\ subsystem that enables fast, type-ahead search and navigation for \ListView\, \TreeView\, and \TableView\ controls. The change adds a set of new classes (\CollectionNavigator\, \CollectionNavigatorBase\, \TableCollectionNavigator\) and interfaces (\ICollectionNavigator\, \ICollectionNavigatorMatcher\) that handle keystroke-based filtering and selection cycling. Users can now type characters to quickly jump to matching items in a list or table, with the search string clearing after a short delay or when an invalid key is pressed.

Terminal.Gui/Views/CollectionNavigation · high confidence

A new source generator in Terminal.Gui.Analyzers.Internal now automatically produces high-performance extension methods for public enums. The generator creates AsInt32 and AsUInt32 methods for direct binary conversion, and for enums marked with FlagsAttribute, it generates FastIsDefined and FastHasFlags methods that use unsafe casts and bitwise operations for improved performance.

Terminal.Gui.Analyzers.Internal · high confidence

A new DocSnippetValidator tool has been introduced to compile every fenced C\# code block in the documentation against the Terminal.Gui assembly. This ensures that code examples remain valid and prevents 'v1 API rot' by treating obsolete API usage (CS0618/CS0612) as compilation failures rather than warnings. The validator automatically skips blocks marked as anti-patterns or explicitly ignored, and includes a negative-test fixture to ensure obsolete APIs are correctly rejected.

Scripts/DocSnippetValidator · high confidence

The Terminal.Gui library now includes a comprehensive set of localized string resources for multiple languages, including English, French, Japanese, Portuguese, and Simplified Chinese. This is supported by a new \GlobalResources\ class and a \ResourceManagerWrapper\ that ensures proper fallback to invariant culture for missing translations. Additionally, a \config.json\ file has been added to define default values for all settings managed by the ConfigurationManager, allowing for easier configuration of themes, colors, and other UI properties.

Terminal.Gui/Resources · high confidence

The UICatalog application now includes a new 'EditorsAndHelpers' scenario that provides interactive editors for various View properties. This includes editors for layout (position, dimensions), arrangement, navigation, and adornments (margin, border, padding, and general adornment settings). The scenario also features an 'AllViewsView' that dynamically generates and displays all available View types, and an 'AttributeViewer' for inspecting visual attributes. These tools allow users to explore and modify View properties in real-time within the UICatalog demo.

Examples/UICatalog/Scenarios/EditorsAndHelpers · high confidence

Added PowerShell scripts to automate the build and documentation pipeline. The new \Generate-SourceIndex.ps1\ script scans the codebase and documentation to produce a Vercel-style file index for AI agent retrieval-led reasoning, injecting the result into \AGENTS.md\. The \build.ps1\ script now orchestrates the DocFX build, including the source index generation and building the \OutputView\ tool. Additionally, \generate-views-doc.ps1\ was added to automatically generate the \views.md\ documentation page by processing API YAML files and recording GIF demonstrations using \tuirec\.

docfx/scripts · high confidence

Added a new \IMouseHoldRepeater\ interface and \MouseHoldRepeaterImpl\ class to manage periodic mouse-hold events with an accelerating timeout pattern, allowing views to trigger repeated actions (like auto-scrolling) while a button is held down. The \MouseState\ enum was introduced to track mouse interaction states (None, In, Pressed, PressedOutside). Additionally, the \View\ class now exposes \MouseBindings\ and \DefaultMouseBindings\ to allow configurable mouse command bindings, including support for platform-specific modifiers (e.g., Alt, Shift, Ctrl) for selection and activation commands.

Terminal.Gui/ViewBase/Mouse · high confidence

The Terminal.Gui library now includes a dedicated .NET driver implementation (NetInput, NetOutput, NetInputProcessor, etc.) that handles console I/O using native .NET methods. This new driver supports features like bracketed paste, mouse event reporting, and cursor control, while gracefully handling scenarios where no terminal is attached (e.g., in unit tests or headless environments).

Terminal.Gui/Drivers/DotNetDriver · high confidence

Added the ImageView component, which renders images using either cell-based coloring or high-performance raster graphics protocols (Kitty and Sixel). This new view supports zooming, panning, and background rendering, providing a robust way to display images in terminal UIs.

Terminal.Gui/Views/ImageView · high confidence

Added new \Runnable\, \Runnable\<TResult\>\, and \RunnableWrapper\<TView, TResult\>\ classes in the \Terminal.Gui.Views\ namespace. These classes provide a standardized way to run views as blocking, modal, or inline sessions within the terminal, supporting typed result extraction and cancellation handling via the Cancellable Work Pattern.

Terminal.Gui/Views/Runnable · high confidence

The ScenarioRunner example now supports a new command-line interface that allows users to list, run, and benchmark scenarios directly from the terminal. Users can specify options such as the target driver, disable configuration management, force 16-color mode, set benchmark timeouts, and save results to a file. This provides a more flexible way to execute and measure UI scenarios without relying solely on the graphical menu.

Examples/ScenarioRunner · high confidence

The application now supports a modern, instance-based lifecycle where developers create and manage their own \IApplication\ instances via \Application.Create()\, rather than relying on a global static singleton. This change introduces thread-local events (\InstanceCreated\, \InstanceInitialized\, \InstanceDisposed\) to support parallel test execution. Additionally, a new \AppModel\ enum allows applications to run in \Inline\ mode, which renders within the primary terminal buffer instead of using the alternate screen buffer, enabling inline terminal applications.

Terminal.Gui/App · high confidence

Added a new pure ANSI driver implementation for Terminal.Gui, consisting of the AnsiComponentFactory, AnsiInput, AnsiInputProcessor, AnsiOutput, and supporting classes (AnsiPlatform, AnsiSizeMonitor, AnsiTerminalHelper, FakeClipboard). This driver handles input and output using ANSI escape sequences, supporting both Windows (Virtual Terminal) and Unix/Mac (raw mode) platforms, and enables features like bracketed paste and rich keyboard event models.

Terminal.Gui/Drivers/AnsiDriver · high confidence

Adds a new Cancellable Work Pattern (CWP) framework to the application, introducing helper classes (CWPEventHelper, CWPPropertyHelper, CWPWorkflowHelper) and event argument types (ResultEventArgs, ValueChangingEventArgs, etc.) to standardize how the application handles cancellable workflows and property changes.

Terminal.Gui/App/CWP · high confidence

The Terminal.Gui library adds a new, fully generic \TreeView\<T\>\ control that supports lazy-loading of child nodes via an \ITreeBuilder\<T\>\ interface, allowing for efficient rendering of large or deep hierarchies. The update includes a \CheckboxMode\ for multi-state selection, a \TreeViewTextFilter\ for client-side filtering, and a \DrawLine\ event for customizing row rendering. Additionally, a non-generic \TreeView\ is provided for use with the \ITreeNode\ interface, and the control now supports multi-select navigation and keyboard shortcuts for expanding/collapsing branches.

Terminal.Gui/Views/TreeView · high confidence

The Terminal.Gui/Input area now includes a comprehensive command system, introducing the Command enum with explicit integer values to ensure ABI stability for key and mouse bindings. This change adds new types such as CommandContext, CommandBinding, and CommandBridge to handle command routing, including support for bridging commands across non-containment boundaries like popovers. Additionally, it introduces a new paste pipeline with dedicated event arguments (PasteEventArgs, PastingEventArgs, PastedEventArgs) to handle bracketed paste and text insertion, replacing previous ad-hoc event handling with a unified command-based approach.

Terminal.Gui/Input · high confidence

Added a new \Terminal.Gui.App.Timeout\ namespace containing a \TimedEvents\ class and \ITimedEvents\ interface to manage scheduled callbacks with high-resolution timing via \Stopwatch\. The update includes a \Timeout\ base class and specialized implementations (\LogarithmicTimeout\, \SmoothAcceleratingTimeout\) that support dynamic interval adjustments, allowing for more responsive or adaptive timeout behaviors in the application loop.

Terminal.Gui/App/Timeout · high confidence

The Terminal.Gui library now includes a new \EscSeqUtils\ class and supporting types (\EscSeqReqStatus\, \EscSeqRequests\) to manage ANSI escape sequences. This provides a platform-independent API for common terminal control sequences, including screen clearing, mouse tracking modes (1003, 1006, 1015), and window size adjustments, enabling more robust terminal interaction and input handling.

Terminal.Gui/Drivers/AnsiHandling/EscSeqUtils · high confidence

The FileDialog view has been replaced with a new implementation that supports filtering files by extension via the new AllowedType and IAllowedType interface. The dialog now includes a navigation history stack (Back/Forward/Up buttons) and a collapsible directory tree view alongside the file list. Default file operations for Delete, Rename, and New are provided, including path-traversal protection and invalid character validation. The dialog's base type has been refactored to return IReadOnlyList\<string\> for multiple file selections.

Terminal.Gui/Views/FileDialogs · high confidence

Adds a new autocomplete system for terminal GUI controls, including the \IAutocomplete\ interface, \AutocompleteBase\ abstract class, and concrete implementations like \AppendAutocomplete\ and \PopupAutocomplete\. The change also introduces \SingleWordSuggestionGenerator\ for text-based suggestions and \FilepathSuggestionGenerator\ for file path completion, along with supporting classes like \AutocompleteContext\ and \Suggestion\.

Terminal.Gui/Views/Autocomplete · high confidence

The Terminal.Gui/Drawing namespace now includes a new \Attribute\ struct to represent visual styling (foreground, background, and text style), a \Cell\ record struct to hold grapheme data and attributes, and a \FillPair\ class to manage foreground and background fills. Additionally, the \Region\ class has been introduced to handle geometric set operations like union and intersection for clipping and layout calculations, while \Gradient\ and \GradientFill\ provide support for color gradients in rendering.

Terminal.Gui/Drawing · high confidence

Adds a new \Terminal.Gui.FileServices\ namespace containing a suite of components to support the \FileDialog\. This includes \FileSystemTreeBuilder\ for generating file system trees, \FileSystemColorProvider\ and \FileSystemIconProvider\ for visual customization, \FileSystemInfoStats\ for metadata, and \ISearchMatcher\/\DefaultSearchMatcher\ for search functionality. These classes provide the underlying logic for file selection, navigation, and display within the file dialog.

Terminal.Gui/FileServices · high confidence

A new set of internal classes and interfaces has been added to the Terminal.Gui.App namespace to manage OS clipboard interactions. This includes the IClipboard and IClipboardProcessRunner interfaces, a base implementation (ClipboardBase), and helper classes (ClipboardProcessRunner, ClipboardProcessRunnerImpl) that handle shell commands for Unix-based systems. The existing static Clipboard class is marked as obsolete, signaling a shift toward a more structured, interface-driven approach to clipboard support across different operating systems.

Terminal.Gui/App/Clipboard · high confidence

The Terminal.Gui.Input.Keyboard namespace now includes a comprehensive set of new classes and enums to handle keyboard input, including Key, KeyBinding, KeyBindings, PlatformKeyBinding, and ModifierKey. This introduces a modernized, platform-aware key binding system that supports distinct key combinations for Windows, Linux, and macOS, as well as richer event types like press, repeat, and release. Users will benefit from more accurate keyboard handling, better support for modifier keys (including AltGr and Super keys), and a more robust API for defining and managing key bindings across different operating systems.

Terminal.Gui/Input/Keyboard · high confidence

The Terminal.Gui library now includes a comprehensive, new mouse input system. This introduces a \Mouse\ event argument class that abstracts common mouse operations, including detection of clicks, double/triple clicks, and wheel events. A new \MouseBinding\ and \MouseBindings\ collection allows developers to bind specific \MouseFlags\ to commands. Additionally, \PlatformMouseBinding\ enables defining mouse flags that vary by operating system (Windows, Linux, macOS), and \GrabMouseEventArgs\ provides a cancellable pattern for managing exclusive mouse grabs, allowing views to prevent grab theft or premature release during drag operations.

Terminal.Gui/Input/Mouse · high confidence

Adds the \LineCanvas\ class and supporting types (\StraightLine\, \LineStyle\, \IntersectionType\, etc.) to the \Terminal.Gui.Drawing\ namespace. This new system automatically resolves intersections between horizontal and vertical lines, producing correct Unicode junction glyphs (T-junctions, crosses, corners) without manual calculation. It supports merging multiple canvases for seamless border composition across view boundaries, and provides mechanisms to exclude or reserve cells to handle overlapping content like titles or gaps in borders.

Terminal.Gui/Drawing/LineCanvas · high confidence

The UICatalog application has been modernized to use the new instance-based application model (replacing the legacy singleton \Application.Top\ with \Application.Create()\ and \IApplication\), and numerous scenarios have been updated or added to demonstrate new features. This includes a comprehensive \AllViewsTester\ for inspecting all \View\-derived classes, new scenarios for \Adornments\, \Arrangement\, \Bars\, \BracketedPaste\, \Buttons\, \ChineseUI\, \ClassExplorer\, and \AnsiRequests\. The changes also include updates to existing scenarios like \Transparent\ and \Mandelbrot\ to align with the new architecture.

Examples/UICatalog/Scenarios · high confidence

A new ANSI handling subsystem has been introduced to the Terminal.Gui drivers, providing dedicated classes for parsing and encoding ANSI escape sequences. This includes \AnsiKeyboardParser\ and \AnsiKeyboardEncoder\ for converting between \Key\ objects and ANSI keyboard sequences, \AnsiMouseParser\ and \AnsiMouseEncoder\ for mouse events, and \AnsiResponseParser\ classes to manage terminal responses and expectations. The system also introduces \AnsiRequestScheduler\ to manage asynchronous terminal requests and \AnsiEscapeSequence\ models to represent these sequences.

Terminal.Gui/Drivers/AnsiHandling · high confidence

The Terminal.Gui library introduces a new GraphView component that enables users to display bar charts, scatter plots, and other graphical data visualizations in the terminal. This addition includes a comprehensive set of classes for rendering axes (HorizontalAxis, VerticalAxis), data series (BarSeries, ScatterSeries, MultiBarSeries), and annotations (Legends, Text, Paths). Users can now configure axis labels, tick marks, and custom rendering of graph elements, providing a foundation for data visualization within the library.

Terminal.Gui/Views/GraphView · high confidence

Added a new family of linear range views to Terminal.Gui, including LinearRange, LinearSelector, and LinearMultiSelector (plus their generic and non-generic variants). These controls present a list of typed options in a linear layout, supporting single selection, multi-selection, and contiguous range selection modes. The implementation includes supporting types such as LinearRangeSpan, LinearRangeOption, and associated event args, providing a new way to build linear selection interfaces.

Terminal.Gui/Views/LinearRange · high confidence

A new read-only Markdown view has been added to Terminal.Gui, enabling the display of styled Markdown content including headings, lists, code blocks, and tables. The view supports interactive hyperlinks, text selection, and clipboard operations (copying text or links). It also provides a headless rendering API (RenderToAnsi) for generating ANSI escape sequences for terminal output.

Terminal.Gui/Views/Markdown · high confidence

Introduced a new \Popovers\ system in \Terminal.Gui.App\ to manage transient UI elements like menus, tooltips, and dialogs. This includes the \IPopover\ and \IPopoverView\ interfaces, a \PopoverImpl\ base class, and generic \Popover\<TView, TResult\>\ and \ToolTipHost\<TView\>\ implementations. Users can now register and show popovers that automatically handle lifecycle, focus, and keyboard events, while \ToolTipProvider\ enables flexible tooltip content generation.

Terminal.Gui/App/Popovers · high confidence

Added a suite of PowerShell modules and scripts to the Scripts directory to streamline development workflows. This includes a core environment setup module (Terminal.Gui.PowerShell.Core) for managing Visual Studio sessions and environment variables, a Git helper module (Terminal.Gui.PowerShell.Git) for branch management, and a build helper module (Terminal.Gui.PowerShell.Build). Additionally, new automation scripts were introduced: a code cleanup agent (CleanupAgent.ps1) for automated code formatting and inspection, a coverage runner (Run-LocalCoverage.ps1) for executing and merging test coverage reports, and utility scripts for finding duplicate test methods, linting AI agent documentation, and managing NuGet package listings.

Scripts · high confidence

The library introduces a new, modular scrolling system for terminal UIs. The \ScrollBar\ view now acts as a container for \ScrollButton\ (arrow buttons) and a \ScrollSlider\ (draggable thumb), allowing developers to enable vertical or horizontal scrolling with fine-grained control over visibility modes (Manual, Auto, Always, None). This replaces the previous monolithic scrollbar implementation, providing a more flexible and customizable scrolling experience.

Terminal.Gui/Views/ScrollBar · high confidence

A new SpinnerView control has been introduced to display animated glyphs for progress or activity indication. The component supports multiple built-in animation sequences (such as Dots, Dots2, etc.) and allows users to configure properties like SpinDelay, SpinBounce, and SpinReverse. It also supports custom sequences and integrates with the terminal's progress indicator via the SyncWithTerminal property.

Terminal.Gui/Views/SpinnerView · high confidence

Added new helper classes in the Terminal.Gui/Drivers/UnixHelpers directory: SuspendHelper for managing process suspension signals across different Unix-like platforms, UnixClipboard implementing clipboard support via xclip for Linux, native Objective-C calls for macOS, and PowerShell for WSL, UnixIOHelper centralizing low-level I/O syscalls like poll, read, write, and ioctl, and UnixRawModeHelper for safely enabling and restoring terminal raw mode with crash-safe restoration hooks.

Terminal.Gui/Drivers/UnixHelpers · high confidence

Added the \Wizard\ and \WizardStep\ classes in \Terminal.Gui/Views/Wizard\ to support multi-step dialog workflows. The \Wizard\ manages navigation between steps, while each \WizardStep\ can host arbitrary views and display markdown-formatted help text in the right padding.

Terminal.Gui/Views/Wizard · high confidence

Added the \Bar\ container for horizontal or vertical arrangements of \Shortcut\ items, serving as the base for menus and status bars. Introduced the \Code\ view for syntax-highlighted source code display with language hints and custom highlighters. Added \DatePicker\ for calendar-based date selection. Modernized \Button\ with configurable shadow styles, hotkey support, and mouse binding improvements. Updated \CheckBox\ to use \CheckState\ enum for three-state support and improved mouse/keyboard interaction. These changes provide richer UI components and a more consistent API across the library.

Terminal.Gui/Views · high confidence

The Terminal.Gui library introduces a suite of new UI components for color and attribute selection. The \ColorPicker\ allows users to select colors using RGB, HSV, or HSL models via interactive sliders (\ColorBar\ and its derivatives like \RBar\, \GBar\, \BBar\, \HueBar\, etc.), with optional text fields and color name resolution. A \ColorPicker16\ component provides a grid of 16 standard ANSI colors. Additionally, \AttributePicker\ enables users to select foreground/background colors and text styles, while \ColorModelStrategy\ handles the mapping between color models and their respective bar components. These controls implement \IValue\<T\>\ for two-way data binding and support keyboard and mouse interactions for value adjustment.

Terminal.Gui/Views/Color · high confidence

The \Terminal.Gui/ViewBase/Layout\ directory introduces a comprehensive, declarative layout system for responsive UI sizing and positioning. This includes new types for dimensions (\Dim\, \DimAuto\, \DimFill\, \DimFunc\, \DimPercent\, \DimView\, \DimCombine\) and positions (\Pos\), enabling views to automatically size themselves based on content, sibling views, or percentages of the super view. The system supports advanced alignment modes (\Alignment\, \AlignmentModes\) and helper utilities (\StackExtensions\, \Aligner\) to manage view arrangement and stacking. This change provides the foundational API for building responsive terminal user interfaces where components dynamically adjust their size and position based on available space and content.

Terminal.Gui/ViewBase/Layout · high confidence

The ViewBase area introduces new types to support the Cancellable Work Pattern (CWP) and transparency tracking. DrawContext is a new class that tracks drawn regions in screen-relative coordinates, enabling proper transparency support for views with ViewportSettingsFlags.Transparent. DrawEventArgs and DrawAdornmentsEventArgs are new event argument classes that carry the DrawContext and allow cancellation of adornment drawing. Additionally, IValue and IValue\<TValue\> interfaces are introduced to provide a generic way for views to expose their values for command propagation, with a default implementation supporting string, IParsable types, enums, and nullable wrappers. Orientation and navigation event args (AdvanceFocusEventArgs, HasFocusEventArgs) and helper classes (OrientationHelper, IValueParser) are also added to support the new architecture.

Terminal.Gui/ViewBase · high confidence

The Terminal.Gui library introduces a new keyboard input handling architecture in the \Terminal.Gui.Drivers\ namespace, featuring a \Key\ class for high-level key representation and a \KeyCode\ enumeration for consistent key encoding. This change adds a \ConsoleKeyInfo\ extension for debugging, a \ConsoleKeyMapping\ class to bridge \KeyCode\ and \ConsoleKeyInfo\, and an \IKeyConverter\ interface to standardize the conversion between native console input and the shared \Key\ class. These components provide a unified way for application code to specify keys and receive key events, decoupling driver-specific input processing from the core library.

Terminal.Gui/Drivers/Keyboard · high confidence

A new \TextValidateField\ base class and provider interface (\ITextValidateProvider\) enable masked, regex, and culture-aware date/time editing. \DateEditor\ and \TimeEditor\ provide specialized input controls for dates and times, supporting culture-specific formatting and automatic cursor navigation. The \HistoryText\ class and \TextModel\ are introduced to support undo/redo functionality for text changes.

Terminal.Gui/Views/TextInput · high confidence

The Terminal.Gui/Text directory now contains a new set of core text processing classes: NerdFonts (enabling Unicode icon support for file extensions), RuneExtensions (providing width calculation, encoding, and combining mark detection), StringExtensions (handling grapheme clusters, column width, and control character sanitization), TextDirection (defining horizontal and vertical text orientations), and TextFormatter (managing alignment, hotkeys, and drawing). This refactors and replaces the previous text handling, introducing support for vertical text, improved Unicode/grapheme handling, and optimized memory usage via ArrayPool.

Terminal.Gui/Text · high confidence

A new tracing infrastructure has been introduced in the App/Tracing directory, providing a unified way to capture and inspect internal events for debugging and testing. The system supports multiple trace categories (Lifecycle, Command, Mouse, Keyboard, Navigation, Configuration, Draw) that can be independently enabled or disabled. It features a pluggable backend interface (ITraceBackend) with built-in implementations for logging (LoggingBackend), testing (ListBackend), and no-op (NullBackend). The Trace class uses AsyncLocal storage to ensure thread-safe, per-async-context configuration, allowing developers to enable specific trace categories and backends for targeted debugging or test assertions.

Terminal.Gui/App/Tracing · high confidence

The Adornment system (Margin, Border, Padding) has been refactored to use a lightweight settings object (implementing IAdornment) that lazily creates a full View-backed rendering layer (AdornmentView) only when needed. This separation allows the core settings to remain lightweight while enabling complex features like mouse-driven move/resize arrangement via the new Arranger and ArrangerButton components. The Border specifically gains support for tab-style headers, terminal title updates, and gradient fills, while the new ITitleView interface allows for customizable tab headers.

Terminal.Gui/ViewBase/Adornment · high confidence

The color handling in Terminal.Gui has been refactored to introduce new types and improve parsing. A new \AnsiColorCode\ enum maps legacy 16-color names to their corresponding ANSI escape sequences. The \ColorName16\ enum now explicitly defines the 16 legacy color names and their values. A \ColorParseException\ has been added to provide detailed context when color parsing fails. The \Color\ struct now supports custom formatting via the \ICustomColorFormatter\ interface, allowing for flexible string representation of colors. Additionally, a \ColorQuantizer\ class has been introduced to handle color palette generation for image rendering, and a \StandardColor\ enum provides a comprehensive list of W3C+ standard color names with their RGB values.

Terminal.Gui/Drawing/Color · high confidence

Mouse event handling and state management have been extracted from the static App class into a new ApplicationMouse class that implements the IMouse interface. This change decouples mouse logic from the global App singleton, enabling better testability and parallel test execution. The new implementation includes an interface (IMouse) and a handler interface (IMouseGrabHandler) to manage mouse grabbing, event raising, and state, allowing for more flexible and testable mouse interactions within the application.

Terminal.Gui/App/Mouse · high confidence

The legacy \Menu\ and \ContextMenu\ implementations have been removed and replaced with a modernized menu system. Users will now interact with \MenuBar\ and \Menu\ components that support cascading sub-menus, command-based activation, and popover-based drop-downs. This change introduces new classes such as \IMenuBarEntry\, \Menu\, \MenuBar\, \MenuBarItem\, \MenuItem\, and \PopoverMenu\, which provide improved keyboard navigation, command routing, and visual styling. The new system integrates with the \Command\ system for better accessibility and consistency across the framework.

Terminal.Gui/Views/Menu · high confidence

The TableView control now supports advanced customization and data binding. Users can define column-specific rendering via the new ColumnStyle class, which allows configuring alignment, formatting, and custom color getters for cells and headers. A new ITableSource interface and its implementations (DataTableSource, EnumerableTableSource, ListTableSource) provide flexible ways to bind tabular data, including support for generic object collections. Additionally, the TableSelection class introduces a robust multi-region selection model, and the CheckBoxTableSourceWrapper enables adding interactive checkboxes to table rows.

Terminal.Gui/Views/TableView · high confidence

The UICatalog example application now supports running individual or all scenarios in a headless benchmark mode, collecting performance metrics such as iteration counts, draw operations, and screen refreshes. Scenarios are now defined using a structured \Scenario\ base class with \\[ScenarioMetadata\]\ and \\[ScenarioCategory\]\ attributes, making it easier to add and categorize demo code. Additionally, an in-memory log capture system has been added to isolate and display logs for each scenario, and a \Logo\ view renders the Terminal.Gui art with a diagonal color gradient.

Examples/UICatalog · high confidence

The \ApplicationKeyboard\ class and \IKeyboard\ interface have been introduced to manage keyboard input and key bindings at the application level. This change decouples keyboard handling state from the static \App\ class, enabling parallelizable unit tests and better testability. The new implementation provides thread-safe methods for raising key down and key up events, and invoking commands bound to keys, while maintaining compatibility with existing key binding configurations.

Terminal.Gui/App/Keyboard · high confidence

The Terminal.Gui/Drivers directory now contains a modernized driver architecture, introducing new types such as ComponentFactoryImpl, Cursor, Driver, DriverImpl, DriverRegistry, IComponentFactory, IDriver, ISizeMonitor, PlatformDetection, SizeDetectionMode, and TerminalDevice. These files establish a unified driver registry, abstracted component factory pattern, and centralized terminal device detection that resolves input/output via /dev/tty or CONIN$/CONOUT$ when standard streams are redirected. The changes also add support for configurable size detection modes (ANSI query vs. polling) and platform-specific detection for Windows, Linux, and macOS, enabling the framework to better handle terminal attachment and size changes across different environments.

Terminal.Gui/Drivers · high confidence

The application's main loop and its coordination have been refactored into new classes (ApplicationMainLoop, MainLoopCoordinator, MainLoopSyncContext) that manage the UI rendering, event processing, and input threading. This change replaces the legacy MainLoop infrastructure, providing a more decoupled and parallel-friendly structure for handling console input, ANSI startup gates, and UI iteration.

Terminal.Gui/App/MainLoop · high confidence

The \TextField\ control has been refactored from a single large file into multiple partial classes organized by responsibility: commands and key bindings (\TextField.Commands.cs\), drawing and rendering (\TextField.Drawing.cs\), history/undo-redo (\TextField.History.cs\), keyboard input (\TextField.Keyboard.cs\), mouse interaction (\TextField.Mouse.cs\), text selection logic (\TextField.Selection.cs\), and text manipulation (\TextField.Text.cs\). This modularization improves code maintainability and makes it easier to extend or override specific behaviors like autocomplete, selection, and key bindings.

Terminal.Gui/Views/TextInput/TextField · high confidence

The Windows driver has been refactored into distinct, modular components: a new WindowsClipboard implementation for clipboard operations, a CursorVisibility enum for fine-grained control over the cursor's appearance and size, and dedicated classes for input handling (WindowsInput, WindowsInputProcessor, WindowsKeyConverter) and output rendering (WindowsOutput). These changes improve input processing, support for Unicode and dead keys, and cursor management on Windows terminals.

Terminal.Gui/Drivers/WindowsDriver · high confidence

The input handling in Terminal.Gui has been refactored to use a new, cleaner architecture for reading and processing console input. A new \ConsoleInputSource\ abstract base class and \IInputSource\ interface define how input is read from the console, while \IInput\ and \InputImpl\ manage the background read loop. An \IInputProcessor\ interface and \InputProcessorImpl\ base class handle the translation of raw input into Terminal.Gui events (key down/up, mouse, paste) on the main loop thread. This change introduces a more robust and testable input pipeline, supporting features like bracketed paste and improved testability through the new \ITestableInput\ interface.

Terminal.Gui/Drivers/Input · high confidence

The output subsystem has been refactored to use new IOutput and IOutputBuffer interfaces, separating the low-level console output (IOutput) from the high-level screen state buffer (IOutputBuffer). This change introduces a more robust mechanism for managing raster images (Sixel and Kitty graphics protocols) and hyperlink (OSC 8) rendering. The new architecture allows for better handling of terminal-specific features, including support for Kitty graphics protocol alongside Sixel, improved management of stale hyperlink states, and more efficient dirty-state updates for terminal drivers.

Terminal.Gui/Drivers/Output · high confidence

The \TextView\ implementation has been split into multiple partial classes (e.g., \TextView.Commands.cs\, \TextView.Drawing.cs\, \TextView.Keyboard.cs\) to separate concerns such as command handling, rendering, keyboard input, and text management. This structural change organizes the \TextView\ codebase, making it easier to navigate and maintain without altering the user-facing API or behavior.

Terminal.Gui/Views/TextInput/TextView · high confidence

The palette building process in Terminal.Gui has been refactored to use a new, more conservative threshold for merging similar colors. This change, implemented via the new \PopularityPaletteWithThreshold\ class and \EuclideanColorDistance\ metric, ensures that underrepresented colors are less likely to be missed during palette reduction. Users will see more accurate color representation in UI themes and images processed by the framework.

Terminal.Gui/Drawing/Quant · medium confidence

The configuration system has been refactored to use Microsoft.Extensions.Configuration (MEC) as the primary backend, replacing the legacy static ConfigurationManager. This introduces a new TuiConfigurationBuilder that loads settings from library defaults, app defaults, user files, environment variables, and runtime JSON. Each UI component (such as Button, Dialog, Window, and Glyphs) now has a corresponding Settings POCO (e.g., ButtonSettings, DialogSettings) that holds default values. These are bound to static 'Defaults' properties via the new MEC binding. Additionally, theme management is now handled by the IThemeManager and ISchemeManager interfaces, with MecThemeManager and MecSchemeManager providing the implementations. A static ThemeChanges facade bridges the new system to legacy event subscribers, ensuring that views can still react to theme changes.

Terminal.Gui/Configuration/Settings · high confidence

The ListView component has been refactored to use a new IListDataSource interface, which provides a cleaner contract for data and rendering. This enables the addition of a new generic ListView\<T\> variant that exposes a strongly-typed Value property for the selected item, alongside existing index-based selection. The refactoring also introduces explicit support for multi-selection and marking (checkbox/radio button styles) via the MarkMultiple and ShowMarks properties, and updates the default key and mouse bindings to support these new interaction patterns.

Terminal.Gui/Views/ListView · high confidence

The modern template now includes a new layout master template that defines the HTML structure for documentation pages, including the header, navigation, and footer. Additionally, new partial templates have been added to render class headers, member pages, and individual class members, providing a more structured and consistent presentation of API documentation. These changes enhance the visual layout and information hierarchy for users viewing generated documentation.

_docfx/\_exported\templates · high confidence

The Terminal.Gui library now uses GitVersion for automated semantic versioning, replacing the previous MinVer-based approach. A new Directory.Build.props file configures the build environment, while ModuleInitializers.cs ensures the ConfigurationManager is initialized early in the application lifecycle. Additionally, JetBrains Rider settings are standardized via a new DotSettings file to enforce consistent code analysis rules.

Terminal.Gui · high confidence

The Terminal.Gui configuration subsystem was refactored to improve reliability and support Ahead-Of-Time (AOT) compilation. New JSON converters were added for core types including Color, Attribute, Key, and various collections, ensuring robust serialization and deserialization of configuration data. The ConfigurationManager and its associated classes (ConfigProperty, SettingsScope, etc.) were updated to be trim-safe and compatible with NativeAOT, resolving initialization crashes and reflection-based type scanning issues. Additionally, the codebase introduced explicit handling for configuration locations and deep-cloning of configuration objects to prevent mutation corruption.

Terminal.Gui/Configuration · medium confidence

A new nuget.config file was added to the EditorRef directory to configure NuGet package sources. This change clears existing package source mappings and explicitly points to the public NuGet.org feed, allowing the EditorRef project to resolve the Terminal.Gui.Editor package and its transitive dependencies from the public feed rather than being restricted to locally-built packages in the repository root.

docfx/EditorRef · medium confidence

Added new helper classes (NetWinVTConsole, WindowsConsoleHelper, WindowsVTInputHelper, WindowsVTOutputHelper) to manage Windows console modes for Virtual Terminal Sequences (VTS). This enables proper support for ANSI escape codes, non-ASCII characters, and mouse input on Windows, while ensuring console modes are correctly restored on shutdown.

Terminal.Gui/Drivers/WindowsHelpers · high confidence

The mouse driver now uses a new \MouseInterpreter\ and \MouseButtonClickTracker\ to process mouse events. This change implements an 'immediate emission' approach for click detection, meaning single clicks are emitted instantly rather than being deferred to detect double-clicks. This eliminates the previous 500ms delay for single clicks, providing instant user feedback while still correctly detecting double and triple clicks based on timing and position thresholds.

Terminal.Gui/Drivers/Mouse · high confidence

2 commits adding/updating tests in Tests/IntegrationTests/FluentTests/\_\snapshots\\_; Added AppTestHelper test infrastructure for integration testing; Added benchmark for Button draw performance; Added benchmarks for ConsoleDrivers; Added benchmarks for FastHasFlags performance; Added comprehensive unit tests for View navigation and focus management; Added comprehensive unit tests for the Output driver subsystem; Added configuration and theme switching benchmarks; Added diagnostic and scrolling tests for the TabView component; Added input injection API for testing; Added integration tests for view disposal, scenario cleanup, and tab fan-out behavior; Added layout and content-size unit tests for the Dim/Pos system; Added nullability tests for the Images scenario; Added parallelizable unit test project for isolated, concurrent test execution; Added parallelizable unit tests for Views and Resources; Added parallelizable unit tests for text, string, and formatter components; Added performance benchmarks and memory profiling for layout, scrolling, and configuration subsystems; Added performance benchmarks for Terminal.Gui text processing; Added performance smoke tests for ListView and TableView rendering; Added scrolling performance benchmarks for core views; Added stress tests for Application.Invoke and scenario benchmarks; Added test assets for ConfigPropertyTypeLoad scenarios; Added test infrastructure for legacy and non-parallelizable unit tests; Added tests for configuration loading and assembly scanning; Added unit tests for ANSI driver components; Added unit tests for ANSI, .NET, and Windows drivers; Added unit tests for Adornment view behavior and layout; Added unit tests for Application lifecycle, keyboard thread safety, and key binding setters; Added unit tests for Application lifecycle, navigation, and inline mode behavior; Added unit tests for Kitty graphics protocol support; Added unit tests for LineCanvas and StraightLine components; Added unit tests for LinearRange view components; Added unit tests for Region geometric operations; Added unit tests for ResultEventArgs; Added unit tests for Sixel image encoding and support detection; Added unit tests for SpectreView interop; Added unit tests for View keyboard and hotkey behavior; Added unit tests for Windows input processing and key conversion; Added unit tests for application keyboard and key binding behavior; Added unit tests for application timeout and timed event behavior; Added unit tests for configuration system serialization and parallel execution; Added unit tests for drawing components; Added unit tests for enum extension methods; Added unit tests for input handling, including Command enum stability and input injection; Added unit tests for keyboard input handling and key binding serialization; Added unit tests for mouse click detection and interpretation; Added unit tests for mouse event handling and coordinate offset adjustments; Added unit tests for mouse input binding and injection; Added unit tests for mouse interaction and event routing; Added unit tests for the ANSI driver and related components; Added unit tests for the Color class and related color resolution utilities; Added unit tests for the Terminal.Gui driver subsystem; Added unit tests for the new IRunnable interface and Runnable base class; Added unit tests for the new Popover and ToolTip host components; Added unit tests for view arrangement, command bubbling, and focus rendering; Added unit tests for view drawing, clipping, and redraw logic; Added unit tests for viewport scrollbar positioning and transparent mouse handling; Added xUnit assertion generator and context extension; Centralize test environment setup and add Native AOT smoke test; Expanded integration test coverage for UI components.

The project has been migrated to a modern .NET SDK-style build system, replacing the legacy .csproj format with a centralized \Directory.Packages.props\ file that defines all package versions in one place. This change introduces a new \Terminal.Gui.Interop.Spectre\ interop library, updates the test suite to use xUnit v3 and parallelizable test projects, and adds new tooling projects for documentation and code analysis. Key dependencies like \Spectre.Console\, \Serilog\, and \Microsoft.Extensions.\*\ are now managed centrally, ensuring consistent versions across all projects including the main library, examples, and tests.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 58.

• Code Health 49
• Architecture 96
• Maturity 68
• Readiness 70
• Security 65
• Performance 62

• 300 commits — 219 feature/other, 81 fixes

• (repo) — 115 commits
• (root) — 36 commits
• Terminal.Gui/Views — 32 commits
• Tests/UnitTestsParallelizable — 26 commits
• Terminal.Gui/ViewBase — 20 commits
• Examples/UICatalog — 18 commits
• Terminal.Gui/Drivers — 14 commits
• .github/workflows — 10 commits
• Terminal.Gui/App — 4 commits
• docfx/images — 4 commits
• docfx/docs — 3 commits
• Terminal.Gui/Drawing — 2 commits
• Tests/IntegrationTests — 2 commits
• .claude/cookbook — 1 commit
• .claude/rules — 1 commit
• .claude/tasks — 1 commit
• Scripts/DocSnippetValidator — 1 commit
• Terminal.Gui/Configuration — 1 commit
• Terminal.Gui/Input — 1 commit
• Terminal.Gui/README.md — 1 commit

• fix: #4522: Address Codex review findings — fix three test quality issues
• fix: #4522: Fix render fingerprint review follow-up
• fix: Add dialog run/stop custom style regression test
• fix: Add failing tests proving two bugs in wizard navigation
• fix: Add fire progress style and fix Mandelbrot layout
• fix: Address CR feedback: perf, safety, correctness fixes
• fix: Address Codex review: predict full Frame, exact dim guard, broaden to fixed/one-axis
• fix: Address review: clarify cascade adornment-offset comment, fix plan doc
• fix: Address review: drop scroll subtraction in subview cascade, fix bad tests
• fix: Adds doc snippet compile validation; fixes v1 API rot in agent docs (#5480)
• fix: Audit and fix inaccuracies in AI guidance files (#5424)
• fix: Fix #5513: flash-free Kitty pan/zoom via placement crops (#5514)
• fix: Fix #5518: set attribute before drawing Padding adornment thickness
• fix: Fix #5543: release raster graphics when their view stops being rendered
• fix: Fix #5561: make TuiConfigurationBuilder flat-key binding trim/AOT-safe
• fix: Fix Kitty corruption when an image is split into multiple clip fragments
• fix: Fix Kitty graphics cursor scroll and stale-placement on resize/removal
• fix: Fix Kitty resize border artifacts and Fire progress on Kitty-only terminals
• fix: Fix Tab order and reformat-on-keystroke in NumericUpDown editable mode
• fix: Fix TextViewTests: rename missed short URL truncations gui- → tui-
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

tui-cs/Terminal.Gui was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.