Changelog

Version 1.10.2 - 2026-05-04

Version 1.10.2 is a focused follow-up to the 1.10 beta UI overhaul. It keeps the new theme and action model, but polishes the practical details that matter when building real terminal interfaces: predictable themed margins and padding, reusable one-line text surfaces, safer geometry arithmetic, and a richer String / StringView API for terminal text manipulation.

The beta UI API changed again in this release. The old one-line AbstractLine and TextLine surfaces were replaced by composition-based line surfaces centered around ui::DynamicTextLine and ui::DynamicText. Existing demos were updated to the new API.

Highlights

  • Reworked beta one-line UI surfaces around ui::DynamicTextLine, ui::StaticText, and ui::Label, replacing the previous subclassing-oriented AbstractLine / TextLine design with composed, theme-aware surfaces.

  • Added theme layout helpers such as theme::StringWithMargins, themed layout rectangles, and padding/margin helpers in ThemeAccessor, making built-in controls handle themed spacing consistently.

  • Expanded String and StringView with display-width cropping, character-set searches, default trimming, normalization, range replacement/removal, efficient base-style application, and shared range algorithms.

  • Improved geometry helpers with a richer Alignment value type, saturated Size arithmetic, clearer expandTo / limitTo style APIs, and margin helpers for layout axes and margin collapsing.

  • Updated the UI demos, reference documentation, and unit tests to cover the revised layout, theme, string, and surface behavior.

Added

  • Added ui::StaticText for fixed one-line text, ui::Label as its label-themed specialization, and ui::DynamicTextLine as the new composed left/middle/right line surface for headers and compact status rows.

  • Added ui::ExclusiveSurfaceManager for surfaces that own a fixed internal child set while still using the regular surface-container machinery.

  • Added ui::HelpFormat and moved ui::HelpVisibility to its own public header. HelpData can now record whether detailed help descriptions are plain text or HTML.

  • Added theme::StringWithMargins, themed layout-rectangle helpers, and theme::layout functions for styling text with padding, cropping, bracket decoration, and collapsed horizontal margins.

  • Added String::croppedToDisplayWidth(), String::indexNotOf(), String::normalized(), String::replace(), String::remove(), String::set(), and String::withBase() for common terminal-text editing tasks.

  • Added matching StringView helpers for display-width cropping, character-set searches, default trimming, and base-style materialization.

  • Added HtmlRenderer::escapeHtml() for safely embedding plain text into HTML fragments used by the rich-text renderer.

  • Added Keys::mainKeyLabels() and Char::empty() as small convenience APIs used by the refreshed UI rendering code.

Improved

  • Replaced the beta ui::AbstractLine and ui::TextLine implementation with composed surfaces. HeaderLine now builds on DynamicTextLine, while FooterLine continues to combine status text, action help, and queued messages using the newer text surfaces.

  • Made Button, ActionHelp, Frame, Buttons, Sections, and text surfaces resolve themed margins and padding consistently instead of hard-coding local spacing.

  • Clarified UI layout metrics: sizes describe the margin-free content rectangle, while margins remain parent-owned spacing. Stack and Buttons collapse adjacent child margins, pure layouts propagate outer margins, and enclosing layouts such as Frame collapse child margins with their own insets.

  • Reworked Alignment from a plain enum into a lightweight value type with named constants, horizontal/vertical component helpers, offset calculations, bitwise combination, equality, and hashing support.

  • Updated Size and Margins with clearer mutating and copy-returning helpers such as add(), subtract(), expandTo(), limitTo(), expandedWith(), and limitedWith(). The old component-style helpers remain available for compatibility.

  • Centralized terminal string range logic in an internal StringRangeView helper so String and StringView share the same behavior for iteration, display width, splitting, trimming, searching, and line metrics.

  • Improved character and bitmap safety: invalid Unicode scalar values passed to Char are normalized, Bitmap dimensions are capped at 4096 x 4096, and geometry calculations use saturated arithmetic where overflow would otherwise be surprising.

  • Refined WritableBuffer text drawing internals to work with full CharStyle values instead of only colors.

  • Updated the UI demos to the new line-surface, margin, and help-description APIs, including ui-hello-world, ui-html-viewer, ui-choice, ui-sections, and ui-world-view.

