Topics

• Core
  • Core Application Framework
    • Choosing an Application Design
    • Writing Small Applications with Functions
    • Building Event-Driven Applications
    • Building Procedural Applications
    • Organizing Command-Style Tools
    • Composing Applications from Services
    • Running as a Service or Foreground Daemon
    • Adding Build Version Information
    • Creating Release Packages
  • Choosing an Application Design
    • Comparing the Designs
    • Understanding Main Dispatch
    • Shared Application Startup and Error Handling
  • Writing Small Applications with Functions
    • Configuring the Complete Lifecycle
    • Capturing the Application Safely
    • Knowing When to Introduce a Class
  • Building Event-Driven Applications
    • Entering the Main Event Loop
    • Starting Asynchronous Work after Option Parsing
    • Finishing and Reporting Failures
  • Building Procedural Applications
    • Separating Setup, Options, and Work
    • Using Parsed Values
    • Overriding Application Main Dispatch
    • Cleanup and Errors
  • Building Command-Style Applications
    • Defining Commands with Option Modules
    • Preserving Callback Lifetimes
    • Leaving Main Dispatch to Application
    • Help, Errors, and Exit Codes
  • Building an Application from Parts
    • Registering the Service Graph
    • Keeping Application and Service Responsibilities Separate
    • Accessing Prepared Services
    • Combining Parts with Custom Main Behavior
  • Designing Application Parts
    • Publishing a Stable Service Interface
    • Implementing and Constructing a Part
    • Declaring Dependencies
    • Following the Part Lifecycle
    • Sharing Command-Line Configuration
    • Calling Services Across Threads
    • Handling Failures and Shutdown
  • Running Application Parts Independently
    • Manual Application-Part Lifecycle Management
    • Preparing Before Startup
    • Waiting for Part Startup and Shutdown from an External Thread
    • Starting and Stopping One Branch
    • Supplying an Existing Event Target
  • Creating Services and Foreground Daemons
    • What Makes a Service Different?
    • Preparing One Executable for Every Mode
    • Installing the Compiled Application
    • Reporting a Slow Windows Startup
    • Windows Controls and Console Events
    • Linux and macOS Signal Conventions
    • Service Startup and Shutdown Responsibilities
  • Adding Git Version Information to Your App
    • Version Tags
    • Subclass Pattern
    • Direct Application Pattern
    • CMake Setup
    • Git Reference Tracking
  • Creating Release Packages
    • What a Release Package Contains
    • Register Your First Package
    • Add Your Own Files
  • Registering Packages in CMake
    • What a Package Call Registers
    • Choose the Executables: TARGET or TARGETS
    • Choose the Package Name: NAME
    • Select a Configuration File: CONFIG
    • Choose Where ZIPs Go: OUTPUT_DIRECTORY
    • What Happens During Install
  • Configuring Release Package Contents
    • Begin with a Shared Configuration
    • Choose a Version Source
    • Archive Root Directory, Filename, and Runtime Contents
    • Add Files and Directories
    • Adapt Settings to a Platform or Package
    • Signing Credentials from Environment Placeholders
  • Signing and Notarizing Release Packages
    • Code Signing and macOS Notarization
    • Sign a Windows Release
    • Sign and Notarize a macOS App
• Memory
  • Working with Bits and Bytes
    • The Byte Type
    • Bitwise Operators, Shifts, Rotations, and Masks
    • Explicit Byte, Integer, and Character Conversions
    • From One Byte to a Block
  • Reading and Writing Bit Streams
    • When a Bit Reader Fits
    • Reading and Navigating Bit-Packed Data
    • Writing Bit-Packed Data
  • Working with Predefined Byte-Spans
    • Borrowing a Block of Bytes
    • Borrowed Byte-Span Lifetime
    • Adapting Existing Byte Storage
    • Reading and Writing Integer Fields
    • From Views to Purpose-Built Containers
  • Working with Fixed Byte Arrays
    • When a Fixed Array Fits the Problem
    • Inspecting Individual Bytes
    • Changing Selected Bytes
    • Changing Byte Ranges
    • Moving a Complete Bit String or Separate Bytes
    • Borrowing an Existing Range
    • Copying an Exact Span into an Array
    • Converting Fixed Arrays to Dynamic Byte Storage
    • Choosing Byte Blocks, Buffers, and Ring Buffers
  • Working with Byte Blocks
    • Shared ByteBlock Storage and Copy-on-Write
    • ByteBlock Ownership and Other Byte Containers
    • Creating Blocks
    • Byte Prefix, Suffix, Containment, and Search Operations
    • Reading Individual Bytes
    • Reading Native Integers
    • Converting ByteBlocks to Buffers, Vectors, and Spans
    • Editing and Assembling Small Blocks
    • Controlling Editor Storage
    • Comparing Blocks
  • Byte Integer Formats Explained
    • Fixed-Width Integers
    • Unsigned Prefix-Coded Integers
    • Signed Prefix-Coded Integers
    • Unsigned Base-128 Integers
  • Using Byte Buffers
    • Choosing a Mutable Working Buffer
    • Creating Independent Buffers
    • Controlling Length and Capacity
    • Accessing Individual Bytes
    • Reading and Writing Integers
    • Revising Byte Ranges
    • Crossing Standard-Library Boundaries
  • Using Byte Ring Buffers
    • Choosing a Queue for Byte Streams
    • Creating Fixed and Growable Rings
    • FIFO Order, Wrap-Around, and Growth
    • Understanding Size and Capacity
    • Writing and Consuming Bytes
    • Transferring Structured Integers
  • Reading and Parsing Byte Streams
    • Building a Parser Around One Cursor
    • Navigating the Input
    • Reading Bytes and Byte Blocks
    • Reading Integers
    • Decoding Text Fields
    • Choosing ByteReader or Direct ByteBlock Access
  • Writing Byte Streams
    • Building One Record Together
    • Backpatching Previously Written Fields
    • Managing Allocation and Reuse
    • Writing Bytes and Existing Blocks
    • Writing Integers
    • Encoding Text Fields
    • Choosing ByteWriter or Direct Byte Container Editing
  • Encoding Text in Binary Byte Streams
    • Why Text Needs Framing
    • Selecting Dynamic or Padded Framing
    • Selecting the Character Encoding
    • Terminating Text with an End Mark
    • Choosing the Count Representation
    • Padding Fixed-Width Fields
    • Common Schemas
  • Designing Custom Copy-on-Write Containers
    • What Copy-on-Write Means
    • Building a Regular Copy-on-Write Value
    • Keeping the Dynamic Backend Type
    • Single-Allocation Copy-on-Write Arrays
    • CowStorage and CowManualStorage Helpers
  • Marking Unsafe Memory Access in Code
    • Why an Unsafe Name Helps
    • Keep the Unsafe Region Small
