sparkles · unicode/

Agent Guidelines Package Catalog Functional & Declarative Programming

docs/

Overview

Package Overview Glossary

Credits

All components sparkles:terminal hue

Design System

Overview Glyphs

Catalog

Welcome Primitives Layout Tracks Text Themes Slots Decoration Grid Components Tree Property tree Table Scrolling State Split Dock Terminal

Guidelines

Design by Introspection

Intro Guidelines

Interpolated Expression Sequences DDoc Writing Research Docs Writing Specification Docs Writing Specification Prose Integrating C Libraries (ImportC) Benchmarking & Profiling Cutting a Release Android Release Runbook Move Semantics & __rvalue Modern D Language Features Composable Memory Allocators

Code Style

Overview Appendix: Official DStyle

Idioms

Forcing Named Arguments Expected Error Handling

idioms/

forced-named-arguments/

abi_comparison.d alternatives.d lib.d test_negative.d test_positive.d

Apps

sparkles:terminal

Getting started On Android

Reference

CLI Key & mouse bindings

sparkles:hue

Open issues

ui-gallery

Open issues

Libraries

event-horizon

Tutorial

Coming from Node.js Coming from eventcore Coming from vibe-core Coming from libasync Coming from Photon Coming from collie Coming from hunt-net Coming from EVE Running the examples

snippets/

eh_callback_concurrency.d eh_callback_deadline.d eh_callback_file_read.d eh_callback_retry.d eh_callback_tcp_echo.d eh_callback_timers.d eh_channel.d eh_concurrency.d eh_deadline.d eh_exec.d eh_file_read.d eh_retry.d eh_signal.d eh_spawn.d eh_tcp_echo.d eh_timers.d node_channel.mjs node_concurrency.mjs node_deadline.mjs node_exec.mjs node_file_read.mjs node_retry.mjs node_signal.mjs node_spawn.mjs node_tcp_echo.mjs node_timers.mjs vibe_channel.d vibe_concurrency.d vibe_deadline.d vibe_exec.d vibe_file_read.d vibe_retry.d vibe_signal.d vibe_spawn.d vibe_tcp_echo.d vibe_timers.d

base

Tutorial

Write @nogc text Log with CoreLogger Style templates with IES Pretty-print values Parse text with readers Analyze Unicode text Own heap values without the collector Test @nogc code with check helpers

How-to guides

Reference

API index Base codecs Percent-encoding Unicode analysis

Explanation

The design Buffers: storage as capabilities Base codecs: design notes

dmd-fmt

Reference

Layout decisions

code-instrumentation

Tutorial

Handle parse failures Match a report to a source file

How-to guides

Reference

API

Explanation

Why the parsers look the way they do

core-cli

drawTable playground

reflection

Tutorial

Embed a viewer pane Module reference

Reference

API

Explanation

Structure versus policy

doc-view

metadata

Reference Explanation

font

Tutorial

Open a face and map text

How-to

Inspect a damaged font

Reference

API

Explanation

Borrowing and leniency

fuzzy

Tutorial

How-to guides

Chunked search

Reference

API

Explanation

Admission and ranking

shaders

syntax

Tutorial

The core The tree-sitter engine

Reference

Explanation

The design

test-runner

Tutorial

Run and filter tests Write @ctfe tests Write @betterC tests Write @wasm tests Benchmark with @benchmark Measure workloads with @workload Skip tests at runtime Run tests on Android

How-to guides

Reference

Command-line options Attributes

Explanation

The design

Guide (single page)

versions

Tutorial

Compare and sort versions Constrain with ranges VERS and pURL interop Handle unknown schemes Add a new scheme

How-to guides

Reference

Concepts and API Scheme catalogue API index

Explanation

The design Prior art No cross-scheme order Prerelease in ranges

twoslash

How to render a twoslash payload Reference: the overlay API

ui

wired

Serialization Resolve scalar configuration

Specs

Application Packaging

Owned UTF/Unicode specification Foundation delivery plan Foundation testing & evidence Foundation decisions Wrapping & measurement Cell-splitting & width spec Conformance test cases Conformance harness Case-style spec Enums spec float_conv spec

Base

Text

Buffer spec Generational pool spec CustomFloat spec

Capability VFS

SPEC Backends PLAN Testing Decisions

Build Primitives

Filesets

SPEC PLAN Decisions

CI

ci-stats specification ci-stats delivery plan Task DAG specification Task DAG delivery plan

Core-CLI

args subcommands spec drawTable spec TUI component suite TUI components delivery plan

Design System (proposal)

Overview Specification Capabilities Glyphs & typography Keyboard vocabulary Web The Sparkles theme Testing Delivery plan Decisions

DMD-FMT

M0 Decision Record Testing & Decision Docs Codemod Roadmap

DMD-LSP

Overview Feature Requirements DDoc Test Plan Dub-Project Context Target Profiles & Device Code

Docs (SSG)

Overview SSG surface Site discovery API doc generator Components (flow-mode) Glossary data

DQL

Specification

Event Horizon