Fixed

  • Fixed several range-related edge cases in String and StringView where operations on substrings or views could accidentally ignore the visible range.

  • Fixed out-of-range unchecked string access to return an empty/discarded character instead of reading outside the visible range.

  • Fixed UI spacing inconsistencies where padding, margins, frame titles, button rows, action-help fragments, and line sections could add too much spacing or fail to collapse adjacent themed margins.

  • Fixed line and button measurement paths so theme changes that affect padding or margins are reflected in layout instead of only in paint output.

  • Fixed several overflow-prone geometry and layout calculations by introducing saturated integer helpers for internal arithmetic.

Documentation

  • Updated the UI surface reference to describe DynamicTextLine, StaticText, labels, dynamic text, action help, and footer behavior after the line-surface redesign.

  • Expanded the UI layout and theme reference pages with the new margin and padding model, including how pure layouts propagate outer margins and how enclosing layouts collapse child margins with their own inset.

  • Updated the stack-layout implementation note so it explains margin collapsing, hidden-child handling, and propagation of cross-axis margins.

  • Refreshed the reference index and the ui-hello-world demo documentation to match the renamed and newly added UI surface APIs.

Implementation

  • Added the internal SaturatingMath helpers and dedicated tests for integer casting, arithmetic, and overflow detection used by geometry and layout code.

  • Added and updated unit tests for String, StringView, Alignment, Margins, Size, themes, button rows, frames, pages, choices, scroll areas, text boxes, StaticText, and DynamicTextLine.

  • Adjusted CI and documentation workflows for the refreshed documentation and generated headers.

Version 1.10.0 - 2026-04-30

Version 1.10.0 continues the beta UI framework work with a much more complete application layer: shared actions, theme-driven painting, reusable scrollable areas, modal pages, and a broader set of layout and surface primitives. It also adds table-style grid drawing helpers, clipped writable buffers, and new demos that show the UI framework in larger, more realistic examples.

The beta UI API changed substantially in this release. Existing demo code was updated to use the new action, theme, surface-container, and layout concepts.

Highlights

  • Added the erbsland::cterm::theme subsystem with Theme, ThemeBuilder, selectors, states, tags, reusable property sheets, and built-in dark, light, and monochrome themes for UI applications.

  • Replaced the beta ui::KeyBindings API with shared ui::Action objects, ui::Actions, ui::ButtonAction, focus-chain dispatch, enablement callbacks, multi-key help data, and automatic footer keyboard help.

  • Expanded the beta UI layout and surface toolkit with ui::Viewport, ui::ScrollArea, ui::Centered, ui::Frame, ui::Sections, ui::Buttons, ui::Button, and modal ui::Choice and ui::HelpViewer pages.

  • Added FrameBorder, GridLayout, and WriteClippedBuffer so applications can draw table-like grids, combine mixed frame styles, and render safely into clipped writable regions.

  • Added the ui-world-view, grid-layout, ui-choice, and ui-sections demos and expanded the documentation with new theme, UI layout, UI surface, UI input, UI paint-system, and scrollable-area material.

Added

Improved

  • Reworked beta UI key input around action dispatch. Key presses now travel from the focused surface through its parent chain to the active page, disabled actions can let outer actions handle the same key, and actions can refresh enablement before repaint or before triggering.

  • Updated UI painting to resolve colors, blocks, margins, padding, focus state, selected state, disabled state, checked state, and custom tags through the active theme instead of hard-coded surface styling.

  • Improved scrollable UI behavior with shared scroll metrics, clamped offsets, stable automatic scroll-bar visibility, scrollIntoView() support, and visibility-aware traversal for layout, paint, dirty collection, and focus handling.

  • Reorganized the public geometry headers into a dedicated geometry source module while keeping generated top-level include wrappers available for existing users.

  • Refined the rich-text renderer internals around text::TextNodeType, parser frames, tag metadata, streaming block targets, TreeRenderer, StyleResolver, InlineTextRenderer, and render contexts, making the implementation easier to reason about and test.

  • Updated the UI demos to use the new shared UiDemoApplication helper, actions, footer help, themed surfaces, and layout primitives.