• Compression
  • Compressing Data
    • Byte Compression and Supported Algorithms
    • Choosing Raw, ZIP, and Core Representations
    • Compressing Complete Values
    • Compressing Input That Arrives in Pieces
    • Decompressing Complete Values Safely
    • Decompressing Input That Arrives in Pieces
    • Choosing Compression Algorithms and Representations
  • Working with ZIP Archives
    • Inspecting an Archive
    • Safe Extraction
    • Creating an Archive
    • Directory Filtering
    • ZIP64 Policy
    • Errors and Limits
    • Reassembling Without Recompression
  • LZ4 Blocks
    • Understanding LZ4
    • Pros and Cons
    • Compression Levels
  • Deflate Streams
    • Understanding Deflate
    • Pros and Cons
    • Compression Levels
  • bzip2 Compression
    • Understanding bzip2
    • Pros and Cons
    • Compression Levels
  • LZMA Compression
    • Understanding LZMA
    • Pros and Cons
    • Compression Levels
  • Zstandard Frames
    • Understanding Zstandard
    • Pros and Cons
    • Compression Levels
• Compiled Resources
  • Compiling Resources into an Application or Library
    • Add Resources to a Target
    • Read Logical Data and Text
    • Inspect Storage and Metadata
    • Use the Resource Compiler While Cross-Compiling
• Security Topics
  • About Sensitive Strings and Byte Blocks
    • Choosing Storage for a Secret
    • Receiving Sensitive Values
    • Allocation-Level Marking
    • Building and Copying Sensitive Values
    • When Erasure Happens
    • Comparison Timing
    • Limits of the Guarantee
  • Erasing Memory in a Secure Way
    • Why and When to Erase Memory
    • Shared Byte Blocks Need Shared-Ownership Awareness
    • Fixed Arrays and Borrowed Spans
    • Uniquely Owned Dynamic Buffers
    • Sensitive Byte Ring Buffers and Consumed-Data Erasure
    • Sensitive Storage versus Explicit Memory Erasure
• Cryptology
  • Cryptology Overview
    • Authenticating with Tokens
    • Signing and Verifying Byte Blocks
    • Storing and Verifying Passwords
    • Sensitive Data
    • Using Hash Algorithms
    • Reading X.509 Certificates
    • Creating TLS Certificates and Requests
    • Configuring TLS Profiles
    • Supported Hash Algorithms
  • Configuring TLS Profiles
    • Client and Server Profiles
    • Loading an HTTPS Server Profile
    • Choosing Trust for a Private Service
    • Labels and Profile Selection
    • Presenting a Client Identity
    • Requiring Client Certificates
    • Retrieving Key Passwords from Secure Storage
    • Reloading Profiles Together
  • Creating TLS Certificates and Requests
    • Choosing a Key Profile
    • Creating a Test Certificate Hierarchy
    • Writing Certificate and Private-Key Files
    • Protecting a Private Key with a Password
    • Creating an Enterprise Signing Request
    • Validity and Reissuance
  • Authenticating with Tokens
    • Authentication Guarantees, Replay Protection, and Channel Limitations
    • Credentials and Configuration
    • Challenge-Response Protocol over JSON Lines
    • Serving One Authentication Attempt
    • Answering the Challenge
    • Token and Response Format
  • Signing and Verifying Byte Blocks
    • Create and Share the Keys
    • Sign the Bytes for One Purpose
    • Accept a Record Only After Verification
    • The Serialized Format
  • Storing and Verifying Passwords
    • Run the Demo
    • Create the Local Pepper
    • Load Pepper Material
    • Read a Password
    • Hash and Store a Password
    • Verify a Login
    • Rotate Peppers
    • Unkeyed Records
    • Exact Unicode Behavior
    • Safe Local Persistence
    • Authentication Rate Limits, Transport, and Storage Protection
    • Password-Data Erasure Guarantees and Limits
  • Supported Password Hashing Algorithms
    • Algorithm Overview
    • Argon2id
    • scrypt
    • The Pepper Layer
    • Storage Format
    • Automatic Migration
    • Unsafe Custom Costs
    • Why Other Algorithms Are Excluded
  • Using Hash Algorithms
    • Understanding Hash Algorithms
    • Hash with a Fixed Algorithm
    • Select an Algorithm Automatically
    • Store Hash Values
    • Persist the Used Algorithm
    • Defensive Hashing
  • Supported Hash Algorithms
    • Overview
    • SHA3-256
    • SHA3-384
    • SHA3-512
    • SHA-256
    • SHA-384
    • SHA-512
    • SHA-1
    • MD5
• Text Strings
  • Text Strings Overview
    • Using Strings as Everyday Values
    • Understanding String Attributes
    • Transforming Read-only Strings
    • Editing One Working Value in Place
    • Managing StringEditor Storage
    • Finding Text Positions
    • Slicing and Splitting Strings
    • Accessing Characters and Writing Parsers
    • Comparing Whole and Partial Text
    • Normalizing Unicode Strings
    • Working with Character Sets
    • Fuzzy Matching with Edit Distance
  • Using Strings
    • Read-Only String Parameters
    • Storing and Returning String Values
    • String Literals and StringLiteral
    • Shared String Copies and Slice Lifetime
  • String Attributes
    • Empty Text and Well-formed Encodings
    • Encoded Length and Code-Point Count
    • Encoding-Independent String Hashes
    • Storage Identifiers and String-Index Ownership
  • Transforming Strings
    • Common Transformations Return String Values
    • Unicode and ASCII Case Conversion
    • Cleaning Whitespace and Converting Word Boundaries
    • Custom Character Mappings
    • Replacing and Removing Text
    • Trimming the Edges of a String
    • Combining Transformations and Managing Storage
  • Editing Strings in Place
    • StringEditor Mutations and Index Validity
    • Removing and Keeping Text Ranges
    • Removing Matching Text and Character Sets
    • Insert and Replace at Known Positions
    • Truncating and Aligning Text by Code-Point Width
    • Reusing Editor Capacity with clear() and reset()
    • In-Place Unicode Normalization
  • Managing StringEditor Storage
    • Native Capacity Units and Reservation
    • Automatic Copy-on-Write Detachment
    • Explicit Copy-on-Write Detachment
    • Capacity Retention, clear(), reset(), and shrinkToFit()
    • Storage Capacity, Memory Usage, and Sharing Diagnostics
  • Finding Text Positions
    • Text Search Operations and Match Types
    • Native Search Indexes and Character Boundaries
    • Searching with Character Sets
    • Finding the Start and End of a Character Run
    • Repeated Text Searches and Overlapping Matches
    • Slicing Text between Search Results
  • Slicing and Splitting Strings
    • Slicing with Byte and Code-Point Ranges
    • Prefix, Suffix, and Middle Slices
    • Splitting Strings into Shared Slices
  • Character Access and Parsing of Strings
    • Choosing Character Iteration, Parsing, or Indexed Access
    • Byte Indexes and Code-Point Indexes
    • Parsing with StringCharReader
    • Iterating over Decoded Characters
    • Sequential Character Reading with Native Indexes
    • Indexed Character Access
    • Why UTF-32 Changes the Cost of Indexed Access
    • Character Access Methods and Their Costs
  • Comparing Whole and Partial Strings
    • Decoded String Equality and Ordering
    • Custom Character Comparison Rules
    • Prefix, Suffix, Substring, and Occurrence Tests
    • Comparing Stored Bytes
    • Validating Untrusted Text
  • Normalizing Unicode Strings
    • Canonical and Compatibility Normalization
    • Copy-Returning and In-Place Normalization
    • Normalize After Joining Text
  • Working with Character Sets
    • Defining a Reusable Character Policy
    • Validating Incoming Text
    • Combining Policies for Different Positions
    • Trimming Borders and Removing Unwanted Characters
    • Character Sets in Word Transformations
  • Fuzzy Matching with Edit Distance
    • Damerau-Levenshtein Edit Distance
    • Finding Candidate Suggestions
    • Suggestion Thresholds, Result Limits, and Comparison Rules
    • Reading Ranked Matches and Edit Distances
