sparkles · async-io/

Reference

CLI Key & mouse bindings

hue

Open issues

ui-gallery

Open issues

Libraries

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 Base codecs: design notes

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

fuzzy

Tutorial

How-to guides

Chunked search

Reference

API

Explanation

Admission and ranking

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

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

Specs

Application Packaging

Cell-splitting & width spec Conformance test cases Conformance harness Case-style spec Enums spec float_conv spec

Base

Text

CI

ci-stats specification ci-stats delivery plan

Core-CLI

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

DMD-FMT

M0 Decision Record

DMD-LSP

Overview Feature Requirements DDoc Test Plan Dub-Project Context

Docs (SSG)

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

DQL

Specification

Event Horizon

Specification Delivery Plan Open Issues Benchmarks

Window System Integration

Specification Feature Requirements Delivery Plan Supported Features Open Issues

Fuzzy

Specification Delivery Plan Benchmarks

Hue

Overview Feature Requirements 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

Parsing (proposal)

Design Proposal Delivery Plan

Release

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

Syntax (proposal)

Test Runner

Specification Delivery Plan Open specification issues

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 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

Expressiveness Upgrade

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

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

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

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 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 Readability Evidence Comparison & Synthesis The D Landscape The dmd-lsp Substrate A Proposal: sparkles:dmd-fmt

Fuzzy Matching & Pickers

Matchers

fzf fzy nucleo frizbee telescope-fzf-native

Engines & Picker Hosts

fff snacks.picker Helix × nucleo

Comparison

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)

sample/

cli/

main.go

greeter/

greeter.go greeter_test.go

JS/TS Task Orchestrators

Nx Turborepo Lerna Rush Lage Wireit

sample/

package.json project.json tsconfig.json

cli/

greeter/

package.json project.json tsconfig.json

nx.json package.json tsconfig.base.json

sample/

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

cli/

package.json tsconfig.json

greeter/

package.json tsconfig.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

package.json pnpm-workspace.yaml

utils/

moon.yml package.json tsconfig.json

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

TUI Libraries

Catalog 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

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 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

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 case_style.d cstring.d enums.d errors.d grapheme.d html.d lineindex.d package.d percent.d readers.d scan.d span.d utf.d utf16.d utf8.d width.d wrap.d

notcurses_c.c package.d

allowlist.d config.d corpus.d layer0_segmentation.d layer10_python_wcwidth.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

dub.d

gh.d

git.d

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

error.d help_formatting.d uda.d

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

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

nix/