Documentation

  • Added the Themes reference chapter and expanded the UI reference pages for core concepts, input, layouts, surfaces, and the overall beta UI framework.

  • Added implementation notes for UI Paint System and UI Scrollable Areas, and refreshed the text-node renderer notes to match the new renderer structure.

  • Added or expanded demo documentation and captures for Grid Layout, UI Choice, UI Sections, UI World View, UI Hello World, and UI HTML Viewer.

  • Expanded the buffer, drawing, input, and reference-index documentation for clipped buffers, grid drawing, key modifiers, multi-key bindings, theme APIs, and the new UI components.

Implementation

  • Split and reorganized many unit tests by API area, implementation area, and UI subsystem so coverage follows the source structure more closely.

  • Added focused tests for grid layout drawing, frame-border combinations, clipped writable buffers, key modifiers, multi-key action helpers, themes, scroll bars, scroll areas, viewports, button rows, choices, help viewers, surface containers, and UI paint behavior.

  • Replaced the large generated common box-frame implementation with smaller frame-border combination data and reusable generation helpers.

  • Added generated, world-map demo data and tooling for the ui-world-view demo.

Version 1.9.0 - 2026-04-20

Version 1.9.0 introduces a more efficient shared-storage model for terminal text, making String instances significantly cheaper to reuse. It also adds reusable UI surface primitives for common patterns such as status bars and scrollable views, and expands the documentation around the beta UI framework.

In addition, this release introduces the ui-html-viewer demo, improves key-binding ergonomics, and adds focused tests for the new text and UI infrastructure.

Highlights

  • Introduced StringView and IndexRange as public APIs for efficient read-only access, cheap slicing, and range-based operations on terminal strings.

  • Added ui::ScrollingBufferView, ui::AbstractScrollBar, ui::HorizontalScrollBar, ui::VerticalScrollBar, and the beta one-line UI surfaces that are now represented by ui::AbstractLine and ui::TextLine to simplify building scrollable views, visual range indicators, and single-line headers or footers with minimal custom surface code.

  • Added the ui-html-viewer demo and extended demo documentation for html-viewer, ui-hello-world, and ui-html-viewer to demonstrate how the HTML renderer and the beta UI framework work together in realistic applications.

  • Expanded the reference documentation with dedicated chapters for UI core, input, layouts, and surfaces, and added an implementation note describing the new string-sharing design.

  • Increased unit test coverage for StringView, IndexRange, paragraph rendering, action dispatch, and the new UI surfaces.

Added

Improved

  • Updated read-only text APIs across Terminal, CursorWriter, CursorBuffer, WritableBuffer, Buffer, String, and related helpers to accept StringView where mutation is not required. This reduces copying and clarifies ownership semantics.

  • Improved the beta key input API. The old key-binding API has since been replaced by shared ui::Action objects.

  • Refined paragraph and rich-text rendering with improved token and render-block handling, keeping the HTML renderer and paragraph pipeline more modular and easier to extend.

Documentation

  • Split the UI reference into smaller, focused chapters to make the beta UI framework easier to navigate.

  • Expanded the text reference to better explain implicit sharing, string views, ranges, and UTF-8 handling.

  • Improved the reference index so new text and UI support types are easier to discover.

  • Unified the demo documentation with screen captures and more focused descriptions.

Implementation

  • Refactored terminal string storage around dedicated shared data and builder components, making String slicing and detaching behavior more explicit.

  • Expanded the unit test suite with focused coverage for string-view behavior, string building, paragraph rendering, HTML rendering, key input, scroll bars, scrolling views, and line surfaces.

  • Added the repository-local utilities/pre_commit.py helper to run standard pre-commit checks consistently.

Code Format