Specification Delivery Plan Open Issues Benchmarks

Window System Integration

Specification Feature Requirements Delivery Plan Supported Features Open Issues Event Delivery Under Load

Font (proposal)

Specification Parsing Operations (M1) Variation, Metrics, Inspection (M2) Delivery Plan Testing & Evidence Decisions

Shaders (proposal)

Specification Delivery Plan Testing & Evidence Decisions Adversarial Review

Text Layout

Specification Delivery Plan Testing & Evidence Decisions

Font Explorer (proposal)

Specification Delivery Plan Design Register

Fuzzy

Specification Delivery Plan Benchmarks

Hue

Overview Delivery Status Feature Requirements Viewer (tier-scoped) GUI (--gui) TUI (planned) Document chrome (design) Pager & streaming (design) Android (NativeActivity APK) F-Droid distribution Configuration (design) Content folding (planned) Format preview (shipped v1) Tree / DAG view (planned) Tab view (planned) Gallery & multi-document nav Diff & PR view (planned) DSV preview (design) Navigation (planned) Images & diagrams (planned) Twoslash (planned) Web integration (planned) Overlays (planned) Notifier (planned) Lantern (key guide) Picker (planned) UI architecture Transformer pipeline Open implementation issues

Nix

Design Proposal Delivery Plan

Parsing (proposal)

Release

Design Proposal Delivery Plan Label-Vocabulary Dialects Next-milestones handoff

Syntax (proposal)

Test Runner

Specification Delivery Plan Open specification issues

Terminal

Overview Android (nix-on-droid app) Configuration and settings Terminal profiles (draft) Profile configuration and persistence (draft) Keymap and key guide Terminal protocols About, logs, notifications Selection and autofill Exit prompt, tabs and splits Opening files: the viewer Design: mockup register Decisions Delivery plan Testing and evidence

Android Nix development environments

Specification Project milestones Acceptance and evidence Decisions and design gates

TUI

Overview Delivery Plan Render-core benchmark baseline

Twoslash

Specification

UI

Overview Feature Requirements Principles Layout (decision) Theme (planned) Widgets Gutter channels Containers (planned) Inspector Property tree Anchored overlays (proposed) Input (planned) State machines Keymap & lantern Interaction architecture review Editor (planned) Backends Effects & images Effects & images · demos Migration (planned) Open implementation issues

UI SDL3

Native Wayland resize handoff

UI Skia

isCanvas seam friction

UI App

Overview Feature Requirements Delivery Plan Terminal View Open issues

Diagram

Overview Feature Requirements Delivery Plan

UI Gallery

Overview Open issues

Versions

Wired

Definition resolution Scalar resolution interface Collection and submodule composition Property, source, value Delivery plan Oracles and evidence Decisions and open questions

Configuration resolution (draft)

Expressiveness Upgrade

Specification Delivery Plan Provenance Manifest

SDL Backend

Runtime JSON benchmark baseline Open specification issues

Dman (design)

Overview Feature Requirements Architecture Command Schema CLI Surface Config VCS Backend Designing for jj Repo Catalog Workspaces TUI Shell Milestones Decisions

Research

SIMD UTF & Unicode

UTF Algorithms Measured Performance Unicode Algorithms

Platform UI Guidelines

iOS / iPadOS Android (Material You)

Mobile

Linux desktop

GNOME (XDG portal) KDE Plasma

portal-appearance.d

Desktop OS

Windows macOS

Non-GUI surfaces

Terminal emulators The web

Color derivation Comparison & synthesis Sparkles proposal

color-scheme-probe.d

Prior art

libadwaita AdwSettings

Applying it

kdeglobals-appearance.d

Serde Expressiveness

Pydantic v2 msgspec & cattrs

Baseline

sparkles:wired

TypeScript

Effect Schema

Rust

serde facet

Python

Functional Lineage

zio-schema autodocodec, tomland & unjson circe & aeson Invertible Syntax OCaml ppx & ATD

Cross-Cutting

argv as a Codec

Comparison & Synthesis

Parsing

Formal Languages Top-Down (LL / ALL*) Bottom-Up (LR / GLR) General (Earley / CYK / GLL) PEG & Packrat Operator-Precedence & Pratt Parsing with Derivatives Incremental & Query-Based

Foundations (Theory)

Generators

ANTLR GNU Bison & yacc Menhir pest

Parser Combinators