• Text Formatting
  • Text Formatting Overview
    • Building Strings Efficiently
    • Formatting Structured Text
    • Describing Values with Named Format Specifications
    • Maintaining Compact Compatibility Specifications
  • Building Strings
    • Appending to StringEditor with Reserved Capacity
    • Concatenating Known String Fragments
    • Collecting and Joining Dynamic String Fragments
    • Building UTF-8, UTF-16, and UTF-32 with AnyStringBuilder
    • Comparing String Construction and Allocation Strategies
    • Structured Output with StringFormat
  • Formatting Text with StringFormat
    • Creating and Reusing a StringFormat Pattern
    • Empty Placeholders and Automatic Argument Numbering
    • Positional Placeholders and Argument Reuse
    • Supported Value Types and Custom FormatAs Representations
  • Named Format Specifications
    • Describing a Value’s Representation
    • Laying Out and Escaping Text
    • Formatting Integer Identifiers and Counts
    • Choosing Floating-Point Notation and Precision
    • Choosing Boolean Words and Capitalization
    • Keeping Byte Diagnostics Bounded
    • Format Errors and Reusable Patterns
  • Compatibility Format Specifications
    • Compact Format Grammar
    • Integer Presentation Letters and Padding
    • Text Precision and Alignment
    • Floating-Point Notation and Precision
    • Compact Text Escaping Extensions
    • Unsupported Compatibility Format Features
• Text Rendering
  • Text Rendering Overview
  • Rendering Text with Layouts
    • From a Layout to a Document
    • Reading the Layout Language
    • Render Environments, Layouts, and Contexts
    • Render Workflow, StringFormat, and Placeholder Alternatives
  • Using the Render Engine
    • A Complete Rendering Pass
    • Configure the Environment
    • Find the Layout by Name
    • Supply Values for This Document
    • Render and Handle Failures
  • Configuring the Render Environment
    • Environment Reuse, Concurrent Rendering, and Auto-Reload
    • Global Render Context and Shared Values
    • Local Context Overrides of Global Values
    • Registering Custom Render Filters
    • Configuring Layout Delimiters
    • Configuring Output Escaping
    • Rendering Work and Output Limits
  • Loading Render Layouts
    • Logical Layout Names
    • Loading Layouts with FileSystemLoader
    • Loading Compiled Layouts with ResourceLoader
    • Loader Priorities and Local Overrides
    • Implementing a Custom Layout Loader
  • Preparing Render Contexts and Values
    • Binding Names in a Render Context
    • Scalar, List, and Map Values
    • Lazy Render Values and Callback Lifetime
  • Template Language Syntax
    • Expression, Statement, and Comment Delimiters
    • Value Expressions and Filters
    • Conditional Branches and Local Assignments
    • Loops over Lists and Maps
    • Whitespace Control in Templates
  • Sharing Layouts with Inheritance
    • Defining Named Template Blocks
    • Extending a Base Layout and Overriding Blocks
    • Rendering Parent-Block Content with super()
    • Multi-Level Layout Inheritance
    • Content Rules for Base and Extending Layouts
  • Template Feature Cheat Sheet
    • Markers and Whitespace
    • Expressions at a Glance
    • Built-In Filters
    • Statements and Layout Structure
    • Output Escaping
    • A Working Layout
• Text Placeholders
  • Text Placeholders Overview
  • Completing Text with Placeholders
    • Placeholder Expression Syntax
    • Registering Sources and Replacing Placeholders
    • Variable and Environment Placeholder Sources
    • Filter Chains and Literal Replacement Values
    • Strict and Tolerant Replacement and Validation
  • Using Built-in Placeholder Sources
    • Reading the Process Environment
    • Supplying Application Values
  • Transforming Placeholder Text with Built-in Filters
    • Enabling the Filter Set
    • Reading Filter Parameters
    • Cleaning and Selecting Text
    • Escaping, Choosing, and Validating
  • Providing Your Own Placeholder Values and Filters
    • Implementing a Custom Placeholder Source
    • Implementing a Custom Placeholder Filter
    • Source and Filter Error Categories and Diagnostics
  • Choosing Placeholder Syntax for Your Text
    • Opening and Closing Placeholder Delimiters
    • Filter Separators and Disabled Filter Chains
    • Name and Parameter Separators
    • Escaping Literal Placeholder Delimiters
    • Strict and Tolerant Placeholder Replacement
    • Single and Repeated Replacement Passes
    • Escaping Replacement Values and Parsing Layers
• Text Parsing and Encoding
  • Text Parsing and Encoding Overview
    • Converting Text and Scalar Values
    • Recognizing Small Text Patterns
    • Converting Strings and Encoded Data
    • Encoding Internationalized Names
    • Encoding Byte Data as Base-N Text
    • Parsing HTML Fragments into Documents
    • Parsing Compact Named-Key Parameters
  • Converting Text and Scalar Values
    • Conversion Failure and Exception Policies
    • Parsing and Formatting Boolean Values
    • Choosing the Accepted Integer Syntax
    • Formatting Integers for Their Destination
    • Parsing and Formatting Floating-Point Values
    • Scalar Conversions for UTF-8, UTF-16, and UTF-32
  • Recognizing Text Patterns
    • Constructing a StringPattern from Parsed Syntax
    • Constructing a StringPattern from Typed Elements
    • Matching String Prefixes and Suffixes
    • Removing Matching Prefixes and Suffixes
    • Splitting Text at Pattern Match Positions
    • Match Lengths and Native String Indexes
  • Converting Strings
    • String Representations and Encoded Byte Data
    • Converting String Representations with StringConverter
    • Encoding Strings as UTF Byte Sequences
    • Width-Independent Text with AnyString and AnyStringEditor
    • Choosing String Conversion, Byte Encoding, or Text Streams
  • Encoding Internationalized Names
    • Use Raw Punycode Only Where a Protocol Defines It
    • Apply the Complete IDNA2008 Rules to Domain Names
    • Preserve Useful Failure Information
  • Encoding Byte Data as Base-N Text
    • Why the Base Matters
    • One Complete Round Trip
  • Writing Bytes as Base-N Text
    • Start with a Byte Block
    • Choose the Alphabet
    • Choose the Padding Character
    • Control the Format Flags
    • Wrap Long Output
  • Reading Base-N Text into Bytes
    • Decode with a Byte Limit
    • Decide Which Characters to Ignore
    • Choose a Padding Policy
    • Strict Base-N Validation
  • Parsing HTML into Documents
    • Where HTML Fragments Fit
    • Parsing Once, Rendering in Different Styles
    • Malformed and Unsupported HTML
  • Parsing Compact Named-Key Parameters
    • Named-Key Entry Syntax and Use Cases
    • Parsing Named-Key Entries and Accessing Results
    • Named-Key Parameter Validation
    • Shared Key Definitions and Allowed-Key Restrictions
  • Configuring Named-Key Parameter Lists
    • Key Identifiers and Accepted Spellings
    • Choose the Forms a Field Accepts
    • Bound Positional Lists and Value Length
  • Customizing Named-Key Syntax
    • Choose Delimiters for the Surrounding Text
    • Add Prefixes and Compact Values
    • Restrict the Value Alphabet
    • When Syntax Choices Conflict