We updated the code formatting rules.

Where two empty lines were previously used to visually separate code sections, only a single empty line is now used.

This change was made deliberately to keep multiple code bases in sync and to simplify automated code formatting.

Version 1.8.0 - 2026-04-17

Release 1.8.0 introduces two higher-level layers on top of the existing terminal primitives: a beta ui::Application framework for event-driven terminal interfaces and a new rich-text pipeline centered around text::HtmlRenderer for rendering structured documents and HTML to terminal output. This release also makes UTF-8 recovery deterministic, adds new public support types for paragraph layout and buffer resizing, introduces new demos, and substantially expands the reference and implementation documentation.

Highlights

  • Added the beta erbsland::cterm::ui framework with Application, pages, surfaces, layouts, key input, schedulers, worker threads, and built-in surface types for structured terminal user interfaces.

  • Added rich-text and HTML rendering through text::HtmlRenderer, text::Style, and text::TextNode, making it much easier to render headings, lists, links, blockquotes, and code blocks into terminal-friendly output.

  • Added EncodingErrors, BufferResizeMode, ParagraphIndents, FastCharSet, and TerminalSession as public support APIs for safer text handling, reusable paragraph configuration, and clearer terminal lifecycle management.

  • Added the html-viewer and ui-hello-world demos and reorganized the demo infrastructure around reusable terminal-application helpers, which makes the examples easier to study and extend.

  • Expanded the documentation and unit tests significantly, including new reference chapters for rich text, the UI framework, UI events, and detailed implementation notes for scheduling, layout, paragraph rendering, and text node planning.

Added

Improved

  • String now acts as the explicit public UTF-8 boundary, and text-based Char and CombinedChar construction now recovers deterministically instead of throwing by default.

  • Malformed UTF-8 replacement is now deterministic, with each erroneous UTF-8 byte becoming one Unicode replacement character. Empty text passed to character constructors also normalizes to the replacement character.

  • Buffer resize-related APIs now use BufferResizeMode, which makes content-preservation behavior more explicit when buffers are resized.

  • Paragraph rendering internals were reorganized into dedicated layout, painter, printer, and renderer components, which simplifies reuse across direct terminal output, cursor-buffer output, and the new rich-text renderer.

  • Existing demos were modernized around shared terminal-application helpers, and update-screen-modes gained improved flush-speed tracking for comparing rendering strategies.

Documentation

  • Added new reference chapters for Rich Text and HTML, UI Framework, and UI Events and Scheduling.

  • Expanded the reference index so the new text, UI, buffer, paragraph, and terminal support types are documented and easier to discover.

  • Added detailed implementation notes for action scheduling, invocation and event threads, remapped buffers, stack layout, and rich-text rendering, and substantially expanded the paragraph-layout documentation.

  • Added Mermaid support to the Sphinx documentation build so diagrams can be embedded directly in the docs.

Implementation

  • Refactored paragraph rendering into a dedicated impl/paragraph subsystem and split the rich-text renderer into parser, tokenizer, planning, and rendering components to keep the internal architecture modular.

  • Expanded the unit test suite across API, implementation, demo, and UI layers, including focused coverage for HTML parsing and rendering, event scheduling, UI layout, text styles, and deterministic UTF-8 recovery.

Version 1.7.0 - 2026-03-27

Release 1.7.0 unifies direct terminal output and buffer-based text rendering around a shared cursor-oriented API. The biggest additions are CursorWriter and CursorBuffer, which make it much easier to reuse output code between live terminals, scrollback buffers, and rich text views. This release also introduces explicit character attributes and reusable text styles, expands buffer composition APIs, adds several new demos and reference pages, and improves key decoding and UTF-8 recovery for interactive applications.

