Pages

Every page of the wiki with its headings. Each heading is a figure with a stable ID; work marks carry their status.

The luv workshop wiki	A workshop, not an authority String figures Work marks Paths into the initial material Engineering the implementation GPU semantics and implementation The little block world The wiki itself
Technical debt that multiplies truths	What this audit counts as debt Ranked cut list 1. The session has several resource ownership truths DONE Give rendering resources one transactional owner 2. McCLIM implements one open command vocabulary four times DONE Make command phases an open protocol 3. The shared shader language is trapped inside the SPIR-V backend DONE Give the shared shader graph its own home 4. The HAL boundary is only half-owned DONE Make the portable HAL boundary tell the whole truth 5. Voxel lighting keeps oracle, experiment, and production live DONE Keep one production light solver 6. Serial umbrella systems conceal useful dependency islands DONE Expose the shader, frontier, and reference islands already earned 7. A high-confidence deletion queue DONE Delete the queue without deleting history A workable order
The little block world and its possible worlds	A game-shaped path through the engine The current proof The screenshot gazetteer names gameplay views What the first extension establishes A checkpoint saves the world description, not its materialization DONE Persist and resume the authored little world Chunk production is an ownership boundary Landmarks from working voxel engines A world is not necessarily its finest materialization Things with identity and values at sites Block kinds, states, and exceptional entities The first animal is an entity, not a field Riding is a focus that moves TODO Let the animals be part of the saved world The player has a body, and the body holds things The phone is a wall terminal you can carry The sequence that stays fun Paths into the design Questions to keep open
The luvcraft showcase gazetteer	The showcase is an atlas with three lanes Pre-noon light on the little world The sky deserves one fixed camera across a whole day Crystal afterglow shows luminous materials A terminal is a place, a pane, and a carried thing Player instruments should be readable in context World-native panes should keep their depth cues Inhabitants need portraits and motion Agent work has four visible surfaces Physics is best shown with causality The birthday world is the authored ensemble shot A world within a world needs its own folio Reference plates make failures legible Every still has a motion companion when time matters DONE Author the pre-noon ridge DONE Open the phone-first gallery DONE Put action, inhabitants, and authored surfaces in the gallery
A terminal in the little world	A terminal is a world-native interactive surface The McCLIM gadget leaves a useful interaction seam Modal focus is a player relationship Ghostty owns terminal semantics, not the surrounding application PTY traffic has one serialized owner Render state is the frame boundary Viewport cells form a finite domain Cell presentation is a derived materialization Draw populations are narrow columnar projections DONE The derived 2 by 2 block wall exposed the wrong abstraction Adjacent terminal-material blocks define one unified display surface The terminal grid remains authoritative through Slug NEXT Bridge styled Ghostty render-state rows into the block wall DONE Attach a live PTY independently of the render boundary
Field notes on four agent harnesses	Four earlier harnesses, read for what luv can borrow Froth: a tool result is a tree of blocks, not a string Froth: blobs plus a recursive pager teach the model to stop piping into head Froth: context is assembled for the cache, and the prompt is a page you can open Froth: live evaluation as the agent's native interface, with a detachable clock Froth: parallel tools with a prepare/commit split, and control by button rather than allowlist Froth: one span primitive, one firehose, and a patch model over every provider stream Sheaf: six characters address anything, resolved through the graph Sheaf: an append-only quad log with a working set, and doctrine about how to read it Sheaf: typed tool results with two renderings, and reading collapsed by default Sheaf: retrieval variants, persisted context, and one URL in four representations Nxt: one coroutine runtime under I/O, tools, and the terminal Nxt: hope, or the value or the work to get it Nxt: a hung agent is a question you can ask the process Nxt: traces as Arrow, rendered as cassettes through XSLT Nxt: a HUD pinned under scrolling output, drawn from typed diffs Nxt: tools as concepts, failures as values, streams parsed as grammars Swash: a shell command is a session with a host, and the host outlives you Swash: run returns in three seconds or a screenful, and says how to follow Swash: TTY sessions with a screen you can read as text Swash: contexts as journal facts, and the log projected as RDF What the four agree on DONE A luv agent surface would inherit these seams
Autolith: a primer on an agent that is a Lisp image	Autolith is a terminal agent that lives inside the SBCL image it can edit Four processes and one package The prompt line is a REPL; prose is sugar for `(prompt ...)`The system prompt is one `format` template rebuilt for every request Request-local context: contributors, classes, a token budget, and a trailing developer message Tools are a CLOS registry with closed JSON schemas and exactly one bounded result per call On the wire the conversation is Responses items, and tool calls run one at a time Resources: revision-gated reads with opaque aliases and explicit elisions Shell: classify, sandbox, wait ten seconds, then hand off the same job `lisp.`: named, heap-isolated SBCL REPLs with saved images and pinned source `self.`: evaluate, redefine, and set the running image with a journal and an undo Restarts are a tool argument `self.commit`: private image commits, a clean replay probe, forked generations, and recovery Children, jobs, and `yield.submit`; skills and MCP as request-local context Durable state is readable forms: append-only conversations, memories, agenda, papercuts, vault Where Autolith agrees with the other four, and where it does not What luv could take from Autolith
An agent in the little world	The agent surface is a command table, a view, and a handle space A tool is a CLIM command whose arguments are presentation types A tool result is a presentation, and the model reads it under a view Handles are presentation history The cassette is one presentation file Draw and print: live cards and committed records A shell scope is a session object with a screen and an observation The agent has a body The turn runs beside the canvas, and commands cross by mailbox A proposal is a temporary possible world A glance is an image and the small truth that frames it IDEA Authored edits form sparse swaths, not another terrain field IDEA Terrain summits are born at peaks and merge at saddles DONE Give embodied agents a truthful third-person glance DONE Give construction tools a visible possible world DONE Wire three commands into an agent and draw their cassettes The gnome is an agent occupying a cell, not a block DONE Discrete destinations, continuously embodied NEXT Parameterized M-x prompts through presentation types
McCLIM surfaces in the world	The first McCLIM surfaces reached the world as rasters A terminal is sharp at any distance because its glyphs are geometry The PDF sheet made the difference measurable A backing texture is a fallback, not a surface DONE Draw McCLIM text as world geometry DONE Replay the complete McCLIM stream at its destination
The shared Lisp application workbench	The workbench belongs to the Lisp application One quiet line is the default global surface M-x and the metabar reveal one application vocabulary Application panels are retained GPU commands, not pane textures Captures reserve the evidence they own Live replacement and stopping publish whole outcomes The language-agent harness is not the gnome DONE Extract the application workbench beneath both games
Field notes on Box3D's architecture	Scope and method An id is an index, a generation, and a world Stable sparse structs point into moving dense arrays Memory is four allocators, none of them general Solver sets sort the world by simulation temperature The Soft Step solver is a small loop with careful phases Graph coloring is what buys parallelism and SIMD at once Islands are persistent, merged eagerly, split lazily Contacts are a state machine that begins at AABB overlap Determinism is a property of the whole design, not a mode Events are buffered facts, polled after the step The math is chosen for determinism and locality, not generality What "extensive SIMD" concretely means here What Box3D gives luv to think with
Domains, bundles, and materialized worlds	The apparent CLOS–SoA contradiction Dispatch on descriptions; compute on domains Identity does not come from being addressable What Moppe's Bundle demonstrates A finite domain is more than dimensions Bundle means a checked materialization Logical fields and physical representations Columnar layout, materialization, and policy are separate Row meaning binds once; raw lanes run DONE Extract a quantity-aware columnar buffer DONE Bind fixed columnar materializations to finite domains DONE Percolate domain-bound representations through voxel storage NEXT Give dynamic columnar populations explicit compaction A columnar buffer is not one hot sequence Chunk boundaries need an environment Level of detail changes the schema as well as the spacing Products follow ownership and lifecycle The first Lisp atelier should stay ordinary What this page does not decide
Field notes on measures: dim-numbers in 1992 Common Lisp	What this page studies The prime-ratio encoding of dimension Runtime objects, reader syntax, and the environment argument What the package never had
Field notes on mp-units: abstractions beyond dimension	What this page studies Three abstractions: point, absolute, delta Character: two orthogonal axes, and why the type cannot tell you Logarithmic quantities as affine structure Specifiers on the spec: one declaration site for meaning IDEA Exposure as a logarithmic level in the sky model
The GPU API and its backend proofs	Contract, mechanism, and open proof stay distinct The portable GPU API is a tested seam, not a complete contract WebGPU is a landmark, not luv's specification GPU work crosses several timelines Inspectable commands are protocol inputs, not a retained command IR Recorded and submitted work must own their dependencies Each backend has a completion frontier of a different extent Destroy is logically immediate and physically conditional Explicit destruction is the discipline; collection is only a safety net Vulkan frame slots are pacing clients of the frontier Usage names hazards; each backend still owns the synchronization proof Host access is still a deliberately narrow path The remaining questions are local and testable
Seeing a frame on the CPU	Frame time is several clocks DONE Trace one real frame with nested CPU zones Ambient telemetry is a bounded semantic skeleton The first ambient-zone census DONE Convert the outer runtime boundaries DONE Stream one chunk window under measurement The game names usage; backends realize hazards TODO Reuse Metal frame submission resources TODO Separate drawable pacing from encoding distributions
Mathematical shaders as live Lisp objects	Source mathematics and machine form are different views The block pipeline is the first real client Methods are live definition identity Expressions, declarations, and bindings are objects Shader functions are graphs; source abstractions are syntax One source language can have target-owned effects DONE Share function application across arithmetic and shader realizations Semantic maps are not merely matrix-shaped values McCLIM presents the relationship What this does not decide
Slug: Bézier outlines in the pixel shader	The 2026 release removes two different restrictions A pixel asks the outline for its winding Root eligibility, not a floating-point range test, supplies robustness Coverage turns intersections into antialiasing Bands make exact curves affordable The 2026 reference is not the 2017 sample Dynamic dilation is a rasterization guarantee DONE The reference's shape, with its constants as knobs DONE One fixed contour proves luv's pixel-stage mathematics The fixed proof delineates the first milestone Full Slug is a structured fold over indexed outline data McCLIM already exposes the TrueType contour boundary DONE Teach the shared language Slug's structured band fold DONE Pack arbitrary quadratic contours into Slug bands HarfBuzz places a run; Slug draws indexed outlines DONE Shape and draw a HarfBuzz text run through Slug DONE Put a shaped run into the moving world DONE Cache shaping and device glyph outlines DONE Pack one atlas and issue one instanced text draw DONE Select spatial bands and scale coverage from fragment derivatives DONE One distance function draws the roundrect family analytically NEXT Compare Slug coverage at glyph edges
The native Metal 4 backend	The seams now meet in one Metal 4 draw A native Metal backend now stands beside Vulkan Metal 4's explicit model matches the Vulkan layer Argument tables realize semantic binding groups SDL remains the platform shell The typed shader specification is already the shared IR Target-specific lowering stays open and inspectable Generated MSL remains a view of semantic objects The Metal 4 compiler belongs to the live backend The second backend tests apparently portable names DONE Present a Metal clear through the existing SDL canvas The first live pipeline is the backend threshold DONE Lower one mathematical shader directly to MSL DONE Join the proofs in one live Metal pipeline DONE Retire replaced Metal resources without a frontier wait
The Moppe legacy: lighting, post, and atmosphere worth transplanting	Moppe is evidence, a tuning library, and a legacy The post stack reveals what finished-looking means Sun shafts are the highest-glamour transplant common.h is a library of judgment calls Sky, temporal reconstruction, and mesh shaders bound the proof DONE Transplant the post stack onto the HDR path IDEA March the shadow map for shafts and compare against the screen sweep
Objective-C as a foreign object system	Objective-C interop is a reusable substrate Objective-C is a foreign object system, not a wrapper list Declarations generate typed messages The hybrid boundary is an explicit escape hatch DONE Send one declared Objective-C message DONE Turn Objective-C exceptions into Lisp conditions DONE Make Objective-C exception catching dynamically selectable DONE Resolve the Objective-C dispatch entry once
Physics data and SIMD execution	A seam, not a specification The first executable seam Bodies, contacts, and constraints are domains of their own The sparse–dense split is the row/column distinction with a forwarding address Select the phase once, then run closed loops The smallest solver worth building DONE The smallest solver was built: spheres, coloured contacts, four-wide lanes The step as built The voxel grid is the static tree, and the overshoot rule keeps seams smooth Colours are the lanes: the constraint buffer is written in colour order Bitwise agreement is the wide kernel's contract Sleep is relocation, and boxes and edits wake What a step costs Allocation: what the profile taught, and how not to be misled by it Things with weight, as the player meets them Open after the first pile The block world is the static tree Sleep is residency, and it prices determinism Questions to keep open
Quantities, dimensions, and interpretation	One number participates in several kinds of meaning Dimension describes lawful physical algebra A specification carries semantic identity A unit is a conversion, not the meaning Dimension one still has semantic units Points are not differences Three affine characters: point, absolute, difference Constraints are marks the author places, not costs the compiler hides DONE Generalize affine-p to a three-valued character DONE Declare luvcraft's amounts absolute and non-negative Tensor order is independent of dimension Representation vectors can carry semantic products Calculation derives; interpretation names Bundles keep meaning outside the lanes Declarations keep representation and quantity parallel DONE Declare quantities on Lisp storage DONE Check storage declarations against Lisp arithmetic DONE Audit quantity-bearing Lisp storage DONE Describe the repeated block-mesh vertex product DONE Put contextual light-removal meaning on its queue DONE Check the packed frame product across CPU and shader DONE Declare the fullscreen and overlay vertex products DONE Keep quantity contracts at owned function boundaries DONE Review the exercised quantity architecture A possible Lisp vocabulary Arithmetic definitions outlive execution backends DONE Give luvcraft quantities backend-neutral ownership DONE Move portable operator semantics below shaders DONE Extract a compiled arithmetic frontend DONE Compile checked arithmetic to Lisp DONE Share one production computation between CPU and GPU IDEA Lower checked domains to native SIMD kernels DONE Prove semantic arithmetic in the shadow graph DONE Give GPU components first-class quantity meaning DONE Make numerical unit conversion explicit DONE Constrain units to semantic quantity kinds Semantic representation boundaries point both ways Maps carry spaces; rows carry representation Where luv's semantic arithmetic goes beyond its sources DONE Carry semantic units through the vertex and camera ABI DONE Introduce the world-to-light sampling map DONE Separate homogeneous projection from shadow sampling DONE Give the remaining crosshair colour ABI meaning An initial block-world quantity map Rendering is radiometry: PBR as the forcing use case The frame uniform was an unlabeled quantity ledger Dimensioned types in the shader DSL Types with structure; judgments in parallel One arithmetic medium, many clients DONE Quantity-carrying shader types DONE Give the sRGB atlas seam explicit transfer meaning TODO Structural shader-type identity Questions and executable claims
Field notes on sb-simd	Scope and method The library is a database that generates itself The generic package promises scalars; availability is a runtime property Before SBCL 2.6.7, arm64 was absent in three instructive ways The story changed in SBCL 2.6.7 Luv now treats SIMD availability as a project invariant What a kernel looks like Evaluation order is fixed because reproducibility is a goal Two sharp edges met in 2.6.7's NEON port What sb-simd teaches now that it can run here
Sky, atmosphere, and voxel light for the little block world	Status: implementation notes and remaining plan What the critique changed What exists today: verified touch points The rendering model Phase 0: give the shader language the mathematics this work needs Phase 1: a real sky driven by a small Lisp clock Phase 2: make voxel light an explicit derived field Lighting semantics and boundaries The solver: explicit reference truth plus one runtime implementation Meshing carries raw light, not an art-directed bake Meshing also carries what a fragment cannot see A round-over is an arc, not a leaning plane The atlas paints relief as well as colour No two faces are the same card A roughness the relief already knew Phase 3: one crystal proves emission and edit propagation Phase 4: HDR scene colour, tone mapping, and restrained bloom What the presentation stack became The screen centre is the focus plane A sky worth tone mapping The sky became an atmosphere A cloud deck is a plane both halves of the renderer can find Later: real-time shadows, not baked animated sunlight Verification and observability Playable implementation sequence Light work marks DONE First CPU voxel-light proof DONE Player-placeable crystal TODO Measure light-to-mesh latency DONE Shadow-ready shader math substrate DONE Shader source abstractions for reusable shadow expressions DONE Shadow-map producer pass and light projection resources DONE Sample the shadow map in the block material DONE First isolated visual evidence standard for shadow changes DONE Shadow credibility in representative play DONE Tool and live-definition hardening after the shadow review DONE Moving-sun shadow shape and temporal evidence DONE Temporal derivatives and continuously filtered shadow decisions DONE Receiver-plane shadow evidence and self-shadow stability DONE The shimmer that only noon could show DONE The shadow lattice turned about the world origin DONE HDR crystal bloom DONE Materials and sky taken toward physical shading TODO Verify resized presentation in a live capture Decisions now made; questions left to evidence
Frontiers, memoization, and materialized worlds	Materialized worlds deserve a frontier language Frontier is an operational pattern, not merely a queue Five roles make the engine legible Reservation precedes adjacency; commitment follows naming Memoization is identity preservation, not just a visited set Cheney collection is breadth-first materialization BFS and A* differ mainly at admission and order Bucket updates make duplicate work a policy question The repository became clearer by becoming less grand Minecraft contains several families of frontier work Discover, relax, and invalidate are three different dynamics Terminal walls supply a second, deliberately simpler client Voxel efficiency requires translating the algebra, not its objects A frontier language composes meaning with specialized execution Frontier programs are compiled sparse kernels The kernel language names fields, constants, predicates, and laws Families own admission, commit, and priority Bindings close a program over storage Terminal walls are the second compiled client Invalidation is a family with a companion frontier The shared questions are now concrete Tracy aligns temporal structure with semantic work Fast generic functions can specialize a sealed semantic domain DONE Remove the per-admission type construction DONE Begin frontier light beside the oracle DONE Compile the monotone light kernel to scalar Lisp DONE Compile the sky seeds as boundary transfers DONE Give frontier light its own invalidation program
Voxel fields and chunk windows	The seam is shared spatial meaning, not shared ownership Mathematical ideas should improve the questions, not burden the names Addressing and metric are two sides of voxel space Vec3 is a representation, not one spatial meaning A chunk domain owns local traversal, not world truth Coordinate values can be stack-temporary A chunk window continues a local domain The current program already contains four windows Field identity, value meaning, and representation are independent Domain, materialization, and revision have different identities Field kernels bridge domains to semantic arithmetic Lighting should use a checked local law, not become an arithmetic graph The fixed-point algebra should wait for a second client Chunk hierarchy and level of detail are related but not identical The Lisp shape is semantic objects around dense data A staged concretization DONE Make chunk traversal one owned vocabulary DONE Give dense traversal coordinate values DONE Bundle continuous spatial triples DONE Name the chunk-window protocol DONE Keep rejected neighbors at dynamic extent DONE Pack the lighting worklist, then test level scheduling DONE Pay checked adjacency cost once per visited site DONE Attach existing voxel field definitions
Vocabularies as finite domains	A vocabulary is a finite domain The tile that two branches both called thirty An index is closed by the vocabulary that interprets it Value changes and shape changes cost differently Vocabulary tables and population tables keep different time A film is not a material Baked coordinates freeze the atlas A save is a vocabulary and its columns DONE Name the atlas tiles and give the domain an owner DONE Compute atlas coordinates in the shader DONE The mesher gathers first and then runs one dense loop DONE The world owns one block vocabulary TODO Make films block entities so the material vocabulary closes IDEA A save is a vocabulary table and its columns
LUFT: packed sites, chains, and the atelier	A site is a lattice anchor, an extent mask, and a polarity A block world is a 3-chain and its surface is a boundary The GPU reads signed sites directly Storage buffers and bit fields enter the shader language The mesh-shader experiment found a budget, then ended Vertex shaders are the one terrain path Fillets and bevels belong to edge and vertex sites Small planar facets soften convex and concave creases The miter family portrait keeps the awkward stars in context Rounding is the half-level set of the smoothed occupancy The same field read as a drawing A world knows what it is cut from How a cell says which stock it is An hour is a set of the light knobs An architecture of arches, discs, and corbels Turf catches where the ground is flat Five pieces and a sheet of stocks The lattice need not be square A lattice that wanders, modulated by what the cells are made of A chamfer belongs to the crease, not to either face What the watertightness test caught The distance codomain was tried, and argued against itself Every term needed a fence, and the fences were the finding Clay: the golf ball, a field that is its own definition The studio: a world of stars under the same cameras DONE The atelier itself is a McCLIM application DONE Pointing reveals a site's topology NEXT Grow the workbench and the game as one command vocabulary DONE Cell edits are linear boundary updates IDEA Compact surviving faces only when measurement earns another path IDEA Draw the torus, not only its fundamental domain
The bevel junction is an open problem	The sharp bevel is a global map from sites to points A miter arc carries the band; it does not decorate a singularity The minimal-arc transition crossed the architecture halfway Structural proofs implemented the rejected specification faithfully The sharp baseline remains inspectable at the problem scale The sharp junction with its construction edges The same sharp junction without diagnostic ink A larger local object may preserve the old system's regularity DONE Find a regular site-owned account of mixed bevel junctions
The beveled surface is a sum over sites	Every vertex is an offset-line intersection One tile counts every junction by its turning The skirt is the atomic bevel operation Three plane families and one width dial Turn, don't die: sharp miters leave a (3,1,1) fingerprint Blender's Arc bevel is an executable oracle The Arc oracle has a manifold domain Faces, bands, and fans: three instance streams Bands and fans carry material semantics Authored support geometry protects mixed bevel transitions Coplanar merging is exact level of detail NEXT Implement the site-stream LUFT renderer backbone TODO Derive the regular vertex-star table and choose singular topology
Temporal reconstruction in the Luft atelier	TAA reconstructs samples; it is not a blur One frozen view defines one frame The frame graph has three passes and one ping-pong edge Motion points from the current sample to its old address Resolve admits old colour through a shaped neighbourhood History is a semantic cache Frame resources are one extent-sized ownership cohort The shader language was ready; both HALs needed MRT Two backend resolves share one semantic boundary DONE MetalFX resolves Luft's temporal inputs DONE First Vulkan temporal resolve What the first resolve deliberately leaves open TODO Make the Vulkan disocclusion test depth-aware
The wiki as a static site	What this page is Why ASDF, and how the wiki slots into it Capture recipes are source; captured media is a cache DONE Make wiki media executable without committing it DONE Publish generated media out of band IDEA Give historical captures an annex retention policy The Org subset the reader understands Spinneret as the HTML layer DONE Render the wiki as a static site from ASDF The wiki from a shell: scripts/wiki DONE Serve the site from GitHub Pages A fluid dual system: code contributes to the wiki The model a McCLIM browser wants Code views: a dexp renderer for Common Lisp Layouts are objects chosen by operator and role DONE Boxes hug their widest row DONE Clauses as tables: cond, case, typecase, handler-case DONE The stylesheet as Lisp definitions TODO Pairs, loop tables, and layouts from arglists alone Reading source without loading it: Eclector Dexp on McCLIM Browsing the whole source from the wiki DONE Browse the source as dexp pages DONE The site shows code references to figures DONE Read luv sources with Eclector into a definition index DONE The dexp HTML renderer TODO A wiki browser frame in mcluv WAIT A WIKI package of figure symbols IDEA Structural associations through the MOP IDEA Source-anchored file links