• Data Formats
  • Data Formats Overview
    • JSON
    • BSON
    • CBOR and DAG-CBOR
    • XML
  • Parsing and Rendering JSON Data
    • Reading One Complete Value
    • Following Values Through the Tree
    • Building and Changing a Document
    • Writing JSON
    • Bounding Input
  • Reading and Writing BSON
    • What BSON Stores
    • Core’s BSON Model
    • Parsing a Complete Frame
    • Building a Document
    • Serializing a Document
    • Finding and Editing Values
    • Supported and Preserved Types
    • Limiting Untrusted Input
  • Reading and Writing CBOR and DAG-CBOR
    • What Is CBOR?
    • Parsing a Complete Item
    • Building a Value Tree
    • Serializing a Value
    • Finding and Editing Children
    • Supported Values and Format Boundaries
    • Exchanging DAG-CBOR
    • Limiting Untrusted Input
  • Reading and Writing XML
    • What Is an XML Document?
    • Parsing XML Text
    • Building a Document
    • Serializing XML Text
    • Understanding the Node Types
    • Navigating a Parsed Tree
    • References and Preserved Markup
    • Limiting Untrusted Input
• Configuration
  • Configuration Overview
    • Parsing and Validation
    • Value-Tree Navigation
    • Typed Value Access
    • Validation Rules
    • Validated Values
    • Source Resolving
    • Source Access Control
    • Placeholder Expansion
    • Document Signatures
    • Signature Validation
    • Signing Configuration Files
  • Parsing Configuration Documents
    • Parse and Access a Document
    • Understand Error Locations and Source Excerpts
    • Choose the Document Lifetime
    • Validate Small Documents Directly
    • Load Validation Rules from a Document
    • Build Validation Rules in C++
    • Continue with the Value API
  • Working with Configuration Trees
    • How ELCL Becomes a Tree
    • Address Values with Name Paths
    • Identify a Value in the Document
    • Navigate Between Parents and Children
    • Iterate over Lists and Sections
    • Continue with Individual Values
  • Accessing Configuration Values
    • Convert the Current Value
    • Choose a Structural View for Lists
    • Read Settings with Typed Getters
    • Require Uniform Lists and Matrices
    • Inspect Types Before Choosing a Representation
    • Validate Before Access
  • Validating Documents with Rule Schemas
    • Embed a Rules Document
    • Build Rules into C++
    • Choose the Rule Source
    • Continue with Validated Values
  • Using Values after Validation
    • Use Rule Metadata in User Interfaces
    • Secret Configuration Values and Sensitive Storage
    • Recognize Values Supplied by Defaults
    • Validation Metadata Lifetime and Configuration-Tree Ownership
  • Resolving Configuration Sources
    • From Include Text to Parsed Content
    • Use the Default File Resolver
    • Restrict Accepted File Syntax
    • Write an Application-Specific Resolver
    • Extend or Replace File Resolving
  • Controlling Access to Configuration Sources
    • Access Checks for Root and Included Sources
    • Default File Include Access Restrictions
    • Configuring File Access
    • Extending the File Policy
    • Writing a Complete Access Policy
    • Disabling Includes
  • Using Placeholders in Configuration Text
    • Reading Placeholder Expressions
    • Where Expansion Applies
    • Enabling Built-in Sources and Filters
    • Providing Application Values
    • Transforming Values with Filters
    • Reporting Lookup and Transformation Errors
    • Restricting Placeholder Sources and Filters
  • Trusting Signed Configuration Files
    • Why Sign Configuration Files?
    • Trust Anchors and Signing-Key Trust
    • How ELCL Carries a Signature
    • Parser Responsibilities and Application Trust Policy
  • Validating Configuration Signatures
    • SignatureValidator Inputs and Trust Decisions
    • A Compact Shared-Secret Validator
    • Enforcing Validation During Parsing
    • Strict and Development Policies
    • Signature Rejection and Trusted-Key Rotation
  • Signing Configuration Documents
    • What the Signing Tool Does
    • Implementing a Signing Backend
    • A Complete Parse, Sign, and Verify Workflow
    • Signing the Exact Reviewed Document Bytes
    • Choosing Where Signing Happens
• Command Line Options System
  • Options System Overview
    • How the Pieces Fit Together
    • Command Line Syntax
    • Using Application
    • Using OptionManager Directly
    • Where to Go Next
  • Command-Line Option Definitions
    • Option Names, Aliases, and Positional Arguments
    • Use OptionEditor for Compact Definitions
    • Choose the Right Value Type
    • Work With Choices
    • Repeated Values and Maximum Occurrences
    • Defaults and Validation
    • Flags
    • Customize Option Help
    • Help Visibility
  • Command-Line Option Sets
    • Grouping Component Options with Option Sets
    • Option-Set Help Groups and Metadata
    • Pre-Parsing Callbacks
    • Post-Parsing Callbacks
    • Set Flags
    • Help Visibility on Sets
  • Option Modules
    • Use Modules for Command-Style Tools
    • Root Help and Module Help
    • Add Options and Sets to a Module
    • Module Callbacks
    • Module Main Functions
    • Module Help Metadata and Visibility
  • Accessing Parsed Command-Line Values
    • Parsed Option Values and Lookup
    • Use Typed Getters for Normal Code
    • Flags, Lists, and Module Names
    • Inspect Raw OptionValue Objects
  • Customizing Help Output
    • Detailed Option Help
    • Plain Output Is the Default
    • Enable Terminal Rendering in Application
    • Render Help Manually
    • Customize Display Text