Highlights

  • Added CursorWriter as a shared cursor-based output interface implemented by Terminal and CursorBuffer, so the same printing helpers can target both live terminals and in-memory buffers.

  • Added CursorBuffer with VT100-style wrapping, configurable overflow behavior, paragraph printing, inherited color resolution, and fill-character based screen clearing, which makes scrollback panes, log viewers, and text consoles much easier to implement.

  • Added CharAttributes and CharStyle so ANSI text attributes and color can be configured, combined, inherited, and reused consistently across direct terminal output, strings, and buffer rendering.

  • Added BufferDrawOptions plus improved WritableBuffer buffer-to-buffer drawing support for aligned placement, source cropping, and character-combination based composition.

  • Added the display-all-attributes, key-input-demo, and log-viewer demos together with substantially expanded reference and demo documentation for cursor output, text rendering, geometry, fonts, backends, and input handling.

Added

  • Added CursorWriter and CursorWriterPtr as the shared public abstraction for cursor-based text output, style changes, cursor movement, paragraph printing, and screen clearing.

  • Added CursorBuffer with CursorBuffer::OverflowMode options for shifting, wrapping, or growing scrollback-style buffers at the bottom edge.

  • Added CharAttributes for bold, dim, italic, underline, blink, reverse, hidden, and strikethrough state with explicit specified-versus-inherited semantics.

  • Added CharStyle as a reusable combined style object for color plus character attributes, including overlay/base resolution and stable hashing.

  • Added BufferDrawOptions so callers can draw buffers into other buffers with explicit target rectangles, source rectangles, color overwrite behavior, and optional CharCombinationStyle composition.

  • Added the display-all-attributes demo to show supported ANSI text attributes and style combinations.

  • Added the key-input-demo demo to visualize interactive key handling, printable text input, special keys, and live terminal resizing behavior.

  • Added the log-viewer demo to demonstrate cursor-based text generation, scrollback handling, follow mode, and BufferView based viewport rendering.

  • Added new reference chapters for backend integration, cursor output, and text rendering, plus new generated documentation helpers for drawing, drawing text, fonts, and geometry.

Improved

  • Terminal now implements CursorWriter, so direct terminal printing and in-memory cursor output share one conceptual API for colors, character attributes, cursor movement, auto-wrap, and paragraph rendering.

  • WritableBuffer now has broader buffer composition support, making it easier to place pre-rendered regions, cropped views, and combined character artwork inside larger layouts.

  • Char, String, and related text-rendering paths now integrate more cleanly with reusable styles, inherited attributes, and multi-codepoint rendering support.

  • Key decoding and console input handling are more robust, including better handling for printable single-character input, broken UTF-8 lead bytes, chunked input timing, and polling-based POSIX readiness checks.

  • The documentation now covers cursor-oriented output, ANSI character attributes, text rendering, geometry, fonts, demo applications, and backend behavior in much greater depth.

Implementation

  • Added focused unit tests for CursorBuffer, CharAttributes, CharStyle, combined character handling, key decoding, and UTF-8 resynchronization.

  • Refactored paragraph rendering and related internal helpers so terminal output and cursor-buffer output can share more behavior.

  • Improved backend internals for attribute emission, input polling, and UTF-8 recovery while keeping the public API higher-level and easier to reuse.

Version 1.6.0 - 2026-03-25

Release 1.6.0 makes text-heavy terminal applications much easier to build. The biggest user-facing addition is a new paragraph layout system that works both for direct terminal output and for text rendered into buffers. This release also adds a new remapped buffer type for row- and column-oriented editing workloads, improves terminal capability detection, and substantially expands the documentation and demos around wrapped text output.

Highlights

