Changelog

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 ParagraphOptions, ParagraphBackgroundMode, ParagraphOnError, TabOverflowBehavior, and TextOptions to configure alignment, indentation, wrap markers, word splitting, tab handling, ellipsis behavior, background fill, and fallback behavior in one reusable model.

• Added Terminal::printParagraph() so applications can print structured, width-aware paragraphs directly to the terminal without first building a full-screen buffer.

• Added RemappedBuffer and Orientation for efficient row and column insertion, deletion, movement, shifting, and rotation in editors, log viewers, scrollback panes, and other large grid-based views.

• Expanded Text, String, and Char with paragraph-aware rendering options and new helpers such as String::terminalLines(), String::containsControlCharacters(), and Char::isControl().

• Added Terminal::isInteractive(), a new command-line-help demo, and a much broader documentation set for paragraph layout, backends, and Unicode width handling.

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 Bitmap::expanded(), Bitmap::pixelCardinal(), Position::ringEight(), Position::ringEightDeltas(), and Direction::fromDelta() to make neighborhood analysis, contour detection, and grid navigation easier to express with the public API.

• Added Size::clamp() and Rectangle::clamp() so positions can be forced into valid drawable bounds without repeating manual min/max code throughout applications and demos.

• Added hash() methods and std::hash specializations for Foreground, Background, Color, Char, Direction, Position, Rectangle, and Key, which makes these value types directly usable in std::unordered_map and std::unordered_set.

• Added TerminalFlag and TerminalFlags so applications can control built-in terminal signal handling explicitly, including an opt-out for environments that already manage process shutdown and terminal restoration.

• Improved color parsing and color inheritance: color names now accept spaces, underscores, and hyphens, and inherited color components in String::append() and Terminal::write() now resolve against the currently active color as users expect.

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

• Added ReadableBuffer::countDifferencesTo() and ReadableBuffer::toMask() to compare rendered frames and derive bitmap masks from visible buffer content.

• Added WritableBuffer::setFrom(), WritableBuffer::setAndResizeFrom(), shared drawing helpers, and Buffer::clone() so frame-generation code can work against abstract writable targets and keep copies of previous frames.

• Added a default Buffer() constructor, validating Buffer(Size, Char) construction, Buffer::resize(Size, bool, Char), and Buffer::fromLinesInString()/Buffer::fromLines() for more flexible buffer lifecycle management.

• Added Backend as a public extension point for custom platform output and input handling, and changed Input into a public interface that backends can implement.

• Added Terminal::OutputMode with FullControl and Text modes, plus Terminal::setBackend(), setAlternateScreen(), moveTo(), moveHome(), moveCursor(), moveRight(), moveUp(), moveDown(), setAutoWrap(), and setCursorVisible().

• Added Bitmap::rect(), pixelRing(), boundingRect(), pixelCount(), invert()/inverted(), outlined(), fillRect(), floodFill(), fromFunction(), and toPattern().

• Added Text::setParagraphSpacing() and String::wrapIntoLines(..., ParagraphSpacing), plus String::count(), indexOf(), substr(), splitLines(), and String::fromLines() helpers.

• Added more geometry and character helpers, including Rectangle overlap/containment/intersection tools, Rectangle::frameDirection(), Rectangle::bounds(), and new Char convenience checks such as isEmpty() and isOneOf().

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.