• Exceptions, Errors and Diagnostics
  • Error Handling Overview
    • Choosing How to Report Failure
    • The Common Exception Family
    • Domain-Specific Exceptions
    • Rendering Exceptions as Diagnostics
  • Reporting Errors with Result
    • Named Success and Failure Outcomes
    • Handle Results at the Call Site
    • Create a Custom Result Type
    • Choose Between Result and Exceptions
  • Throwing and Handling Exceptions
    • Throwing Exceptions and Choosing Catch Locations
    • Exception Reasons, Text, and Diagnostics
    • Preserving Exception Cause Chains
    • Application-Level Error Reporting and Exit Codes
  • Working with Diagnostic Data
    • One Exception, One Diagnostic
    • Build a Complete Diagnostic Document
    • Render the Document for Its Destination
    • Display Text and Localization
  • Writing Custom Exceptions
    • Choosing a Base Class for a Custom Exception
    • Storing Error Details in Context Objects
    • Generating Diagnostics from Error Context
    • Escaping External Text in Error Diagnostics
• Filesystem Access and Manipulation
  • Path API Overview
    • Choosing a Component
    • Errors and Non-Throwing Forms
    • Traversal and Symlinks
    • Copying, Moving, and Removing
    • Temporary Resources
    • Working with Paths
  • Working with Paths
    • Constructing Paths
    • Inspecting Paths
    • Comparing Paths
    • Editing Names
    • Joining and Slicing
    • Converting Paths
• Random and Secrets
  • Random API Overview
    • Choosing a Generator
    • Overview Demo
    • Reproducible Randomness
    • Writing Generator-Independent Code
    • Thread Safety
  • Working with Random Values
    • Random Values Demo
    • Integer Values
    • Domain Ranges
    • Lists of Integers
    • Floating-Point Values
    • Boolean Values
    • Random Bytes
    • Random Strings
  • Shuffling and Selecting Elements
    • Element Sampling Demo
    • Selecting One Element
    • Empty Inputs
    • Selecting an Index
    • Sampling with Replacement
    • Sampling without Replacement
    • Shuffling
  • Secure Randomness
    • When Secure Randomness Is Required
    • Secure Randomness Demo
    • Visible Tokens
    • Binary Secrets
    • Protected Generated Values
    • Failure Behavior
    • Logging and Display
    • What SecureRandom Does Not Do
• Dates and Time
  • Dates and Time Overview
    • Choosing a Type
    • Constructing Dates and Times
    • Choosing and Resolving Time Zones
    • Expressing Amounts and Intervals
    • Calendar Calculations
    • Customizing ISO Date and Time Output
    • Measuring Elapsed Time
    • Running the Topic Demos
  • Working with Dates
    • A Calendar Date on Its Own
    • Constructing a Date
    • Checking and Inspecting a Date
    • Converting a Date for Display or Storage
    • Moving Through the Calendar
    • Related Clock, Interval, and Instant Types
  • Working with Times
    • A Clock Reading Within One Day
    • Constructing a Time
    • Comparing Times and Accessing Clock Fields
    • Time since Midnight, Interval, and Text Conversions
    • Calculating Across Midnight
    • Choosing a Dated or Zoned Value
  • Working with UTC Timestamps
    • Choosing an Instant Type
    • Constructing and Checking an Instant
    • Parsing and Formatting ISO Timestamp Text
    • Storing Fields and Portable Bytes
    • Timestamp and DateTime Conversions and Display Zones
    • Converting Epoch Counts Without Losing Meaning
    • Shifting an Instant by a Fixed Interval
    • Finding the Distance Between Instants
    • Continuing with Calendar and Clock Tasks
  • Working with DateTime Values
    • Keeping an Instant and Its Display Together
    • Resolving Calendar Fields
    • Reading Local and UTC Fields
    • Comparing Instants and Comparing Complete Values
    • Changing the Display and Resolving Clock Transitions
    • Reading and Writing ISO Text
    • Choosing an Epoch and an External Number Format
    • Applying Elapsed and Calendar Changes
    • Keeping a Recurring Local Time
  • Customizing ISO Date and Time Output
    • ISO 8601 Representations and Output Requirements
    • Choosing the Formatting Flags
    • Selecting the Displayed Precision
    • Related Date, Time, Timestamp, and Interval Topics
  • Working with Whole-Second Durations
    • Choosing a Fixed Interval
    • Building a Duration
    • Combining Intervals and Checking a Budget
    • Splitting a Total into Components
    • Passing the Interval to Another API
    • Applying Whole-Second Intervals
  • Writing Time Values with Literals
    • Bringing the Suffixes into Scope
    • Choosing a Unit and Writing a Signed Amount
    • Choosing a Representation for an Expression
    • Integer Precision and Representable Bounds
  • Working with Typed Time Amounts
    • A Quantity Is Different from a Calendar Position
    • Time Units and Conversion Groups
    • Creating and Inspecting an Amount
    • Converting to a Compatible Unit
    • Calculating and Comparing in One Unit
    • Giving Calendar Quantities a Starting Date
  • Working with Precise Time Intervals
    • Choosing Nanosecond Precision
    • Constructing an Interval
    • Choosing a Factory and Overflow Policy
    • Combining and Comparing Intervals
    • Handling Arithmetic Boundaries
    • Converting Totals to Another Unit
    • Presenting an Interval
    • Measuring and Applying an Interval
  • Customizing Time Interval Output
    • Starting with a Preset
    • Adjusting Individual Options
    • Combining Precision Settings
    • Formatting Calendar Changes
    • Reusing a Format Across an Application
  • Understanding Calendar Changes
    • Choosing a Calendar Change
    • Composing a Change
    • Combining Changes Before Application
    • Applying Components in Order
    • Calendar Changes and Local Time
    • Handling Range Boundaries
    • Converting to a Fixed Interval
  • Working with Calendar and Time Parts
    • Calendar Positions versus Time Quantities
    • Available Parts and Their Numbering
    • Constructing and Checking a Part
    • Converting Calendar Labels to Zero-Based Amounts
    • Finding Lengths and Valid Days
    • Navigating Across Calendar Boundaries
    • Finding a Weekday Occurrence
    • Converting Ordinal Dates
    • DateParts, TimeParts, and DateTimeParts
  • Measuring Elapsed Time
    • Choosing an Elapsed-Time Clock
    • Timing an Operation
    • Timing Successive Phases
    • Checking a Time Budget
    • Elapsed-Time Measurement Accuracy and Overhead
  • Working with Monotonic Time Points
    • Choosing the Clock for Your Task
    • Recording Checkpoints
    • Calculating Elapsed Intervals
    • Representing a Deadline
    • Interoperating with Standard Library APIs
  • Keeping a Wall-Clock Time with Its Zone
    • A Daily Reading Is Not Yet an Instant
    • Building and Inspecting the Value
    • Resolving a Chosen Date
    • When a Reading Repeats or Does Not Occur
    • Displaying the Intended Time
    • Keeping a Local Time Across Dates
  • Working with Time Zones
    • A Zone Describes Rules; an Offset Describes a Shift
    • Choosing a Zone
    • Inspecting and Comparing Zones
    • Displaying an Existing Instant
    • Interpreting Local Input
    • Understanding Clock Transitions
    • Using the System-Local Zone
    • Keeping Identity and Offset Details Distinct
    • Understanding the Bundled Rules