Added

  • Added ParagraphOptions as a reusable public configuration object for wrapped paragraph rendering in Terminal, TextOptions, and Text.

  • Added ParagraphBackgroundMode so wrapped paragraphs can optionally extend their background color into continuation indents, the remaining cells at the right edge, or both. This makes highlighted help blocks and callout text look consistent even when they wrap.

  • Added ParagraphOnError and TabOverflowBehavior to control narrow-layout fallbacks and non-advancing tab stops in a predictable way.

  • Added TextOptions so color, font, animation, and paragraph layout settings can be bundled and reused independently from the Text content object.

  • Added Terminal::printParagraph() for direct terminal output with indentation, wrap markers, tab stops, paragraph spacing, wrap limits, ellipsis markers, and layout fallback handling.

  • Added Terminal::isInteractive() so applications can detect after initialization whether a real interactive terminal is attached and switch to a plain-text output path when needed.

  • Added RemappedBuffer with efficient operations for resizing, shifting, rotating, erasing, inserting, and moving complete rows and columns while keeping the visible grid model intact.

  • Added Orientation and Coordinate as public support types used by the new buffer and geometry APIs.

  • Added String::String(std::size_t, Char), String::terminalLines(), String::containsControlCharacters(), and Char::isControl() for common text-processing and validation tasks.

  • Added the command-line-help demo application to show how paragraph-aware output can keep a classic command-line help screen readable across narrow and wide terminal widths.

Improved

  • Text now renders through a structured paragraph pipeline instead of only using the earlier simpler layout settings. The same paragraph configuration can therefore be reused for direct terminal printing and for text rendered inside rectangles.

  • Tab handling in left-aligned paragraphs is now much more practical for help text and option lists. Applications can define explicit tab stops and choose whether a non-advancing tab inserts a space or starts a wrapped continuation line.

  • Paragraph rendering now supports visible wrap markers, word-break markers, wrap limits with ellipsis, configurable paragraph spacing, and clearer fallback handling when a layout becomes too narrow to render safely.

  • The terminal backends now expose whether the process is attached to an interactive terminal, making it easier to produce a rich UI in a real terminal while keeping redirected output, logs, and CI runs readable.

  • Geometry and buffer APIs now consistently use Coordinate, and Buffer::get() returns a shared space for out-of-range reads, which simplifies caller code that inspects the edges of a buffer.

Documentation

  • Added a detailed new Paragraph Options reference chapter with rendered examples for alignment, indentation, wrap markers, background modes, word splitting, tab stops, wrap limits, and error handling.

  • Added documentation for the new command-line-help demo, showing a practical end-to-end use of Terminal::printParagraph().

  • Expanded the reference documentation for buffer, terminal, and text APIs.

  • Added implementation chapters for paragraph layout and painting, Unicode width handling, and the POSIX and Windows backends, plus a helper tool used to generate consistent paragraph-layout examples for the documentation.

Implementation

  • Refactored the text rendering internals into dedicated paragraph layout and paragraph painting components, which improves consistency between terminal output and buffer-based text rendering.

  • Refactored writable and readable buffer convenience APIs into explicit internal wrapper implementations and expanded unit test coverage for text rendering, terminal convenience methods, and RemappedBuffer.

Version 1.5.0 - 2026-03-21

Release 1.5.0 sharpens the library’s low-level building blocks for bitmap processing, geometry, and hash-based containers, while also fixing how inherited colors are resolved when strings and characters are appended or written incrementally. From the user perspective, the most noticeable additions are new helpers for expanding and probing bitmaps, new geometry clamping and neighbor APIs, and direct support for using core value types in std::unordered_map and std::unordered_set.

Highlights

Added

  • Added Bitmap::expanded() to grow a bitmap by margins or crop it with negative margins, with a configurable fill value for newly created cells.

  • Added Bitmap::pixelCardinal() as a four-neighbor bitmask helper, complementing pixelQuad() and pixelRing() for cellular automata, pathfinding, and shape-analysis code.

  • Added Position::ringEight() and Position::ringEightDeltas() for clockwise access to the eight surrounding positions, plus Direction::fromDelta() for converting arbitrary deltas into one of the canonical directions by sign.

  • Added Size::componentClamp(), Size::clamp(), Rectangle::clamp(), and Rectangle::center() for layout and cursor-position calculations that need safe in-bounds coordinates.

  • Added TerminalFlag and TerminalFlags and corresponding Terminal constructors, so applications can opt out of the built-in signal restoration logic when integrating with another framework or host environment.

  • Added hashing support through hash() methods and std::hash specializations on the most common value objects, including geometry types, colors, characters, directions, and keys.