Parsec / Megaparsec nom chumsky winnow (nom fork) flatparse (Haskell) combine (Rust) Angstrom (OCaml) FParsec (F#)

High-Performance & SIMD

simdjson simd-json (Rust) sonic-rs (Rust) yyjson (C, no-SIMD) RapidJSON (C++) Hyperscan (regex) Zig tokenizer

Incremental & Query-Based

Tree-sitter rust-analyzer (+ salsa) Roslyn Lezer rustc queries

Syntax Highlighting

syntect bat tree-sitter-highlight Shiki Pygments Chroma highlight.js @lezer/highlight Helix (editor engine) Linguist LSP Semantic Tokens IntelliJ Platform Vim & Emacs font-lock

Comparison & Synthesis The D Landscape

SQL & ORM Abstraction

Effect TS (sql) Quill (Scala) doobie (Scala) skunk (Scala) Slick (Scala) Ecto (Elixir)

Effect Systems & Functional Access

Typed Functional SQL (Haskell)

hasql Squeal Opaleye Beam persistent + esqueleto

Typed Builders & Thin Safe-SQL

Diesel (Rust) sqlx (Rust) SeaORM (Rust) Kysely (TypeScript) Drizzle (TypeScript) jOOQ (Java) sqlc (Go) linq2db (.NET) Dapper (.NET) Exposed (Kotlin)

Full ORMs / Data Mappers

EF Core (.NET) Hibernate / JPA (Java) SQLAlchemy (Python) Django ORM (Python) Prisma (TypeScript) TypeORM (TypeScript) GORM (Go) ent (Go) ActiveRecord (Ruby)

Raw Drivers & Tagged-Template Baseline

Go database/sql (+ sqlx) postgres.js (JS/TS) JDBI (Java)

Comparison & Synthesis Case Study: Safe SQL Interpolation

Sean Parent: Better Code

C++ Seasoning Local Reasoning Regular Types Value Semantics Algorithms Concurrency Chains Data Structures Relationships Contracts Safety Human Interface Generic Programming

Algebraic Effects

Cross-Cutting

Comparison Evolution Parallelism Papers Theory & Compilation

Effect-Native Languages

Koka Eff Frank Unison

Haskell

effectful polysemy fused-effects cleff bluefin freer-simple mtl eff theseus heftia

Scala

ZIO Cats Effect Kyo Ox Scala 3 Capabilities Turbolift

OCaml

OCaml 5 Effects Eio

Rust

Implicit Effect System effing-mad CPS Effects

Swift

Swift Effects

Industry Platforms

Effect (TypeScript) Project Loom (Java) WasmFX

Durable Execution

Concepts & Vocabulary Comparison & Delta

Engines & SDKs

@effect/workflow Temporal Restate DBOS Transact Azure Durable Functions Dapr Workflow & DTFx Inngest Cloudflare Workflows Vercel Workflow Resonate Golem Trigger.dev AWS Step Functions

Event Sourcing

Akka / Pekko Persistence Orleans KurrentDB Marten

Theory

Durable Functions Semantics (OOPSLA 2021) Netherite (VLDB 2022) Sagas (1987) Compensation Calculi Write-Ahead Logging (ARIES) Idempotence (Helland) Deterministic Replay Replay vs Snapshot Deterministic Simulation Testing Effect Handlers & Record/Replay

replay-journal.d

Other Implementations

Iroh (P2P / QUIC)

Identity & Cryptography Wire Formats & Serialization QUIC Transport (noq)

Foundations

Connectivity

Endpoint & Protocol Router The Multipath Socket NAT Traversal & Address Discovery The Relay Protocol Address Lookup (Discovery) Net Report & Interface Watching

Data Protocols

Blobs: Content-Addressed Transfer BLAKE3 Verified Streaming (bao-tree) Document Sync (iroh-docs) Epidemic Broadcast (iroh-gossip)

D Migration

Tokio Concurrency Inventory D Architecture Migration

Async I/O & Event Loops

Concepts

Primitives Implementation Techniques kqueue, PTYs & Signals on macOS Process Supervision

io_uring Reference

Features by Area Timeline (v5.1–v7.1) Opcode & Flag Reference

async-cancel.d clock-min-timeout.d cqe-mixed.d cqe-skip.d defer-taskrun.d direct-descriptors.d epoll-wait.d fs-mutations.d futex-waitv.d futex.d linked-sqes.d msg-ring.d multishot-accept.d multishot-recv.d multishot-timeout.d napi.d nop.d openat-statx-close.d pipe.d poll-add.d probe.d provided-buf-ring.d read-multishot.d read-write-fixed.d recv-zc.d registered-files.d registered-ring-fd.d resize-rings.d restrictions.d send-zc.d sendmsg-recvmsg.d socket-bind-listen.d splice-tee.d sq-rewind.d sqe-mixed.d sqpoll.d sync-cancel.d tcp-echo.d timeout-link-timeout.d uring-cmd-socket.d waitid.d

Library Deep-Dives

Tokio (Rust) Glommio (Rust) monoio (Rust) Boost.Asio (C++) Seastar (C++) libuv (C) Grand Central Dispatch (macOS) Zig std.Io .NET Runtime Java Go Netpoller Python (asyncio / Trio) Haskell Lean 4 OCaml Eio Backend

qos-parallelism.d root-queues.d source-read-pipe.d source-timer-leeway.d sync-on-caller-thread.d target-queue-funnel.d

Synthesis

Effects & Event Loops D Landscape Comparison & Recommendations

Code Formatting

Oppen's Algorithm Combinators Optimality Cost & Search Layout Preservation

Foundations (Theory)

Combinator & Greedy

Prettier Prettier's Decisions swift-format OCamlFormat The Rust Reimplementation Wave

Search-Based

clang-format dfmt (D) dart_style

Structure-Preserving

gofmt zig fmt Roslyn rustfmt

Declarative & Long Tail

Topiary The Long Tail

Verification How Formatters Test Themselves Readability Evidence Comparison & Synthesis The D Landscape The dmd-lsp Substrate A Proposal: sparkles:dmd-fmt

Content Addressing

Nix Archive (NAR) casync / desync

Serial Serialization

Merkle Trees

Venti (Plan 9) Git objects Git cache-tree Nix git-hashing Snix castore Mercurial -> Sapling Bazel REAPI OSTree Software Heritage bup / git-annex

Intra-File Trees

Bao / BLAKE3 IPFS unixfs / CID composefs + fs-verity dm-verity / APK v4 Tahoe-LAFS

Archives & Retrofits

OCI image layers eStargz / SOCI Reproducible archives

Adjacent

Build input caches

Synthesis & Recommendations

Safe Path Traversal

Bishop & Dilger 1996 Dean & Hu 2004 / Borisov 2005 Wei & Pu 2005 Watson 2007 Tsafrir 2008 Cai 2009 Chari 2010 Payer 2012 Raducu 2022

Attacks & Theory

Kernel Mechanisms

Linux openat2 Linux procfs & magic links FreeBSD & OpenBSD Darwin Windows NT

Libraries & Runtime APIs

libpathrs filepath-securejoin Go os.Root Rust std rustix cap-std openat / openat-ext gnulib fts CPython shutil

Talks & Articles

Aleksa Sarai's talks LWN openat2 series Forshaw: Windows symlinks

Comparison & Recommendations

component-walk.d fd-remove-tree.d openat2-resolve-flags.d

Fileset & File-Selection Languages

jj filesets jj revsets Mercurial filesets Sapling pathmatcher bazel query & glob() nixpkgs lib.fileset

Set-Algebra Languages

Rule Lists & Prefix Namespaces

git pathspec git sparse-checkout Ordered-rule filters The ignore crate

Build Systems & Watchers

Ant & Gradle filesets watchman queries

Interactive & Shell Tools

fzf & fff find, fd, ripgrep

Comparison & Synthesis Recommendations Contradictions with the Brief

Fuzzy Matching & Pickers

Matchers

fzf fzy nucleo frizbee telescope-fzf-native

Engines & Picker Hosts

fff snacks.picker Helix × nucleo

Comparison

Full-Text Search

Concepts & Vocabulary Measurement Protocol Sparkles Baseline Foundations (Theory) fff (grep engine) GNU grep ripgrep ugrep git grep The Silver Searcher hypergrep Grep long tail Rust regex & RE2 lineage Phobos std.regex RE2 PCRE2 Vectorscan Oniguruma .NET non-backtracking Engine comparison Literal prefilters Multi-pattern search Automata Bit-parallel matching String matching Approximate matching Succinct indexes Ranked retrieval n-gram indexes Google Code Search Zoekt livegrep Suffix structures Compressed self-indexes Lucene tantivy PISA Embedded FTS Wide SIMD GPU automata GPU retrieval Hardware automata Corpus access Unicode semantics Approximate search Structural search Interactive contracts Live-grep hosts Editor project search Comparison Recommendations

Diff Viewers & PR Review

Terminal Differs

delta git-split-diffs

Structural Diff & Merge

Difftastic Mergiraf diffoscope SemanticDiff

Editor Diff Stacks

codediff.nvim diffview.nvim diffview-plus.nvim diffs.nvim Neovim linematch Neovim charmatch (PR) VS Code Diff Editor GitLens

TUI Clients

gitui lazygit

Desktop GUI Differs

Meld WinMerge Araxis Merge Beyond Compare

Web Review Platforms

Gerrit ReviewStack (Sapling) Reviewable diffy

Stacked PRs & Workflow

av (Aviator) git-spice git-branchless GitButler Graphite

Comparison (Synthesis)

CPU PMUs

perf_event_open (the hub) elfutils (code space) libtraceevent (event space) libnuma (topology) Precise Sampling (IBS/PEBS/SPE)

The Linux Stack

ISA Mappings

ARMv8+ RISC-V

OS Backends

Windows macOS

Event Naming & Encoding

Synthesis

Capability Comparison sparkles Baseline Backend Proposal

counting-group.d mem-latency-numa.d pfm4-name-roundtrip.d sampling-symbolize.d unwind-stack-user.d

Sanitizers

AddressSanitizer (+ LSan) ThreadSanitizer UBSan (the D absence)

The LLVM Stack

The D Toolchain The Valgrind Family

The Field

Runner Integrations macOS & Windows Hardware-Assisted & Sampling

Synthesis

Capability Comparison sparkles Baseline Integration Proposal

asan-global-overflow.d asan-heap-uaf.d asan-report-capture.d asan-stack-uar.d fiber-asan.d gc-uaf-blindspot.d lsan-gc-interplay.d tsan-data-race.d valgrind-attribution.d valgrind-client-requests.d valgrind-memcheck-catch.d

Mathematical Animation Engines

Scene Graph & Geometry Text & LaTeX Pipeline Caching & Determinism

Programmatic Engines

Manim Community (Python)

ManimGL (Python) Motion Canvas (TS) Remotion (React) Theatre.js (TS) Javis.jl (Julia) Makie.jl (Julia) nannou (Rust) MathAnimation (C++)

Declarative Diagramming

Penrose Bluefish TikZ / PGF Asymptote CeTZ (Typst) MetaPost

Building Blocks

Rendering Backends

CPU Vector (Cairo/Blend2D) GPU Vector (Vello/raylib) Path Ops & Flattening

cairo_c.c package.d surface.d

Math Typesetting Video Encoding

Synthesis

Capability Comparison sparkles Baseline Animation Engine Proposal

affine-transform.d bezier-eval.d frame-capture.d rate-functions.d

Coroutines (LDC)

Stackless vs Stackful WebAssembly & WasmFX

Stackless

LLVM Model & Intrinsics LLVM Pass Internals C++20 Coroutines Cross-Language Comparison D Language Design LDC Code Generation Attributes & Memory Implementation Roadmap

Stackful

D Fiber Context Switching Green Threads & Scheduling Stack Management WasmFX as a Target Fiber → WasmFX Plan

Monorepo & Workspace Tooling

package.json pnpm-workspace.yaml

JS/TS Package Managers

npm Yarn Berry pnpm Bun

.yarnrc.yml package.json

Python Package Managers

uv Poetry Hatch

Language Package Managers / Build Systems

Cargo (Rust) Go (go.work) Gradle (JVM) Maven (JVM) sbt (Scala) Mill (Scala/JVM) Composer (PHP)

main.go

greeter.go greeter_test.go

Makefile go.work

JS/TS Task Orchestrators

Nx Turborepo Lerna Rush Lage Wireit

sample/

packages/

cli/

package.json tsconfig.json

greeter/

package.json tsconfig.json

package.json pnpm-workspace.yaml tsconfig.base.json turbo.json

sample/

packages/

cli/

package.json project.json tsconfig.json

greeter/

package.json project.json tsconfig.json

nx.json package.json tsconfig.base.json

Polyglot Build Orchestrators

Bazel Buck2 Pants Please moon GN + Ninja

add.h

toolchain.yml workspace.yml

apps/

web/

moon.yml package.json tsconfig.json

packages/

utils/

moon.yml package.json tsconfig.json

package.json pnpm-workspace.yaml

Container / CI-Oriented

Dagger Earthly Garden

Generic Task Runners

Task (go-task) Just mise Make

Native Build Systems

Meson CMake SCons Waf Ninja

Remote Execution Backends

BuildBuddy Buildbarn NativeLink

Minimalist / Research

redo tup

Polyglot Glue

Nix (flakes)

Synthesis

dub Baseline Comparison & Recommendations dub Workspace Proposal

Application Packaging

Concepts & Baseline

Concepts Artifact Formats Release Pipeline Sparkles Baseline

Linux

Native Packages Repositories AppImage Flatpak Snap linuxdeploy + appimagetool

Windows

Portable Applications WiX / MSI MSIX Inno Setup / NSIS WinGet Chocolatey Scoop

macOS

Application Bundles DMG / PKG / XIP Signing & Notarization Homebrew

Release Control Planes

dist / cargo-dist GoReleaser JReleaser dotnet-releaser

Packagers & Updaters

cargo-packager Velopack Conveyor Briefcase cx_Freeze electron-builder Electron Forge

Packaging Backends

CPack fpm / nFPM jpackage Swift Bundler

Synthesis

Comparison Platform Gotchas Recommendations

grounding/

README.txt apple-host-evidence-2026-07-13.txt apple-notarization-2026-07-13.html.txt apple-notarization-issues-2026-07-13.html.txt

Nix development on Android

Foundations

Concepts Sparkles baseline

elf-loader.d namespace-probe.d

Execution backends

nix-on-droid / PRoot AVF / Pixel / MediaTek Qualcomm Gunyah Native stores / NNS Alternatives

Evidence and synthesis

Device validation Contributor probes and agent prompt Pixel 7 Pro contributor evidence Source ledger Comparison Recommendations

app-probe.d contributor-probe.d inventory.d

grounding/

device/

pixel7/

avf-artifacts.txt avf-cli.txt avf-features.txt avf-info.txt avf-list.txt avf-permissions.txt identity.txt kernel-config.txt namespace-policy.txt nns-config.txt nns-layout.txt pid-10820.txt pid-15606.txt pid-15612.txt pid-1946.txt pid-2007.txt processes.txt resources.txt security.txt

pad-app-probe.txt pad-avf-info.txt pad-cleanup.txt pad-inventory.txt pad-microdroid.txt pad-permissions.txt phone-app-probe.txt

nix-on-droid/

bootstrap.nix.txt build-config.nix.txt login-inner.nix.txt login.nix.txt networking.nix.txt nix-directory.nix.txt nix.nix.txt proot.nix.txt

sparkles/

AndroidManifest.xml.txt android-spec.md.txt android.md.txt android_app.d.txt session.d.txt

Linux on macOS

Determinate native Linux builder Apple container Apple Containerization nix-darwin linux-builder

Backends

Synthesis

Comparison Sparkles Baseline Recommendations

probe-backends.d sa-resethand.d

TUI Libraries

Catalog

Text Sizing

Comparison Sparkles Baseline Sparkles Proposal Validation

Protocol and Terminals

Kitty Ghostty foot

Libraries

libvaxis OpenTUI Blessed (Python) wcwidth

Applications

presenterm osc66 mdfried

Ratatui (Rust) Ink (JavaScript) Textual (Python) Bubble Tea (Go) Brick (Haskell) Notcurses (C) FTXUI (C++) Cursive (Rust) Mosaic (Kotlin) Nottui (OCaml) libvaxis (Zig) tview (Go) ImTui (C++) Snacks.nvim (Lua) broot (Rust) Comparison Tree-View Case Study Table Row/Column-Span Case Study

Property Trees

Concepts & Vocabulary Comparison (Capstone)

Subjects

Qt Property Browser Godot EditorInspector WinForms PropertyGrid Unreal Details Panel bevy-inspector-egui Unity SerializedProperty Derive-Macro Inspectors (Rust) VS Code Settings Editor react-jsonschema-form Chrome DevTools Object Inspector

Sparkles Baseline

edit-commands.d erased-descent.d erased-subject.d leaf-dispatch.d open-set-descent.d path-addressing.d reflect-descent.d sumtype-variants.d tree-adapter.d type-only-instantiation.d uda-metadata.d

Anchored Overlays

Concepts & Vocabulary Comparison (Capstone) Features People Forget

Web — Headless Behavior & Positioning

Floating UI Radix Primitives Base UI Ariakit Zag.js Headless UI Floating Vue Tippy.js Angular CDK Overlay React Aria

Web Platform

HTML Popover API CSS Anchor Positioning Chromium / Blink WAI-ARIA APG

Native Desktop

Qt Quick Controls Qt Widgets GTK4 WPF WinUI Uno Platform Avalonia Slint Zed / GPUI Dear ImGui

Mobile & Adaptive

Jetpack Compose Flutter Apple (UIKit / AppKit / SwiftUI / TipKit)

Terminal & Cell Grid

Helix Neovim Floating Windows Notcurses nui.nvim nvim-cmp / blink.cmp Ratatui Textual tmux display-popup Turbo Vision Emacs posframe + company

Protocol

Wayland xdg_positioner

Sparkles Baseline Proposal

dismissal-policy.d place-reference.d tooltip-timing.d

UI Layout

Catalog

Constraint Systems

Android ConstraintLayout Auto Layout (Apple)

CSS Layout Specs

CSS Flexbox CSS Grid CSS Normal Flow

Declarative App Frameworks

Flutter (Dart) Jetpack Compose (Kotlin) SwiftUI (Swift)

Desktop GUI Toolkits

GTK 4 (C) Qt Layouts (C++) Swing / MiG Layout (Java) Tk Geometry Managers WPF / XAML (.NET)

Foundational Algorithms

Cassowary (algorithm) TeX / Knuth-Plass

Immediate-Mode Layout

Dear ImGui (C++) egui (Rust)

Renderer-Agnostic Libraries

Clay (C) Kiwi (C++ / Python) Stretch (Rust) Taffy (Rust) Yoga (C++)

Tiling / Structural Layout

i3 / sway xmonad (Haskell)

Window System Integration

winit (Rust) SDL3 (C) GLFW (C) Pointer-shape probe sokol_app.h (C)

Library Deep-Dives

Tier 1 — Windowing Libraries

Tier 2 — Framework Platform Layers

Qt 6 / QPA (C++) GTK4 / GDK (C) Flutter Engine (C++) Chromium Ozone (C++)

Tier 3 — Additional Perspectives

Avalonia (.NET) .NET MAUI Uno Platform (.NET) Slint (Rust) wxWidgets (C++) JUCE (C++) Smithay + libdecor

OS Windowing APIs

Overview

Wayland

Feature demos

Wayland scaffold — a real `xdg-shell` window F01 first pixel & init cost F02 resize correctness F03 modal-loop survival F04 vsync / frame pacing F05 loop wakeup & external fds F06 keyboard & keymap F07 IME / text input F08 DPI / runtime rescale F09 Output enumeration & hotplug F10 Pointer: relative motion, lock & confine F11 Scroll fidelity F12 Cursors F13 CSD & decoration modes F14 Window state & vetoable close F15 Popup with grab F16 Clipboard + drag-and-drop F17 threading probes

app.d c.c dub.sdl

f01-first-pixel/

app.d c.c dub.sdl generate.sh inject.d instrument.d run.sh

app.d c.c dub.sdl generate.sh inject.d instrument.d run.sh

f13-decorations/

libdecor-variant/

app.d c.c dub.sdl generate.sh inject.d instrument.d run.sh

app.d c.c dub.sdl generate.sh inject.d instrument.d run.sh

app.d c.c dub.sdl generate.sh inject.d instrument.d run.sh

X11 scaffold — findings F01 first pixel & init cost F02 resize correctness F03 modal-loop survival F04 vsync / frame pacing (the Present extension) F05 loop wakeup & external fds F06 keyboard & keymap F07 IME / text input (XIM) F08 DPI / runtime rescale (the absence proof) F09 output enumeration & hotplug — findings F10 pointer capture — findings F11 scroll fidelity — findings F12 cursors — findings F14 window state & vetoable close F15 popup with grab F16 clipboard + file drag-and-drop F17 threading probes

X11 / Xlib

Feature demos

app.d c.c dub.sdl

f01-first-pixel/

Win32 scaffold — findings Win32 — F01: first pixel & init cost Win32 — F02: resize correctness F03 modal-loop survival F04 vsync / frame pacing Win32 — F05: loop wakeup & external handles Win32 — F06: keyboard & keymap Win32 — F07: IME / text input Win32 — F08: DPI / runtime rescale Win32 — F09: Output enumeration & hotplug Win32 — F10: Pointer — relative motion, lock & confine Win32 — F11: Scroll fidelity Win32 — F12: Cursors F14 window state & vetoable close F15 popup with grab F16 clipboard + drag-and-drop F17 threading probes

Windows (Win32)

Feature demos

AppKit scaffold — findings F01 first pixel & init cost F02 resize correctness F03 modal-loop survival F04 vsync / frame pacing F05 loop wakeup & external fds F06 keyboard & keymap F07 IME / text input (`NSTextInputClient`) F08 DPI / `backingScaleFactor` F09 Output enumeration & hotplug F10 Pointer capture: lock, confine, relative motion F11 Scroll fidelity F12 Cursors F14 Window state & vetoable close F15 Popup with grab F16 clipboard + drag-and-drop F17 threading probes

macOS (AppKit)

Feature demos

app.d dub.sdl dub.selections.json

f01-first-pixel/

iOS / iPadOS (UIKit) Android (NDK) Cross-Platform Summary

Demo Feature Specs (F01–F17)

F01 First pixel & init cost F02 Resize correctness F03 Modal-loop survival F04 Vsync / frame pacing F05 Loop wakeup & fds F06 Keyboard & keymap F07 IME / text input F08 DPI / runtime rescale F09 Outputs & hotplug F10 Pointer lock & confine F11 Scroll fidelity F12 Cursors F13 CSD & decorations F14 Window state & close F15 Popup with grab F16 Clipboard + DnD F17 Threading probes

Feature Matrix Divergence Map Event Sequences Design Constraints Manual-Run Queue

app.d c.c dub.sdl

Comparison Recommendations Platform Gotchas End-to-end testing

app.d dub.sdl

Synthesis

Vulkan Bindings & Wrappers

Overview Concepts

Thin / Generated Bindings

C++ (Vulkan-Hpp) Rust (ash) Rust (vulkanalia) Zig (vulkan-zig) D (ErupteD) C# (Silk.NET) Java (LWJGL / vulkan4j)

Safety-First Wrappers

Rust (vulkano) Haskell (vulkan) OCaml (Olivine)

Render-Graph / Auto-Sync Layers

Daxa (C++) vuk (C++) Tephra (C++) wgpu (Rust) Granite (C++) NVRHI (C++) blade (Rust) V-EZ (C++)

Thematic & Synthesis

Sync & Validation Comparison

Units of Measure

Whitney's Quantity Structures Buckingham π Free Abelian Group of Dimensions Tensor of Lines Torsors & the Scaling Torus Kennedy's Units of Measure Hart's Multidimensional Analysis Type-System Mechanisms

Foundations (Theory)

Systems

F# Units of Measure uom-plugin (Haskell) dimensional (Haskell) uom (Rust) dimensioned (Rust) mp-units (C++) Boost.Units (C++) Au (C++) D Prior Art Pint (Python) Unitful.jl (Julia) GNAT Dimensions (Ada) Lean/mathlib & Provers Wolfram & MATLAB coulomb (Scala) squants (Scala) unchained (Nim) Swift Measurement measured (Kotlin) UCUM & QUDT

Synthesis

Comparison Prototype Evaluation

quantity-affine-torsor.d quantity-diagnostics.d quantity-erasure.d quantity-kind-tags.d quantity-logarithmic.d quantity-nominal.d quantity-open-basis.d quantity-polymorphism.d quantity-rational-exponents.d quantity-runtime-expected.d quantity-unit-in-type.d quantity-vector-composition.d quantity-zn-graded.d

UI Virtualization

Dear ImGui — list clipper egui — show_rows Gio — layout.List

Immediate mode

Terminal

Ratatui — offsets Textual — the line API

Retained mode

Flutter — slivers GTK 4 — list factories Qt Quick — reuseItems WPF & Avalonia — virtualizing panels VS Code — range diffing Slint — repeaters

Sparkles baseline Comparison

UI backend seam

Synthesis

Overview Concepts Comparison

Cross-target

Slint imtui Mosaic Textual

Terminal / cell

Notcurses Ratatui libvaxis Vty Image Notty

Retained scenes

GTK4 / GSK Flutter engine Qt Quick scene graph WebRender Zed GPUI

Reified command streams

Skia SkPicture Chromium PaintOpBuffer Vello Gloss Picture elm-canvas

Device abstractions

Qt QPaintEngine Cairo & Direct2D Java2D SDL_Renderer Avalonia Piet Racket draw & pict

Capability models

Iced wgpu Monomer Doodle Haskell diagrams OCaml Vg

Geometry & text

egui Pango & HarfBuzz Godot TextServer Parley & Xilem elm-ui Functional images

Font Libraries

Overview Concepts Comparison

C / C++ cores

FreeType HarfBuzz stb_truetype msdfgen Slug

Platform text stacks

Skia Core Text DirectWrite Pango

Discovery & databases

Fontconfig fontdb font-kit

Terminal font stacks

Ghostty crossfont

Rust: parsers & shapers

Fontations ttf-parser rustybuzz Allsorts swash

Rust: layout & rendering

cosmic-text Parley + Fontique fontdue ab_glyph Vello glyphon

Managed: C# & Go

SixLabors.Fonts Typography SharpFont go-text/typesetting x/image/font

Inspector engines: JS & Python

opentype.js fontkit lib-font fontTools

font-scan-timing.d harfbuzz-shape-features.d ligature-cells.d outline-sink-raster.d raster-oracle-diff.d

Autological Artifacts

Concepts Comparison & Synthesis Open Questions

Format Superposition

Cosmopolitan / APE / redbean ZIP Suffix Parasitism Polyglot Craft Boot-Adjacent Hybrids Parser Differentials & LangSec

magic-superposition.d zip-eocd-scan.d

Binary as Database

SELF / selfdb / self-httpd sqlelf Format-to-Query Layers Relational System Surfaces Code as a Database

binfmt-magic-match.d elf-note-buildid.d relocation-join.d sqlite-header-probe.d

Dispatch

binfmt_misc The Dynamic Loader Wasm Component Model

Index Anchoring

Footer-Indexed Formats Range-Request Consumption Debug Info & OOB Indexes

Closure & Deduplication

The Nix Store & Closures Content Addressing & Chunking

Self-Mutation & Substrate

Image-Based Systems SQLite as an App File Format The SQLite VFS Seam

Provenance & Trust

Embedded Provenance Threat Model

Prior Art

Single-Level Store Plan 9 & 9P

analysis.d ansi.d grapheme.d simd_caps.d simd_io.d utf.d utf16_bytes.d utf16_emit.d utf16_simd.d utf8.d utf8_simd.d utf_memory_test.d width.d

notcurses_c.c package.d

allowlist.d boundary_corpus.d config.d corpus.d layer0_segmentation.d layer10_python_wcwidth.d layer11_word.d layer12_sentence.d layer13_line.d layer14_bidi.d layer15_normalization.d layer16_casing.d layer1_width.d layer2_emoji.d layer3_kitty.d layer4_ghostty.d layer5_utf8proc.d layer6_utf8proc_seg.d layer7_icu_seg.d layer8_notcurses.d layer9_rust_uwidth.d oracle.d report.d subprocess.d ucd.d util.d

package.d utf8proc_c.c

dub.sdl dub.selections.json

app.d

dub.sdl dub.selections.json oracles.sdl

gitignore.d glob_walk.d

dub.d

gh.d

git.d

box.d live-tasklist.d prompts.d styled-template.d table.d

error.d help_formatting.d uda.d

ansi_decode.d ansi_model.d

glob.d

draw.d font.d font_discovery.d font_set.d shaping_c.c

bench_json.d driver.d execution.d extract.d model.d perf_group.d skip.d syscalls.d tier0.d

attributes.d discovery.d register.d

tmpfs.d

cells.d html.d html_semantic.d

geometry.d theme.d wrap.d

bench_shim_c.c package.d

2026-08-04-ryzen9-7940hx-x86-64-v4-scalar-round4.json 2026-08-05-ryzen9-7940hx-x86-64-v4-mesh-baseline.json 2026-08-05-ryzen9-7940hx-x86-64-v4-mesh-round1.json 2026-08-05-ryzen9-7940hx-x86-64-v4-scalar-round5.json

asdf_json.d jsoniopipe_json.d mir_ion.d package.d rapidjson_json.d rust_engines.d shim_support.d simdjson_dom.d simdjson_ondemand.d std_json.d wired_inline.d wired_native.d yyjson_json.d

allocator.d data.d fingerprint.d runner.d traits.d twitter.d

tools/

gen-wired-inline.d

dub.sdl dub.selections.json

scan.d

all.nix default.nix examples.nix

flake.nix

libs

/

base

/

tools

/

unicode