• Regular Expressions
  • Pattern Syntax
    • Syntax Overview
    • Quoting
    • Special Characters
    • Character Types
    • Character Classes
    • Quantifiers
    • Anchors
    • Alternatives
    • Groups
    • Modes and Flags
    • Unsupported Expressions
  • Regular-Expression Assembler
    • Using the Regular-Expression Assembler
    • Regular-Expression Assembler Syntax
    • Regular-Expression Assembler Registers
    • Regular-Expression Assembler Operations
    • Regular-Expression Assembler Commands
• Event System
  • Event System Overview
    • Event System Concepts and Facilities
    • Application Event Loops
    • Processing Work on Event Threads
    • Event Loops in Application Parts
    • Connecting to Event Sources
    • Callback Ownership and Lifetime
    • Invocations and Timers
    • Simplifying Event Code with Bindings
    • Asynchronous Task Workflows
    • Communication Between Loops
    • Cancellation and Shutdown
    • Handling Event Failures
    • Keeping Loops Responsive Under Load
    • Owning Loop Execution
    • Extending the Event System
    • Related Topics
  • Events in Erbsland Core
    • Event Loops and Targets
    • Callback Execution and Responsiveness
    • Invocations and Timers
    • State and Callback Lifetime
    • Event Sources and Notifications
    • Worker Threads and Application Parts
    • Choosing an Event-Based Design
  • Running an Application with Event Loops
    • The Application’s Main Event Loop
    • Initialization and Cleanup Hooks
    • Worker Event Threads
    • Application Parts and Their Event Loops
  • Processing Work on Event Threads
    • Result Ownership and Synchronization
    • Creating and Starting Managed Threads
    • Posting Work and Choosing a Result Target
    • Completion, Quit, and Join
    • Failure and Interrupted Work
    • Queue Limits and Cooperative Cancellation
  • Using Event Loops in Application Parts
    • Registration and Automatic Startup
    • Configuration and Event-Owned Resources
    • Initialization and Asynchronous Readiness
    • Callback Execution and State Ownership
    • Cross-Thread Service Calls
    • Asynchronous Shutdown
    • Cleanup and Failure Paths
  • Connecting to Event Sources
    • Creating a Source and Registering Handlers
    • Callback Execution Order
    • Source and Handler Lifetime
    • Event Targets and Event Editors
    • Replacing and Clearing Handlers
    • Operation Errors and Callback Exceptions
  • Handling Event Failures
    • API Call Failures, Operation Errors, and Callback Exceptions
    • Operation Errors and Task Completion
    • Reporting Captured Callback Failures
    • Continuing, Quitting, or Failing the Application
    • Custom Callback Failure Handlers
    • Releasing a Caller Waiting for Worker Results
    • Exception Boundaries for Extension Authors
  • Keeping Callbacks and Their Owners Alive
    • Source and Callback Ownership
    • Value Captures and Borrowed References
    • Weak Captures for Optional Recipients
    • Subscription Ownership
    • Cancellation Scope
    • Event Editor Lifetime
    • Releasing Sources from Callbacks
  • Scheduling Work and Timers
    • Deferred Execution with invoke()
    • Delayed Invocations and Timer Handles
    • Fixed-Delay and Fixed-Rate Timers
    • Debouncing with Timer Restart
    • Timer Cancellation and Captured State
  • Simplifying Event Code with Bindings
    • From Nested Callbacks to a Bound Continuation
    • Choosing the Receiving Loop
    • Passing Results to a Bound Method
    • Binding a Callable with Additional Context
    • Retaining an Operation While Its Display Disappears
    • Finishing Work After the User Quits
  • Building Workflows Across Callbacks
    • From Individual Steps to One Operation
    • Advancing the Workflow from a Result
    • Returning Decisions to the Owner Loop
    • Ownership Across the Steps
    • Defining Completion for the Caller
  • Communicating Between Event Loops
    • State Belongs to a Loop
    • A Running Main as the Reply Target
    • Target Lifetime and Recipient Lifetime
    • Replacing a Request Before Its Reply
    • Completion, Failure, and Responsiveness
  • Cancelling Work and Shutting Down
    • Resource Completion Comes Before Loop Termination
    • Cancellation Belongs to the Operation
    • What Graceful Loop Quit Drains
    • Failure and Shutdown Deadlines
    • Ending and Joining Worker Threads
    • Application-Wide Shutdown
    • Required Completion After an Optional View Closes
  • Keeping Event Loops Responsive Under Load
    • Bounding Outstanding Requests
    • Callback Duration and Shared Loop Time
    • Queue Capacity as an Overload Policy
    • A Deliberately Lossy Update Stream
    • Queue Overflow Failure and Waiting Policies
    • Interpreting Queue Counts and Delayed Work
  • Driving Event Loops Directly
  • Designing Objects That Produce Events
  • Defining and Posting Typed Events
  • Writing an Event Backend
  • Integrating Native Waiting and Custom Drivers