Improved

  • String::append() now applies the currently active color to appended Char and String values when those values contain inherited foreground or background components. This makes mixed argument lists behave consistently with plain text arguments.

  • Terminal::write() now resolves inherited colors against the terminal’s tracked current color before output. Incremental writes therefore keep foreground and background inheritance consistent with previous terminal output.

  • Built-in terminal backends now restore the terminal state more robustly on POSIX and Windows when an application is interrupted, which reduces the chance of leaving the shell in an inconsistent state after Ctrl+C or similar termination events.

  • Foreground::fromString(), Background::fromString(), and Color::fromString() now accept more forgiving names such as "bright blue", "bright_blue", and "bright-blue", which simplifies configuration parsing and hand-written theme definitions.

  • TerminalFlag values can now be combined directly with the bitwise OR operator, which makes terminal construction code more concise.

Implementation

  • Expanded unit test coverage significantly across bitmap helpers, buffer conveniences, buffer views, color parsing, geometry helpers, terminal convenience APIs, update settings, and hashing behavior.

  • Reworked built-in signal handling with platform-specific dispatchers for POSIX and Windows and refreshed the terminal reference documentation for the new terminal flag API.

  • Added shared hash utilities and refreshed API documentation for the new public methods and behavior clarifications.

Version 1.4.0 - 2026-03-15

Release 1.4.0 reorganizes the rendering API around reusable buffer abstractions, adds scrollable buffer views and backend customization, and expands the text and bitmap helper APIs. From the user perspective, the most important behavior changes are the new generic ReadableBuffer/WritableBuffer pipeline, richer Terminal control, and updated screen rendering defaults for safe margins and alternate-screen updates.

Highlights

  • Added ReadableBuffer and WritableBuffer as public base interfaces, so application code can render, compare, copy, and mutate terminal content without depending on one concrete Buffer implementation.

  • Added BufferView, BufferConstRefView, and CropEdges for view-based rendering of larger logical canvases, including optional in-view crop markers for scrollable or clipped content.

  • Extended Terminal with Backend, OutputMode, MoveMode, safe-margin handling, alternate-screen control, direct cursor movement helpers, and backend injection for custom terminal integrations and tests.

  • Expanded UpdateSettings with configurable minimum-size background and message handling, explicit bottom-right crop marks, and control over automatic switching to the alternate screen buffer.

  • Added ParagraphSpacing plus new Text and String support for multi-paragraph layouts, and expanded Bitmap with higher-level analysis and editing helpers such as outlining, flood fill, and bounding boxes.

Added

Improved

  • Terminal::updateScreen() and Terminal::write() now accept any ReadableBuffer implementation instead of requiring a concrete Buffer, which makes buffer views and custom readable buffers work throughout the screen-update pipeline.

  • Terminal::size() now reports a drawable size with a one-column and one-row compatibility margin by default. This makes full-screen layouts safer on real terminals, and applications that want the full detected size can disable the margin explicitly.

  • Terminal::updateScreen() can now automatically switch to the alternate screen buffer through UpdateSettings. The default settings enable this behavior when the backend supports alternate-screen updates.

  • Minimum-size handling in Terminal::updateScreen() now supports a custom background fill and centered message instead of only a single marker character.

  • Paragraph wrapping now distinguishes between compact and double-spaced paragraphs through ParagraphSpacing, which improves structured help text and other multi-section layouts.

  • Deprecated Terminal::colorEnabled()/setColorEnabled() in favor of outputMode(), deprecated Terminal::lineBreak() in favor of writeLineBreak(), deprecated the old Buffer::drawText(std::string_view, Alignment, Rectangle, ...) overload, and deprecated the old UpdateSettings marker naming/constructor API.

Implementation

  • Expanded API documentation, demos, and unit tests across buffer rendering, terminal behavior, text layout, bitmap processing, and backend integration.

  • Refactored the rendering pipeline into focused painter, backend, string-wrapping, and line-buffer components to improve maintainability and testability.

Version 1.3.0 - 2026-03-10

Release 1.3.0 adds a more expressive frame-drawing API for animated borders and fills. The main change for library users is that frame rendering can now be configured through reusable FrameDrawOptions instances instead of piecing together several lower-level overloads.

Highlights

  • Added FrameDrawOptions and FrameColorMode for configurable frame styles, fill styles, combination behavior, and animated color effects.

  • Added a new Buffer::drawFrame(Rectangle, const FrameDrawOptions &, std::size_t) overload to render frames and optional fills from one reusable options object.

  • Added Rectangle::frameIndex() to address frame cells in clockwise order, enabling border-based animations such as chasing light effects.

Added

  • Added FrameDrawOptions with support for FrameStyle, Char16Style, and Tile9Style selection in one API.

  • Added animated frame and fill color handling with FrameColorMode::OneColor, stripe modes, diagonal modes, and clockwise/counter-clockwise chasing-border modes.

  • Added reusable frame configuration for fill blocks, combination styles, separate frame and fill color sequences, and shared animation offsets.

  • Added a templated BitmapDrawOptions color constructor so callers can pass the same color argument forms that other rendering APIs already accept.

Improved

  • Frame rendering can now animate the border independently from the fill area, which makes status boxes, dashboards, and decorative panels much easier to build with the public API.

  • Tile9Style and Char16Style frame rendering now integrate more cleanly with animated colors and base-color overlays through the unified FrameDrawOptions workflow.

Implementation

  • Added the frame-color-animations demo plus focused unit tests for the new frame color and frame-index behavior.

  • Improved internal frame-rendering helpers and related documentation.

Version 1.2.0 - 2026-03-10

Release 1.2.0 brings richer rendering primitives, better Unicode handling, smarter terminal updates, and broader examples and test coverage.

Highlights

  • Added BitmapDrawOptions and new Buffer::drawBitmap() overloads for configurable bitmap rendering with scale modes, animated color sequences, stripe-based color modes, custom block characters, and optional Char16Style integration.

  • Added Tile9Style plus matching Buffer support for repeating 3x3 and extended 16-tile patterns when filling rectangles, drawing frames, and drawing filled frames.

  • Added Rectangle::gridCells() to split layouts into evenly spaced grid cells.

  • Expanded Char and String with UTF-32 support, multi-codepoint handling, improved combining-character support, and more flexible color overlay and base-color operations.

  • Improved color composition with explicit Inherited handling across ColorPart, Color, text rendering, bitmap rendering, and buffer-based drawing.

  • Extended Terminal screen updates with clearer refresh strategies, optional line buffering, optional back-buffer diff updates, improved crop-mark handling, and better minimum-size rendering behavior.

Added

  • New display-all-colors demo for exploring the color model and layout helpers.

  • New bitmap-showcase demo for bitmap rendering options, styles, and animated color modes.

  • New update-screen-modes demo for comparing clear, overwrite, and back-buffer update behavior.

  • New unit tests for Tile9Style, terminal update behavior, bitmap rendering paths, and Rectangle::gridCells().

  • Added display-all-colors, bitmap-showcase, and update-screen-modes demo applications.

  • Added BitmapDrawOptions and configurable bitmap rendering in Buffer.

  • Added Tile9Style and tile-based fill/frame rendering support.

  • Added Rectangle::gridCells().

  • Added UTF-32 and multi-codepoint support to Char and String.

Improved

  • Updated frame-weaver, text-gallery, retro-plasma, and terminal-chronicle to use the newer rendering and color APIs.

  • Refined terminal output APIs and documentation around refresh modes, direct writes, buffer rendering, crop marks, and smart overwrites.

  • Improved bitmap, text, geometry, color, and output reference documentation.

  • Improved color overlay behavior and inherited color handling throughout the library.

  • Improved Terminal::updateScreen() with refresh-mode, back-buffer, crop-mark, and minimum-size handling updates.

Implementation

  • Improved memory efficiency.

  • Expanded unit tests and API/reference documentation across rendering, geometry, text, and terminal output.

Version 1.0.0 — 2026-03-08

First public open-source release.