• Logging
  • Logging Overview
    • Choose a Setup
    • Write Messages
    • Configure the Manager in Code
    • Route Entries to Destinations
    • Load Configuration From ELCL
  • Choosing a Logging Setup
    • Use One Root Stream in a Small Application
    • Give Components Their Own Streams in a Medium Application
    • Define One Logging Policy for a Large Application
    • Choosing a Logging Setup for Application Requirements
  • Writing Log Messages
    • Component-Owned Log Streams and Stream Paths
    • Log Severity Levels
    • Constructing Log Messages from Printable Values
    • Multiple Component Streams and Writer Routing
    • Guard Expensive Trace Preparation
  • Configuring Logging in Code
    • Logging Configuration during Application Initialization
    • Replacing the Complete Logging Configuration
    • Buffering Startup Messages with pause() and resume()
    • Application-Owned and Standalone Log Manager Shutdown
  • Formatting Log Lines
    • Setting the Default Log Line Format
    • Line Patterns and Field Placeholders
    • UTC and Local Timestamp Formats
    • Severity Name Formats
    • Stream Name Formats
    • Left-Truncated Stream Name Limits
    • Multiline Messages and First-Line Truncation
    • Message Character Limits
    • Total Rendered Line Limits
    • Truncation Marks
    • Per-Writer Line Formats
    • Producer Message Limits versus Rendered Line Limits
  • Configuring Log Manager Limits
    • Installing LogManagerOptions with a Configuration
    • Queue Entry Count Limit
    • Queue Byte Capacity Limit
    • Reserved Queue Entries for Warnings and Errors
    • Reserved Queue Bytes for Warnings and Errors
    • Producer Message Byte Limit
    • Log Worker Shutdown Timeout
    • Log Manager Statistics and Queue Usage
  • Using Trace Sections
    • Trace-Section Filtering and Log Levels
    • Attaching Trace Sections to Log Streams
    • Guarding Trace Preparation with traceEnabled()
    • Naming and Grouping Trace Sections
    • Enabling Trace Sections and Matching Writer Routes
    • Trace-Section Configuration at Startup
    • Runtime Configuration Replacement and Trace Flags
  • Using Log Writers
    • Log Writers, Manager Delivery, and Routes
    • Add a Writer to the Configuration
    • Route the Right Entries to Each Writer
    • Console, File, and Syslog Writers
    • Show Immediate Feedback on the Console
    • Keep Durable Operational History in a File
    • Send Service Events to a Syslog Collector
    • Recent Errors on Application Exit
    • Implementing a Custom Log Writer
  • Writing Logs to the Console
    • Add Console Output to an Application
    • Console Log Writer Options
    • Control Paragraph Layout
    • Set the Base Style for Every Line
    • Style Complete Lines by Severity
    • Semantic Field Styles across Severity Levels
    • Severity-Specific Field Style Overrides
    • Remain Readable Without Terminal Styling
  • Writing Logs to Files
    • Add a File Writer to a Log Configuration
    • File Writer Path and Options
    • Choose Append or Overwrite for the First Open
    • Time-Based and Size-Based File Rotation
    • Set the Byte Threshold for Size Rotation
    • Rotated Archive Retention
    • External File Replacement and Automatic Reopening
    • File Writer Failures and Recovery
  • Sending Logs to Syslog
    • Add a Syslog Writer to the Configuration
    • Syslog Log Writer Options
    • Choose UDP, TCP, or TLS Transport
    • Select the Collector Endpoint
    • Choose the RFC Facility
    • Host Name: HOSTNAME
    • Application Name: APP-NAME
    • Process Identifier: PROCID
    • Message Identifier: MSGID
    • RFC 5424 Header Format
    • Select the TLS Configuration Label
    • Bound Pending Network Data
    • Plan for Collector and Network Failures
  • Loading Logging Configuration
    • Logging Configuration File Locations
    • Load a Dedicated log.elcl
    • Load Log From application.elcl
    • Validate the Log Configuration Before Parsing
    • Parsing and Installing a Logging Configuration Snapshot
    • Root, Nested, and Invalid Logging Configuration Examples
    • Application Reporting of Logging Configuration Errors
  • Writing an ELCL Logging Configuration
    • Minimal Console Writer Configuration
    • Queue Limits, Line Formats, and Log Routing
    • Default Log Line Format
    • Log Queue Limits, Reservations, and Shutdown Timeout
    • Enabled Trace Sections
    • Writer Routes and Level/Path Filters
    • Per-Writer Log Line Formats
    • Console Paragraph Layout and Wrapping
    • File Paths, Rotation, and Archive Retention
    • Syslog Transport, Collector, and Header Fields
• Streams
  • Working with Streams
    • Creating Streams and Managing Ownership
    • Byte Input and Output
    • Text Input, Output, and Encoding
    • Standard Streams
    • Readiness and Timeouts
    • Buffering and Back Pressure
    • Stream Lifecycle
    • Temporary Streams
    • Positioning Streams
    • Stream Errors and Diagnostics
    • Coroutine Streams
    • Writing Custom Streams
  • Creating Streams and Managing Ownership
    • Choose a Narrow Stream Interface
    • Open File Streams Through a Path
    • Configure Before Opening
    • Design Functions Around Stream Interfaces
    • Manage Shared Ownership Deliberately
    • Where to Continue
  • Byte Input and Output
    • The Byte Stream Interfaces
    • Handle Every Read Result
    • Continue Reads After a Timeout
    • Read a Small Source with a Limit
    • Write Complete Atomic Requests
    • Read and Write Fixed-Width Integers
    • Process Large Input in Bounded Chunks
  • Text Input, Output, and Encoding
    • Choose the Text Operation That Matches the Task
    • Process Unicode Without Splitting Encoded Characters
    • Read Lines Without Losing Their Structure
    • Produce Text as Complete Atomic Requests
    • Capture Reusable Text Output in Memory
    • Match the Encoding and BOM Policy to the Format
    • Choose Deliberately How Malformed Text Is Handled
  • Standard Streams
    • Standard Stream Proxies and Redirection
    • Standard Output and Error Helpers in stream::io
    • Keep Results and Diagnostics on Separate Channels
    • Make Standard Input Deterministic with Scoped Redirection
    • Protect Native Standard-Input Buffers
    • Capture Output Without Changing the Producer
    • Compose Redirections in Strictly Nested Scopes
    • Treat Redirects as Shared Process State
  • Readiness and Timeouts
    • Stream Readiness, Waits, and Deadlines
    • Check Whether a Stream Is Ready
    • Wait Until a Stream Is Ready
    • Handle Operation Timeouts
  • Buffering and Back Pressure
    • Understand the Buffer Limits
    • Read Complete Values Without Manual Assembly
    • Throttle Fast Output Producers
    • Keep Atomic Writes Within the Hard Limit
    • Flush at Delivery Boundaries
  • Stream Lifecycle
    • Stream Ownership and Close Responsibilities
    • Graceful Output Stream Close
    • Close Timeouts, Retries, and Application Deadlines
    • Immediate Stream Abort and Discarded Data
    • Native Stream Failures and Replacement
  • Temporary Streams
    • Create Temporary Text
    • Create Temporary Bytes
    • Remove Synchronously on Close
    • Releasing Ownership of a Temporary File
    • Keep Failure Cleanup Non-Blocking
  • Positioning Streams
    • Checking Stream Positioning Support
    • Use Logical Byte Positions
    • Move Relative to a Reference Point
    • Create Sparse Output Deliberately
    • Position Encoded Text Carefully
    • Retry Positioning After Timeout
  • Stream Errors and Diagnostics
    • Separate Results from Failures
    • Inspecting Stream Error Context
    • Rendering Stream Error Diagnostics
    • Preserve Context Through Wrappers
    • Handle Encoding Errors Separately
  • Coroutine Streams
    • Await Bounded Input
    • Await Owned Atomic Output
    • Generate Byte or Text Blocks
    • Generate Complete Lines
    • Keep Timeout as Flow Control
    • Retain Shared Stream Ownership
    • Cancel by Releasing the Task
  • Writing Custom Streams
    • Choose the Narrowest Base
    • Implement Bounded Input
    • Implement Atomic Output
    • Forward Errors and Positioning Honestly
    • Support Coroutine Ownership Deliberately
    • Test the Complete Contract
• Network
  • Network API Overview
    • Address and Host Values
    • Resolving Hosts
    • Transports
    • HTTP Servers
    • HTTP Clients
  • Working with IP Addresses and Hostnames
    • Parse and Inspect Addresses and Hosts
    • Internationalized Host Names
    • Build Endpoints without Ambiguity
    • Match Networks and Address Ranges
    • From Host Names to Addresses
  • Resolving Hosts Asynchronously
    • Starting Host Resolution and Receiving Addresses
    • Host Lookup Timeouts and Retry Limits
    • Host Lookup Errors and Diagnostics
    • Host Lookup Owner Loops and Callback Execution
    • Cancelling Host Resolution
    • HostLookup Ownership and Lifetime
  • Using TCP Connections
    • TCP Carries a Stream, Not Requests
    • Configuring the Example TCP Lookup Service
    • Listen and Accept Connections
    • Server-Side TCP Message Framing and Responses
    • Connect from the Client
    • Send and Receive One Framed Message
  • How to Use TLS Client Connections
    • Connection Ownership and the Event Loop
    • Choosing Which Server to Trust
    • Following Connection and Authentication
    • Receiving a Byte Stream
    • Sending Without Blocking
    • Deadlines, Closure, and Failure
    • Presenting a Client Certificate
  • How to Use TLS Server Connections
    • From Listener to TLS Session
    • Providing the Server Identity
    • Completing the Handshake Before Application Work
    • Bounding Connections and Handshakes
    • Flow Control and Bounded Input
    • Selecting Profiles with SNI
    • Authenticating Clients
    • Finishing Sessions and Stopping the Service
  • Using HTTP Servers
    • Starting a Plaintext Server
    • How Routes Match
    • Serving Static Content
    • Reading a Request Body
    • Streaming a Response
    • Enabling HTTPS
    • Complete HTTPS Server Demo
    • Using Cookie-Backed Sessions
  • Using HTTP Clients
    • Sending a Request
    • Choosing Automatic Response Handling
    • Following Redirects
    • Using the Cookie Jar
    • Streaming a Download
    • Sequential Connection Reuse
    • Streaming an Upload
    • HTTPS and Deadlines
    • Closing the Session
  • Sending and Receiving UDP Packets
    • One Socket, Many Packets
    • Receive and Reply at a Service
    • Send Only After Binding
    • Handle Replies as Untrusted Packets
    • React to a Full Output Queue
    • Pausing and Resuming UDP Packet Delivery
    • Graceful UDP Socket Close and Immediate Abort
• Color Terminal
  • Color Terminal Demos
    • Bitmap Showcase
    • Log Viewer
    • Frame Color Animations
    • Retro Plasma: Animated Terminal Rendering
    • Frame Weaver: Frame Intersections and Styles
    • Display All Colors
    • Display All Attributes
    • Key Input Demo
    • Grid Layout
    • HTML Viewer
    • Terminal Chronicle: Styled Console Output
    • Text Gallery
  • Terminal Setup and Screen Rendering
    • Preparing and Rendering a Screen
    • Render Loop for Interactive Applications
    • Direct Writes, Line Buffering, and Refresh Modes
    • Controlling Screen Update Settings
    • Output Modes
    • Scoped Terminal Sessions
  • Implementing Terminal Backends
    • Choosing When to Use a Custom Backend
    • How Terminal Uses Backend Capabilities
    • Implementing a Recording Backend
    • Screen Size and Input Responsibilities
    • Public API and Internal Implementations
  • Keyboard Input and Terminal Text Editing
    • Polling for Keys in a Redraw Loop
    • Switching Between Key and Line Input
    • Reading Editable Text
    • Polling the ReadLine Text Editor
    • Editing and Multiple Lines
    • History and Draft Text
    • Masked Secret Input and Empty-Input Placeholders
    • Text Editor Layouts and Terminal-State Cleanup
    • Inactivity Timeout
    • Describing Key Bindings
    • Matching Decoded Key Types
  • Cursor-Based Terminal Output
    • Printing Mixed Arguments
    • Moving the Cursor Explicitly
    • VT100-Compatible Line Wrapping
    • Printing Wrapped Paragraphs
    • Choosing Between Terminal and CursorBuffer
  • Working with Terminal Buffers
    • Reading and Writing Through Buffer Interfaces
    • Write-Clipped Paint Operations
    • Cloning, Copying, and Resizing
    • Working with Remapped Buffers
    • Streaming Scrollback with CursorBuffer
    • Building Buffers from BlockText Lines
    • Copying and Aligning Sub-Regions
    • Comparing Frames and Deriving Masks
  • Viewing and Scrolling Terminal Buffers
    • Viewing a Portion of a Larger Buffer
    • Scrolling by Moving the View Rectangle
    • Choosing Between Shared and Referenced Views
    • Showing Cropped Edges Explicitly
  • Drawing Terminal Frames, Borders, and Tiles
    • Filling Panels and Drawing Simple Frames
    • Combining Frames Automatically
    • Drawing Grid Layouts
    • Repeating 9-Tile Styles
    • Configuring Reusable Frame Presets
    • Choosing FrameStyle, Block16Style, or Tile9Style
  • Rendering Text in Terminal Buffers
    • Drawing Direct Strings and Aligned Labels
    • BlockText Alignment Inside a Rectangle
    • Rendering Wrapped Paragraphs
    • Reusing BlockTextOptions and Animation
  • Configuring Terminal Paragraph Layout
    • Building and Reusing Paragraph Presets
    • Defaults at a Glance
    • Alignment
    • Indentation
    • Wrap Marks
    • Paragraph Spacing
    • Word Separators
    • Word Break Mark
    • Maximum Wraps and Ellipsis
    • Tab Stops and Overflow Behavior
    • Background Fill Modes
    • Reusable Indents and Separator Sets
    • Error Handling
  • Rendering Terminal Bitmaps
    • Preparing a Small Pixel Mask
    • Building Bitmaps from BlockText Patterns
    • Rendering a Bitmap to a Buffer
    • Choosing the Scale Mode
    • Color and Animation Rules
  • Rendering and Defining Bitmap Fonts
    • Rendering a Bitmap Font Title
    • Creating a Font from Row Masks
    • Embedding a Reusable Font Preset
    • Reusing Font Settings with BlockTextOptions
  • Terminal Text Blocks and Block Strings
    • Terminal Display Cells with Block
    • Block Strings
    • Implicit Sharing and Ranges
    • Handling Invalid UTF-8 Input
    • Searching, Slicing, and Measuring
    • Splitting, Wrapping, and Lines
  • Terminal Colors and Animated Palettes
    • Applying Colors Directly
    • Serializing Palette Values
    • Building Animated Palettes
  • Terminal Layout Geometry
    • Deriving Layout Regions from a Canvas
    • Combining, Intersecting, and Testing Rectangles
    • Aligning Smaller Content and Cropping Larger Sources
    • Splitting a Rectangle into Grid Cells
    • Walking Neighbors and Frame Perimeters
    • Deriving Bounds and Keeping Cursors in Range
    • Orientation Helpers and Coordinate Values