summaryrefslogtreecommitdiff
Commit message (Collapse)AuthorAge
* gpu: a uniform block over 4096 bytes fails to compileGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | SDL_GPU's Vulkan backend binds 4 KiB of a uniform block (its descriptors' range, MAX_UBO_SECTION_SIZE in SDL_gpu_vulkan.c) and a larger block was cut off without a word, the rest of it read as nothing: examples/live met it with its two tapes in one block. glsl.assertStd140, which `gpu.uniform` and the GLSL layouts of a `.uniform` type both run, now refuses a block past `max_uniform_block` (4096) at compile time, the error naming the type, its size and the storage buffer to use instead. The README says so where it says std140 is checked. Test: a 4096-byte block passes (glsl.zig); a 4112-byte one fails to compile with the message, checked by hand (there is no harness for compile errors). zig build test: 186 of 186 steps, 148 of 148 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: square units, x and y from the centre in half the heightGabriel Schneider2 days
| | | | | | | | | | | | | | | | | picture.frag gives the tape x and y in half the target's height, 0 at its centre and y up (`y` -1 to 1, `x` -1.78 to 1.78 on 16:9), so a circle is round on any window, half resolution included. Lang.builtins and the README's table say so; the README's program draws its ring about the centre (`r = sqrt(x * x + y * y)`, the ring's radius and width doubled into the new unit). Test: test/live.script replaces the text (`%`, `c`) with a disc of radius 0.5, `step(x * x + y * y, 0.25)`, and reads its edge 180 pixels from the centre across and up: white at 170, black at 190, each way. zig build test: 85 of 85 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: drag a number, the program following as it movesGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | The left button pressed on a number token (the grammar's `number` node at the byte under the pointer, found with the module's parse) starts a drag kept in State: the literal's bytes, the value, its precision. Each pointer move rewrites the literal through the editor's `replace`: a step for every 4 pixels right of where it was pressed (left, down), the step from the literal's own precision (`220` by ones, `0.25` by hundredths), printed with as many decimals. The first rewrite is a step to undo and the rest join it, so one `u` takes the whole drag back. The text changes, so the program is compiled and heard as it moves. A literal with an exponent is not dragged (marked ponytail). `update` finds the byte under the pointer as `code` lays the text out: a character is 10 by 22 pixels, measured once (the code face at 1.25, natively: ten M are 100) and now a constant both use, where `code` asked the host each frame. Test: test/live.script presses 220, drags 40 pixels right (230), back to 12 left of the press (217), lets go and undoes the drag in one step (220). zig build test: 85 of 85 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: hear this, the expression a node walk leaves the selection onGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | After Alt-o, Alt-i, Alt-n or Alt-p (helix's node walks, run in the editor on the module's parse) the primary range is read back and the text compiled again with it as a probe: Lang.compile takes the bytes of a selection and compiles the smallest expression holding them into a third tape, `Program.probe`. The compiler learns each expression's bytes as it parses (`spanned`: a number, a name used, a call, parentheses, a unary minus, each binary operation, a whole line), keeping the smallest that holds the probe: no table of spans. A name used is the line that defines it, so a walk onto `kick` hears kick. State keeps the probe's tape (`probe`, empty when there is none). While it is set, `draw` hears it as `out` (through the crossfade, as any change) and sees it as the picture, grey unless it is a colour. Any other key empties it, so Escape or an edit goes back to the program. It is in State, so a replay probes where the session did. Test: Lang.zig, a probe on an argument, a number, a cursor on one of its digits, a name used, a line's name, a selection Alt-o grew to, and between two lines (none); test/live.script, Alt-o twice from the 2 of 220 (`220`, then `tau * 220`), then Escape. Lang.compile takes the probe as a second argument; the other calls pass null. zig build test: 85 of 85 steps, 8 of 8 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* script: a key carries the modifiers `hold` has down, as a window's doesGabriel Schneider2 days
| | | | | | | | | | | | | A window's key event carries the modifiers held as it happened in its `value` (Host.zig, `modifiers(event.key.mod)`), and a sketch reads chords from there (examples/live: Alt-o, helix's node walk). A script's `key` (and a 9P ctl's `input key`) left `value` 0, so `hold left_alt` then `key o` was a plain o to the sketch: the chord could not be scripted. `key` now carries what `hold` has down, as `click` and the other pointer verbs already did in their `flags`. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the language's grammar, its colours and a new line's indentGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | grammar/grammar.js is the language as src/Lang.zig parses it, for tree-sitter (24 lines): lines of `name = expression` parted by newlines, `+ -` below `* /` below unary `-`, calls, parentheses, numbers (Lang's digits, point and `e`), names, `#` comments as extras. `tree-sitter generate` (tree-sitter 0.26.9; ABI 14, the CLI's without a tree-sitter.json) wrote grammar/src/parser.c (918 lines) and its tree_sitter/ headers, committed: the build compiles them into the sketch as a static library and never runs the generator. The `Language` is handed to the editor at run time (`tree_sitter_live`, queries/highlights.scm and queries/indents.scm embedded). The parse is a module's `Syntax`, kept between calls so Alt-i goes back the way Alt-o came, handed to every key, forgotten at a jump (in `draw`, `in.jumped`) and started again by a reload (the tree a reload leaves is leaked: marked ponytail). `code` colours each run of bytes by `Syntax.colors` in pardes's own theme (orchard, the first): a defined name as a keyword, a called builtin as a string, numbers and comments as theirs, the rest in the theme's ink. indents.scm gives a new line no indent outside an open call or parenthesis: pardes's plain indent is a level more after `)`, so every line of this language that ends in a call pushed the next one in. The library now reads a handed-in language's indent query (pardes, its own change). Test: test/grammar.zig parses with the grammar and compiles with Lang.zig 22 texts: the survey's program and two others both take; eleven broken lines both refuse (an unclosed or extra parenthesis, a missing operand or `=`, two numbers, `1.2.3`, a stray `$`); eight both parse but only Lang.zig refuses, as only it knows names, builtins, arities and where a colour may stand (a name used before it is defined or defined twice, a builtin redefined or called with too few arguments, an unknown call, a colour outside the color line, a name called). Lang.zig's survey is public for it. zig build test: 85 of 85 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the editor's text drawn, its ranges, caret and modeGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | One function, `code`, draws what the editor holds over the picture on a dark band: its lines, every range under its bytes (the primary stronger than the rest), a caret at each range's head that says the mode (a block in normal and select mode, a bar in insert mode, the primary's brighter), and the mode's name (NOR, INS, SEL) in the corner before the replay's state and the time; the problem as before, a red mark under its byte and its words under the text. One face at one size, so a byte of this ASCII language is a column of a fixed advance: marked ponytail as the place sketchbook's paragraph call (spans, any byte's place) takes. zig build test: 81 of 81 steps, 6 of 6 tests (test/live.script's screenshots compare the picture, and the sought moment's code band with the live one's). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: pardes's editor in State, typed with helix's keysGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The plain buffer of part 1 gives way to pardes's text pane as a library (`pardes-editor`, src/lib_editor.zig there): `Editor(.{ .text = 4096, .undo = 16 KiB, .registers = 1024, .selections = 64 })`, a value of plain data, 39,264 bytes of a State of 43,480. The package takes pardes by path (`../../../02-pardes-code`, the checkout beside sketchbook's) with `.editor = true` and its smallest tree-sitter set; sketchbook is spelled `../../../sketchbook` as pardes spells it, since a package is told by its path's spelling and sketchbook's build.zig cannot be two modules. `update` turns events into keys: printables from `text` events only, specials (Escape, Return, Backspace, Tab, arrows, Home, End, pages, Delete) and ctrl or alt chords (helix's `A-I` an upper-case letter) from `key_down`, a chord's letter dropped if it also comes as text. Each call into the editor thaws the value into a static 128 KiB buffer reset for the call (`update` may not allocate from the host; a key at 4 KiB of text took 29 KiB of it). The text is compiled when the editor's `revision` moves. Measured (a scratch bench through `update`, the survey's program, 646 bytes, a key typed into its middle, 400 times): a typed key, edit and compile, 59.5 us best and 78.8 mean in Debug, 7.4 and 7.8 in ReleaseFast; a motion 6.4 and 0.3. The package's cold `zig build lib` went from 3.1 s to 6.6 s, its first build under `--watch -fincremental` from 4.0 to 5.9 s, and an edit of main.zig rebuilt under it from 0.062-0.067 s to 0.067-0.092 s. Test: test/live.script types through helix now (`i`, the text, Escape, `gl`, `h`, `rx` for the edit, `l` `d` to break the line, `u` to mend it) and still replays to equal text, tapes and screenshots, its seeks moved to the marks' new times. zig build test: 81 of 81 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the README, the language on one pageGabriel Schneider2 days
| | | | | | | | | | | | | | examples/live/README.md: what the sketch is, how to run it (keys, the console's replay verbs, capture, crossfade, the test and probe steps), the language (its grammar and every builtin a line, from Lang.builtins), the capacities, what it cannot say (no state between samples or frames: no filters, feedback or reverb; the price of computing each sample alone on the GPU and of exact replays) and how it works, with the probe's numbers. Its example program parses (out 22 instructions, color 38). The sketchbook README lists the example. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the scripted proof, a session played back and soughtGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | test/live.script now ends with the run's own session replayed: `play session 0` from its start, then `seek` to the two moments marked as they happened (the gradient just typed, and the end after an edit, a broken line and its mend). At each, the State equals the mark leaf by leaf (`expect-snapshot`: the text, both tapes, the problem, the time), and at the first the screenshot equals the live one over the text and the picture (0,0 1000x600, without the scope and the status line). `stop` then goes on live from that moment: the typed program, before its edit. What a script could not do: a `record` clip ends at the first mark (Console.zig's `save` stops it), so the clip cannot be marked while it is made: the session is replayed instead. A mark is State before its frame's tick, so its time is the printed time less a frame, and `seek MS` lands on the last frame at or before MS: the script seeks 5 ms past each mark's time (272 and 488). The sound at a jump: `want` counted the queue the clear is about to drop, so a seek starved the device for a frame; now it counts from empty. And the block after a jump crosses from the old tape at where the device was (the clock less what was queued) to the tape at the new time (Synth.old_start). Not measured: a capture records every block made, including the tail the jump drops, so it cannot show what was heard across a seek. zig build test: 68 of 68 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the sound, the out tape on the GPU per sampleGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | `pub const audio_pull = 256`; each frame `draw` runs synth.comp over as many samples as keep the host's lead queued (`in.lead -| queued`, 8192 at most) and streams the block with f.audioBuffer, as spheres does. Time is a sample clock in Session: set from State's time at every jump (a seek, a step, a replay's start; the queue is dropped then, so the jump is heard at once), and free-running otherwise, so a paused replay keeps sounding its moment. When the out tape differs from the one the last block played, the block crosses from the old tape to the new over its length (`set crossfade false` turns that off, to hear what it saves). The blocks are read back for the scope (an oscilloscope and a spectrum along the bottom) and, after the console's `capture`, appended to the sketch's capture.f32 beside its save. The status line shows the lead. The tapes reach synth.comp in a storage buffer, uploaded per block: two tapes are 4 KiB, and SDL_GPU's Vulkan backend binds a uniform block 4 KiB at a time (MAX_UBO_SECTION_SIZE), so a 4128-byte Synth block read its count as 0 past the cut and the kernel wrote nothing, silently: the probe's first synth numbers timed that. Measured again (RTX 3050, Debug host, two runs): every synth dispatch 0.08-0.14 ms, 60 or 128 instructions, 256 or 1024 samples, fading or not, the empty pass's cost alone; the 4 KiB upload 0.07-0.08. Measured on SDL's dummy driver (nothing audible) from captures: out = 0.3 * sin(t * tau * 220): peak 0.3000, RMS 0.2121, fundamental 220.000 Hz; edited to 330 in one keystroke, 330.000 Hz. The largest sample-to-sample step across the edit: 0.0131 with the crossfade (a 330 Hz sine's own steepest step is 0.0130), 0.3725 without; into the first sound, 0.0011 and 0.2967. The survey's program: peak 0.50, RMS 0.16, its bass at 55.0 Hz. Test: live.script also expects the stream to receive the GPU's blocks, and compares screenshots above the scope. zig build test: 68 of 68 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the picture, typed over itselfGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | The sketch: State holds the text (a plain 4 KiB buffer, typed characters appended, backspace deleting the last, return a newline: marked ponytail, the place pardes's editor takes in part 2), the last good out and color tapes, the problem and the time, summed from recorded ticks. `update` compiles the text at every keystroke; a program that parses replaces the tapes and clears the problem, one that does not sets the problem and changes nothing else, so the last good picture stays. `draw` runs picture.frag over the color tape into an image the size of the canvas, 1280x720, or half of it when the tape is longer than 64 instructions (the probe: 128 took 2.7 ms at full size, 0.85 at half), and scales it up. The text is drawn over it on a dark band with the library's text calls (the code face at 1.25, a column a fixed advance), the caret at the end, the problem as a red mark under its byte and its words under the text, and live/recording/replay/paused with the time in a corner. Test: test/live.script, the start of the scripted proof: a tone typed (its eight instructions asserted), a gradient (hsv over x and y, four), an edit (y to x: three, the picture different), a broken line (the problem at byte 52, the tape and the picture the same) and its mend. zig build test: 56 of 56 steps, 6 of 6 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the language, text in, a tape and a problem outGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Lang.compile reads lines of `name = expression` over t, x and y (+ - * /, unary minus, parentheses, numbers, # comments) and returns either a Program, the out and color tapes, or a Problem: a byte of the text and words. The builtins are one table, `builtins` (call, op, arity, value, doc): the survey's sin, cos, exp, log, pow, sqrt, abs, floor, fract, min, max, clamp, mix, step, smoothstep, atan2, noise, saw, sqr, tri, seq, hsv, rgb, tau and pi, and the inputs t, x, y. A name is defined once, before it is used; builtins cannot be renamed; hsv and rgb are colours, so only the whole color line can be one. Each tape is emitted from its line's root, depth first, each term once, so it holds only what the line reaches; t, x and y are a term each however often named, and a negative number is a number. seq's values go in registers side by side: as emitted when they are fresh numbers, else copied. noise's missing arguments are 0. Nothing is allocated: the compiler is a struct on the stack, 512 terms, 128 names, 32 levels of nesting, 17 arguments (seq's 16 values), 128 instructions a tape, about 28 KiB in all; past any of them is a problem in words ("the out line needs more than 128 instructions", at the line). vm.glsl's smoothstep is written out: GLSL leaves lo > hi undefined, and the survey's ring is smoothstep(0.03, 0, ...). Tests: a tone instruction by instruction; the survey's 20-line program (out 54 instructions, color 46, neither holding the other's terms, every operand an earlier register); every builtin; precedence, comments and numbers; 24 problems, each with its byte and words; each capacity, met and passed. zig build test: 6 of 6. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* examples/live: the interpreter of a tape, and its probeGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Demo 1's route: a program becomes a flat tape of at most 128 instructions (src/Lang.zig: the ops, the instruction, the tape and the two uniform blocks that carry it; build.zig writes Lang.Op out as ops.glsl, so the op numbers have one definition), and ONE interpreter, shaders/vm.glsl, runs it per pixel (picture.frag) and per sample (synth.comp, crossing from the tape it replaces over the first `fade` samples). Instruction i writes register i; the tape is pushed as uniforms. The probe measures it before anything else is built: `zig build probe` plays made-up tapes (every instruction reaching the last, a noise in ten) under --profile-gpu. RTX 3050 (driver 620.70.06), Debug host, means of 601 frames, three runs agreeing within 0.07 ms: picture, empty tape 720p 0.14-0.23 1080p 0.19-0.28 (a pass's cost) picture, 60 720p 1.38-1.45 1080p 2.89-2.96 picture, 128 720p 2.71-2.81 1080p 5.86-5.95 picture, 128 at 640x360 0.85-0.94 The budget, under 2 ms at 1280x720: 60 instructions meet it, 128 do not. The cheap fixes, on 128 at 720p: the tape in a storage buffer 2.97-3.03 (worse); the registers as an array of 16 (kept in registers, indexing turned into selects) 5.82-5.93 (twice as slow); the 128-array with only 16 slots used 2.11-2.34 (cache footprint: a register allocator would buy about a sixth); half resolution 0.85-0.94. So the sketch will draw a tape longer than 64 instructions at half resolution, scaled up. The variants are kept outside the tree. The synth's numbers taken here were of a kernel that wrote nothing (its uniform block was past SDL's 4 KiB): the sound's change measures it again. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* fs: a read answered with the sketch closed says so on stderrGabriel Schneider2 days
| | | | | | | With no instance running, fs serves the tree from the save's newest State or the declared defaults; a read then looked exactly like the running sketch's, and a script that read while the sketch was still starting took the save for it (drat-meout's scripts met this). The words the refused files already give ("<name> is not running: this is its save's newest State, frame N of ...") go to stderr before a read's answer; help, ls and complete stay quiet. test-fs checks it; the README says so. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* host: a sketch may ask for the sound device's pull, audio_pullGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | Sound a sketch makes leaves for the device about one pull after draw, and SDL opens 1024-sample pulls at 48 kHz (21 ms); 256 leaves in about 6.5 ms, but the audio server then runs every client at that size, and drops out under load. The only way to ask was SDL_AUDIO_DEVICE_SAMPLE_FRAMES in the environment. Now an app declares `pub const audio_pull = 256;` beside its name; abi.Info carries it (0, SDL's own, when it is not declared), and the host sets it as SDL's hint just before it opens the device, at normal priority, so the environment variable still wins. It is read once, at start; the web host has no device to open and ignores it. The sound overlay's header says what the device took: OUTPUT ch1 / ... / pull 256. Test: audio, on SDL's dummy driver: the device opened with nothing asked takes 1024 at once, asked 256 takes 256, and with 512 in SDL's copy of the environment takes 512 though 256 was asked. test-audio: 48/48 steps, 9/9 tests. README: the app table's row, and a paragraph in sound with the trade-off. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* vector: morph pairs outer contours with outer ones and holes with holesGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A glyph with a counter blobbed through a morph: subpaths paired by their index alone, so a hole with no partner (a 0 into a 5) collapsed onto the end of the other glyph's outline, travelling out of its own shape and leaving the counter filled, and one listed before its outline (or a shape gaining a hole) was paired with the other side's outline, its winding turned inside out. In manual's second slide the 0 became a black blob for a third of its morph into the 5. Now each pair of shapes sorts its subpaths, outer contours then holes (a hole winds against the shape's largest subpath, as a font's counters do), and pairs within each group. A hole with no partner shrinks to a point (or grows from one) where its middle stands relative to the outer contours' bounds on the other side, so it stays inside its shape as that moves. A shape without a partner, or one with no hole, morphs as before, bit for bit. Test: test/scene_morph, a ring into a disc, a 0 into a 5 and a 0 whose path lists its hole first into a ring, at a quarter, half and three quarters on the GPU and on the CPU: each hole's middle is the background (the 0 into the 5 while its hole is half its size or more), and the disc and the 5 fill it at the end. The old pairing fails it at half way on all three. What changed: the compiled test scene's equation morph (export frames 32-59, compiled-morph.png: no stray dot from a's hole, b and a keep their counters) and manual's three morphs of holed glyphs (exported frames 28.1-29.3 s, C0 into 11 000 000; 55.7-56.9 s, the 0 into the 5; 58.8-60.4 s, ADD into SUB with the row). Everything else is byte-identical: the talk's exports, every scene screenshot (manual's are taken at rest), and zig build diff's corpus, which draws no morph. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* anim: play's .lag staggers its animations, manim's lag ratio, 0 by defaultGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | The option was read into every key (default 0.08) and never used. Now animation i of a play of n starts i * lag * each after the play does, each = seconds / (1 + lag * (n - 1)), so the last still ends with the play and the play keeps its length: manim's AnimationGroup run to a run_time. A lag of 1 is one after another. An object two animations of one play change moves with the first (Change.at); the camera with the first camera animation. Compiled and live scenes agree: a live play shows an animation from its own key's start, as the compiled lookup does. Default 0, so every key of a scene without .lag is the bits it was (start + 0, seconds / 1). What changes: examples/manual.zig, slide 1: 83, C0, 01 and add eax, 1 were written all at once over 1.5 s, now one after another (0.79 s each, 0.24 s apart); the six labels and three bytes of the flight played together, now in order, 0.12 s apart, 0.58 s each (exported frames 22.0- 23.4 s and 25.1-26.4 s). vecanim's intro passes .lag to a play of one write: unchanged. Tests: anim: a lagged play (four at 0.5, then two at 1) live against compiled at 16 instants, and its times. test-anim, test-talk, test-manual pass; the compiled scene's export (92 frames), the talk's two (364) and every scene screenshot are byte-identical to before, but for the player bar's wall-clock record time; manual's exports differ in those 29 frames only, its screenshots not at all. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* Merge the sketch's file tree and the manual's second slideGabriel Schneider2 days
|\ | | | | | | | | | | | | Verb tables, state as files, fs verbs in every sketch binary; with the opcode-table slide of examples/manual.zig. No conflicts; zig build test: 180/180 steps, 144/144 tests. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * examples: manual's second slide, ADD's row 80 /0 ib becomes SUB's 80 /5 ibGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The manual example is a talk in two slides now: Figure 2-1 as before, then, once it clears, page 132 of the SDM's Vol. 2 (ADD) fades in with its opcode table taken out; the table is written back row by row (the column rules drawn down, then each row with the rule above it); the camera goes to 80 /0 ib ADD r/m8, imm8 as the rest greys; its opcode cell is tinted; closer in, the 0 after the slash morphs into the 5 of SUB's row from page 1400 while 80, / and ib hold still; then the rest of the row follows (ADD into SUB, Add into Subtract, to into from, imm8 and r/m8. sliding to their places) and the page around it becomes page 1400; at the end ADD's row comes back over SUB's, what differs is marked, and a line says why (one opcode byte, the ModR/M reg field picks the operation). Seven steps; the talk is 66 s exported. The pages and rows are checked against the PDF (pdftotext): ADD is page 132, SUB page 1400, and the rows' word boxes and the page's own rule shapes give the rectangles, in points, turned into the page's units by one function. Page 1400 stands 20 units higher, so its row (182-197 pt) lies on ADD's (167-182). The page draws a table's text row by row, left to right, and its rules after all of its text, so a row part writes in reading order. The column rules run the whole table, so their centres all fall in one row (83 /0 ib, at 265 pt): a band a point high through 265 takes the seven of them first, and nothing else. Each row is cut in the same eight pieces on both pages (the digit, the rest of the opcode, the instruction, the three short columns, the description word by word) and each piece morphs into its own: a morph pairs shapes by index, so the whole row (44 shapes into 51) would send every glyph after Add across the row. test/manual.script goes on through slide 2 with pixel checks (the table gone and back, the cell's tint, a step back to the exact picture before the digit's morph, the marks at the end) and checks three more exported frames of it, the same in both exports. The bench now times pages 132 and 1400 too (2118 and 2040 shapes: parse 10.0 and 10.3 ms, CPU draw 2.8, GPU record 1.2, in budget). The README's examples list and the manual's paragraphs say so, and how a table's column rules are taken. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | console help: the verbs' names, so the sketch's help fits the log under themGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | help printed the rows with their arguments, four lines of the log's five, and drat-meout's own help pushed the first out. Now it is the names (two lines), help VERB says a verb's arguments and what it does, and the sketch's lines follow. Tests: test-timing and test-control, 49/49 steps, 30/30 tests; live in the drat-meout copy over fs, `help` leaves the sketch's two lines and its own in the log. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | README: the 9P controls rewritten around the tree; the Build API's cloud9Gabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | "Local 9P controls" was a socket path, plan9port `9p` lines and a poll of status for a screenshot. Now it says what a running sketch is: a tree that describes itself (README, commands, made from the tables), how it is found (posted as sketchbook/<name> by a run in a window, --9p NAME or a socket path), `fs VERB PATH` in every executable and the generic host, answering with the sketch closed from the save or the defaults; a table of the files; how the State maps to files (rows of numbers one file, arrays of arrays and of structs directories, drat-meout's notes as the example; a value read as it was at the open); and an agent driving drat-meout: start it, help, a console line, read state, await by reading in a loop, a live click, one read for a screenshot, a refused write in words, help of one file, quit, and a read with it closed. The ctl paragraph says the 4096-byte write, errors as their names and what each open pins; the trace examples use fs. The console bullet says help VERB and set of an array. The Build API lists sb.modules.cloud9. --help's --9p row and usage line say NAME|/SOCKET and fs. Tests: the session in the manual was run against the drat-meout copy, headless, posted under a scratch runtime directory. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | state/: a value is read as it was at the openGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A read of a State file formatted the value at each Tread and sent the window at its offset; a value that changed between two reads (a float a frame moves) could change length, and the second read sent the tail of the new text after the head of the old: `1.526633` then `5`, which a shell loop awaiting a number read as "1\n4". Now the open formats the value once into one of the connection's snapshots, as the traces and README are, and reads window it; release frees it. A write is unchanged. Found driving drat-meout from a shell loop, `until [ "$(drat-meout fs read state/street/time | cut -d. -f1)" -ge 3 ]`. Tests: test-control and test-fs, 51/51 steps, 11/11 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | The door for sketch-owned files: sketch/ and the nodes from 2^63, reservedGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A sketch may one day serve files of its own (an embedded editor's buffers, Round 2 §4 of the 9P survey): the host's tree now keeps the place for them and builds nothing behind it. sketch/ is an empty directory the host never fills (its README line says so); every node from 2^63 on is the sketch's, and the host answers none but sketch/ itself (2^63): a lookup under it, or any other node of the range, is UnknownFile. state/'s nodes have bit 62 set and bit 63 clear, so the two ranges never meet. Served offline too, empty. Later, one optional ABI entry can take the requests whose node is in the range or under sketch/, cloud9's engine keeping fids, permissions, readdir cursors and parking; not now. Tests: test-control, a new test: sketch/ is a directory, empty, nothing under it, and nodes of the range refused; README names it. test-control and test-fs: 51/51 steps, 11/11 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | Dial by name, and fs in every sketch's binary, answering with the sketch closedGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A run a person watches (not headless, a script or an export) posts its tree as $XDG_RUNTIME_DIR/9p/sketchbook/<name>, the sketch's Info.name; --9p NAME posts under another name, --9p /path listens at a socket path as before. A name a live run holds is refused, a stale one replaced; a default post that fails says so and the run goes on without one, an explicit --9p that fails ends it as before. (cloud9's post() takes names without a slash, so control.zig makes the sketchbook/ directory and binds there itself, with post.probe deciding live or stale.) `fs VERB [PATH [WORDS]]`, after the options, in the generic host (`sketchbook LIBRARY fs ...`) and in every executable built with sketchbook (`drat-meout fs read state/scene`), is cloud9.verbs.run on an Fsys: the running sketch's tree when one is posted (or at --9p), else the same tree served in this process over a socketpair, on a thread (Control.serveOffline, the same respond with `offline` set), from the save's newest State (--state's save, else the default one; read only: Sessions.openRead, no session started, restored into today's layout), else from the State's declared defaults (init is not run). README, commands, ctl's read and state/ answer; a write and status, log, screen.png and the traces answer in words, "drat-meout is not running: this is its save's newest State, frame 61 of <save>". No window, no SDL. sketchbook.init's modules gain cloud9, so an app's own tests can dial its executable with cloud9.Fsys. Tests: a new step, test-fs (in test): the replay fixture posted by name under a private runtime directory, driven with its own binary's fs: ls, a state write and read, a refused value in words, a live click, a screenshot read, help of state/dots and ctl, quit and the name gone; then closed: a state file read from the defaults, status refused in words. test-fs, test-control, test-paths, test-setup, test-sessions: 56/56 steps, 27/27 tests. drat-meout's copy builds unchanged and answers fs with the game closed: 94 leaves, 16,522 files, 17,608 values, 10,408 directories. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | screen.png: one read, answered when its frame has landedGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A screenshot over 9P was a write of `screenshot` to ctl, then reads of status until screenshot_generation moved, then a read of screen.png (an open while a capture was pending failed). Now an open of screen.png asks for the next frame itself and is parked (cloud9's Status.again) until the capture lands: the service loop answers the engine's retry() each pass, so a parked open is asked again every frame, and respond (unchanged) answers it once nothing is pending, pinning that frame's PNG, or with the capture's error. So `9p read screen.png` or `fs read screen.png` is the whole recipe. A write of `screenshot` still works and status still counts, and an open after it waits for a frame of its own. The frame-thread loop carries the park cleanly: retry() and next() run on the frame thread between frames like every request, a parked open keeps its fid, a flush or a hangup drops it, and the four parking slots a connection has bound how many wait at once (a fifth open is refused "waiting"). Tests: test-control 46/46 steps, 10/10 tests (the snapshot test's CapturePending is now what answer() parks). Live, headless, the replay fixture: three reads of screen.png with no write, 24-26 ms each with the 9p process's start, 640x360 PNGs; the old write-then-read still works. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | The tree describes itself: README and commands from the tables; ctl takes ↵Gabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | input live README is made at each open from the tables (pinned per open, as the traces are): a line a file from control.zig's `files`, ctl's verbs indented under ctl (ctl's own, the script's input verbs, the console's, each with its args and doc from its row), and a line per State file under state/, from the layout (its path with <n> for an index, its type, an enum's tags, a row's length), in the shape cloud9's `help` reads: `help ctl` prints the verbs, `help state/tracker` the state/ line and every file under it. `commands` is the verb lines alone, unindented, the sketch's own words (App.commands) last. A ctl read points at both. ctl takes the script's input verbs live: click, move, down, up, wheel, wheel-x, cancel, key, hold, release, type route their events at the wall clock through script.input, the same code a script runs, with no frame of their own: the next frame feeds them to update. Order: ctl's own words, then the input verbs, then a console line (and through it the sketch's); so a sketch command named like an input verb is shadowed over ctl (none is today). Tests: test-control, a new test: ctl's click and hold reach the pending events, a short click is refused (ExpectedPoint), README and commands read the rows and the layout: 40/40 steps, 10/10 tests. Live with the replay fixture: README read over 9P, `down 5 5` written to ctl moved state/pressing. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | The State as files: state/ in the 9P tree, a directory per struct and arrayGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | state/ serves the running sketch's State nested: a directory per struct and per array, a file per value, state/tracker/songs/3/bpm. A read is the value as get shows it, and a newline; a write is the console's set with the file's path (control.zig builds `set tracker.songs[3].bpm 90` and runs it through runLine, so it stops a replay, logs, marks a jump and notes the line like any set). Numbers, bools and enums are written; optionals, unions and the like read as `<N bytes>` and refuse writes. An array of scalars (a vector's lanes, talk.text) is one file of its values, blank-separated; an array of arrays is a directory of such rows (grid/1 for grid[1] of a [2][3]i16). So a file is one value or one row, the run of values one set names, and stays the size of a row however large the array; and paths keep the State's own shape. An array of structs is a directory of indices: drat-meout's patterns, 8x16x16x4 of {pitch, velocity}, are state/tracker/songs/<n>/patterns/<n>/<n>/<n>/ pitch, reached by walking, listed a dimension at a time. state_files.zig does the walking from a (Layout, bytes) alone: lookup, readdir, read, the set path and a README line per file, so the save's newest State and a sketch's defaults can be served the same way. A node is the layout's first leaf under it, its depth and the element's offset, with bit 62 set (bit 63 stays the sketch's). A node a reload made stale is refused, "StateLayoutChangedWalkAgain". fields.setRow sets a row from its words, all or none, and the console's set takes it: `set talk.text 104 105 0`. The engine keeps names up to 64 bytes (from 28), for long field names. Tests: test-control (now also "the State as files" and "a row of scalars"): 40/40 steps, 9/9 tests. Live, headless, the replay fixture over plan9port 9p: ls state, read and write dots/buffer/3/kind and the position vector, a bad value refused as InvalidValue. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | One verb table: the flags, the console's, the script's and ctl's words are rowsGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Six hand-kept lists said one vocabulary: root.zig's parser, its usage and its header; the console's completion list, its help strings and the execute chain; Host.zig's list of lines that do not move State; the script's header comment and its step chain; control.zig's names and its magic node numbers. Now each is a table, and the parser, the help, the completion and the dispatch read it. - root.zig: `Flag`, an enum, and `flags`, a row each (arg, doc): the loop looks the word up, takes its argument when the row names one, and a switch sets what it means; `usage` is made from the rows at compile time (the same text, and a line for --help). Errors say the flag and what it needs. - Console.zig: `Verb` and `verbs`, a row each (args, doc, moves_state): execute is a switch on the verb, a line whose first word is none goes to the sketch as before; Tab completes from the rows (a verb, and with each lowercase word its first argument may be: `seek start`); `help` prints the rows wrapped to the log's width, `help VERB` its line. - Host.zig: movesState asks the row; a sketch's command moves State. - script.zig: `Verb` and `verbs` (args, doc, frame, input): step is a switch, a row with `frame` is followed by one; the input verbs are `input`, which a 9P ctl will call live. - control.zig: `File` and `files` (mode, doc), a node being its number (the same numbers); `Verb` and `verbs` for ctl's own two words. Behaviour is unchanged but for help's text, completion's list (the same words, and `timing`, `play`, `seek`... alone) and errors' words. The diff adds more than it deletes (+630 -521): the rows carry a line of doc for every verb, which nothing had before. Tests: test-control, test-timing, test-setup, test-same, test-kill, test-past, test-import, test-paths: 70/70 steps, 29/29 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| |
| \
*-. | Merge one State in one file, GPU sound at the host's lead, and PDF pages as ↵Gabriel Schneider2 days
|\ \| | | | | | | | | | | | | | | | | | | | | | | | | objects The Store's deletion with shared-page keyframes and the 64 MiB cap; f.audioBuffer and in.lead with spheres on them; the embedded-SVG image, Typst's root, part, and the manual example. No conflicts; zig build test: 179/179 steps, 140/140 tests; spheres 75/75, micscope 67/67. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| | * README: PDF pages and parts, in the Animation sectionGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A paragraph on a PDF page as a Typst object: the absolute path Typst's root / allows, and that the cache does not see the file change; text as outlines; the order write follows; what a page costs, measured on Figure 2-1's page (parse once 6-12 ms, 0.9-1.7 ms a frame to record for the GPU, 0.4 ms on it, 2-5 ms on the CPU renderer), a table of contents five times that, and the bench's page budget. One on part: the rectangle (centre and size in the object's units, the literal s.rect takes), how to pick it (the guides, or pdftotext -bbox and the points to units sum), where the part stands and when it shows, the rest drawn by the object, a shape to the first part, rules crossing fields, and transformInto into the whole target so a morph can be split. One on examples/manual.zig, -Dmanual and what happens without the PDF. The examples list names it, and the objects list names part. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| | * examples: manual, Figure 2-1 of the Intel SDM comes alive, as a talkGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | examples/manual.zig is a live scene with pauses, played by the stock player: page 31 of the SDM's Vol. 2 (Typst's import of the PDF, every glyph a shape) fades in on paper beside a title; the camera closes on Figure 2-1, the instruction format, while the rest of the page greys and its footnotes go; each field (Prefixes, Opcode, ModR/M, SIB, Displacement, Immediate) is tinted and glows in turn; 83 C0 01, add eax, 1, is written below; each byte flies into its field as the fields it has none for fade; C0 morphs down the arrow into the ModR/M byte's boxes as 11000000, which splits into 11, 000 and 000 over Mod, Reg and R/M, each with what it says (direct, /0 ADD, EAX); and the camera goes back to the page, filled in. Twelve steps, 18 s played straight. The labels, the ModR/M boxes, the figure and its footnotes are parts of the page, by rectangles in the page's units read off pdftotext -bbox (points to units: (pt - 306) * 4/3, (pt - 396) * 4/3) and checked with the guides; each tint is the s.rect of its label's rectangle. The bits are parts of a Typst object, cut by character (0.6 em of DejaVu Sans Mono at 14 pt). The PDF is never committed. build.zig's -Dmanual names it, by default ~/01-resources/intel-devref-ii.pdf; when the file is not there the scene is one line saying how to build with it. zig build manual plays it in a window. test/manual.script, run by zig build test (and test-manual) only when the file is there, steps through the talk with pixel checks (the paper, a tint where it should be and not where it should not, a step back) and exports it twice at 10 fps, the same frames both times. zig build bench also times the manual's page (its one #image source, when the build has the PDF), with a budget of its own for a drawing of over 1000 shapes: parse under 25 ms, CPU draw under 10, GPU record under 4, at 1280x720. Measured: 6.4, 1.9 and 0.77 ms on a quiet run; 14.8, 3.5 and 1.4 at load average 34; once 28.6 ms to parse, at that load, which failed it (the simple objects' 1 ms is as sensitive: 0.87 ms then). The manual's simple objects are not benched: a two-glyph 83 fitted to the whole canvas takes 1.1-1.2 ms on the CPU. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| | * anim: part, the shapes of an object inside a rectangle as an object of their ownGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | s.part(of, .{ .x, .y, .w, .h }) takes the shapes of an object whose bounds' centre lies in the rectangle (x, y its centre, in the object's units: the same literal s.rect would lay over it standing at the origin at scale 1) and makes them an object, around the rectangle's centre, so indicate, scaleTo and rotate turn it about itself. The object draws the rest from then on (its new cut), so a part can be written in, moved away or morphed while the page around it stays. A part stands where its shapes stood and shows as the object does after the plays laid so far: taken from a page that has faded in, it is there; taken first, it fades in with nothing until played. A shape goes to the first part that takes it; parts of parts work the same way. transformInto morphs into the whole of its target, as if nothing were cut from it, so a morph's result can be split into parts taken after it (which then stand where they were and show as it does). How: Source.part holds the object as it was (a pointer: in a compiled scene to a comptime constant, in a live one into the frame's arena) and the area; Object.cut lists the areas taken from it; both are in the object's id. anim.sift makes either drawing out of the whole one, sharing its geometry; the Painter sifts its cached whole, so a page is parsed once however many parts it gives. In a compiled scene the part follows its object through the plays laid before it was taken (keys copied, moved by the area's centre at the object's scale and rotation); in a live one it starts from the object's shown and settled poses. build now also moves a shape's clip with its centring (it moved the shape and left the clip behind). Test, at the end of root.zig: a row of three squares, the right one taken once the row has faded in, then each moved: the compiled and the live scene agree at every instant, the part fades with the row, stands where its square stood, and the row keeps the other two. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| | * anim: Typst runs with / as its root, so a source can name any fileGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The Typst step ran in .zig-cache/typst with Typst's default root, the directory of the file it compiles, so a source could name no file but one in the cache: #image("/home/me/manual.pdf", page: 31) failed with "would escape the project root". It now runs with --root /, which makes an absolute path in a source the file's own path; relative paths still resolve in the cache, as before. Why / and not the build root: the file a scene names (a manual, a paper) lives where its owner keeps it, outside any project, and a copy or link under the project is one jj add away from being committed. / is safe in that Typst only reads what a source names, and a scene's sources are its author's code, compiled by a build that can already read and run anything. The cache is still keyed by preamble and source alone: a file changed in place keeps its old SVG until its cache entry goes (typst.zig says so). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| | * svg: an image that is an SVG document in a data URI is drawnGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Typst places an SVG image, and a PDF page imported with image(), as an <image> whose href is the document in base64; svg.zig skipped every <image>, so any Typst object holding one silently lost it. The parser now decodes such a document and walks it into the same drawing, mapped into the image's x, y, width and height (stretched with preserveAspectRatio="none", else fitted and centered, as SVG says), with its own ids, gradients and percentages and nothing inherited from around it but opacity. It is not clipped to its box (a PDF page never draws outside itself, and a clip per shape costs the renderers a pass over every contour). Raster images still draw nothing. The root's view box and size come from one function both documents use. Tests: a unit test at the end of svg.zig (ids of its own, stretched and fitted corners, a PNG skipped); two corpus cases for zig build diff, image.svg (two data-URI images, one stretched and turned, beside an outer gradient that shares an id with an inner one) and typst-image.typ (two SVGs placed by Typst): both renderers match resvg (mean 0.09-0.11). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * | spheres: its sound streamed from the GPU's block, at the host's leadGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The synth block goes to the speakers with f.audioBuffer, made to keep in.lead queued; in_flight, discard and lead_seconds are gone, and a chord's jump is the stream's clear alone (nothing is on its way back to drop). The block is still read back, a frame later, for the scope. The sound is the same: with the block fixed at 800 samples a frame, the play script and a script that plays every chord key (seven jumps) push the same samples before and after, to the bit (849600 and 1164007 of them), the new one a frame sooner. A change leaves for the device in 19 to 27 ms on average (three one-minute runs on a loaded machine) instead of 96 (dummy driver, 60 Hz, SDL's 1024-sample pulls). The empty Store declaration the brief mentioned is not in this sketch (main.zig says "No Store"); nothing was touched there. Tests: zig build test, 75/75 steps, 3/3 tests (its play script now also expects the stream fed). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * | audio: a GPU buffer streamed within the frame, at a lead the host measuresGabriel Schneider2 days
| |/ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A compute shader's output was heard only after the sketch read it back (f.download, a frame later) and pushed it behind a lead of its own choosing; spheres kept 100 ms, and a change it made left for the device 96 ms later on average (measured, dummy driver, 60 Hz). f.audioBuffer(key, buffer, .{ .count, .offset }) streams `count` f32 a shader wrote: the host copies them back while it runs the frame's commands, waiting on the copy's fence (Executor.read: 0.2 ms on average here, 2 ms at the 99th percentile on a loaded machine), and queues them on the stream, so nothing is in flight between frames and the sketch keeps no books. Input.lead says how far ahead to make sound: the slowest of the last 64 frames' worth of samples (timed between the ends of the frames' commands, where the pushes are), plus the device's pull (what SDL takes from a stream at once, read from the device: 1024 here), plus half a pull for each underrun, a sample less each frame after; capped at 8192. A sketch pushes `in.lead -| in.stream(key).queued` a frame, and its change leaves after about what is queued ahead of it, a pull: 19 to 27 ms on average with SDL's 1024-sample pulls, 6.3 to 6.5 ms with 256 (SDL_AUDIO_DEVICE_SAMPLE_FRAMES; 17 under heavy load). Stream.underruns counts the pushes that found a stream empty though the frame before had fed it (a gap). The voices keep their 2048 samples: mixed to the lead, a one-shot longer than it is mixed over several frames, and voices.script's expect-audio and expect-no-audio, which look one frame at a time, failed. On the web, audio.buffer reads the buffer back with mapAsync and queues it on arrival, in order, counting it as queued meanwhile; in.lead stays at 100 ms there. The measurements (a probe patched into the host for the purpose, kept out of the tree) are in the 02-pardes-code scratch, .scratch/sketch/gpusynth. Tests: the lead's arithmetic (audio.zig, in test-audio's filter); spheres' play script checks its stream is fed. zig build test: 164/164 steps, 49/49 tests run (the rest cached); zig build test-audio: 48/48 steps, with the voices sketch's wasm, so web.zig compiles; voices.script passes four runs in four. web/host.js: node --check only, no browser run. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | README: one thing a sketch keeps, in one file; what a crash loses; the capGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The manual described a mapped state file, a sessions database beside it, a probe, private files for scripted runs and exits that compact past 64 MiB. Now, in The host: "The save" replaces "State file" (one thing, State, in one file, `<name>.xitdb`; the present restored and replayed at start; keyframes as pages and what they cost, measured; layout migration as before; an old `<name>.state` imported once and left as it was); "Where files go" lists `<name>.xitdb` and the files a sketch appends to, `--state x.state` and `x.xitdb` naming one save; "Sessions" says every run is one, `record` decides how much history is kept (a build that does not record keeps the present and the marks, the last minute of input at most while it runs, none after), a crash loses under a second and the next run starts from the last committed frame; a new paragraph, "The cap": 64 MiB, State half, history dropped oldest first and the file compacted to three quarters (about 170 ms in Debug), the present, marks and clips never dropped, a new mark refused with how to make room. The State row and "Data that grows" say 32 MiB; the appendFile paragraph names `<stem>.<name>` beside the save; scripts and exports save nothing; the Build API loses `probe`, `addProbe` and `probe_exe`; Known limits gains the hash pass's cost. layout.zig's note on what State may hold says where it is saved; micscope's README names its takes `micscope.take-<id>.f32`. Tests: zig build test, 168/168 steps. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | The cap: a save is at most 64 MiB, State half of it, history dropped oldest ↵Gabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | first A save grew without bound. Now Sessions.max_save is 64 MiB and layout.max_state 32 MiB, so history always has room (the compile error says so: "State is N bytes, and may be 32 MiB, half of a save, so history has room: ..."). A commit that leaves the file past the cap trims it (Sessions.trim): one transaction drops history oldest first, a keyframe by removing its pages (its frame, batch and time stay, so keyframe numbers, keyBefore and marks by index still resolve) and a batch of frames by emptying its slot, until the keyframes' written pages and the batches left count three quarters of the cap; then the file is compacted into `<path>.new` and renamed over it, and the run goes on in the new file (compact now reopens). A dropped keyframe's pages may still be shared by a later one, so a round can free less than it counted: the next round lowers the count by the overshoot, four rounds at most. Never dropped: the present (the newest keyframe and the batches from its own on), the keyframe of the newest mark of each name, the keyframe of the newest clip of each name and every batch holding one of its frames. A session left with nothing loses its keyframes, batches and stretches; its summary stays. Asked for, what was dropped is error.HistoryDropped, which the console says in words ("That part of the history is gone: a save keeps 64 MiB, the newest."). Marks are pinned under the cap: a mark of a new name needs room for a whole State, history trimmed to make it; without, it is refused, error.SaveFull, the console saying how to make room: save over a mark's name (the older one then goes with history) or start another save. A mark over an existing name is always taken. (The spec's "room" rule, refusing only after a trim failed, let one mark take the file past the cap; room for a whole State keeps the cap hard, at the price of refusing early for a big State.) Builds that do not record (`history` false, from Info.record) use the same mechanism with the history limit zero: every commit holding a keyframe drops all it may (no compaction unless past the cap), and the exit compacts, so the disk holds at most the last minute of input while it runs and the present and the marks after. The exit compaction a recording build made past twice its contents plus 64 MiB is gone: the cap's compaction does that work. Measured (Debug, unit test): a trim of a 64 MiB file to 48 MiB takes 165-187 ms (two rounds of drop and compaction, the first ending 0.5% over); a no-history trim at a keyframe, 0-5 ms. ReleaseFast not measured. The console's `marks` reads each mark's keyframe fields, not its State: an older mark of a name may have gone with history (listed "dropped" when its session went whole). Docs: record means "keep history" in App.Options, sketch.Build and abi.Info. Tests: zig build test, 168/168 steps, 137/137 tests. New, in Sessions.zig: 100 keyframes of 1 MiB each with marks at the 5th and 20th: the file never past the cap, the oldest keyframes and frames HistoryDropped, both marks and the newest keyframe whole, the present's frames readable; without history, 20 keyframes and a mark: only the mark and the present stay, the file compacted at exit under three times the State and the present reopening whole; 2 MiB marks until one is refused (SaveFull, the file under the cap), then one over an old name taken and the file under the cap, every mark whole. micscope 67/67, 10/10; spheres 75/75, 3/3; noc e2e 292/292; the drat-meout copy 87/87, 30/30. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | The present lives in the save: one file a sketch, the state file goneGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A sketch kept its live State in a mapped state file and its history in a sessions database beside it. Now the database is the save, the one file: the present is its newest keyframe and the frames logged after it, and a run starts there (Sessions.present: the newest session with a keyframe, its last keyframe loaded and the frames after it read). Host restores it (migrating across a layout change, as a seek does) and replays the frames through `update`, unlogged, `started` as it was fed (true only from a session's first frame); played by another build, they are not replayed, and the run says how many frames that was. The run's first keyframe then starts from the present's pages, so a session costs what changed since the last one. --fresh still starts from defaults, the save untouched. State is process memory (memory.State: one page-aligned allocation, its layout, and its layout header for the stretches); a reload's adopt allocates the new layout's defaults and migrates the old bytes into it, and returns null when unchanged. Gone: StateFile, its slots, used bits, resize, dropSnapshots and the adopt that rewrote a file's header; the sketch-facing `Host.state` keeps `layout`; Timeline restores into `state.live()`. `adopt` no longer runs `init`: openPresent does when there is no present. Every run saves: the database is opened in a file for every run but a scripted one from fresh state (memory, nothing on disk) and an export (none). So release builds keep their State as before, and marks and clips work there; `.record` keeps or trims history (next change). The save is `<stem>.xitdb`, `<stem>` being --state without `.xitdb` or `.state`: `--state x.state` and `--state x.xitdb` name the same save. Defaults: `.sketchbook/<name>.xitdb` under zig build run, and `$XDG_DATA_HOME/<name>/<name>.xitdb`. A sketch's appended files are `<stem>.<name>` (micscope's takes: `.sketchbook/micscope.take-3.f32`, where Phase 1 wrote `micscope.state.take-3.f32`; that naming never left this workspace, so nothing of the user's is renamed). A scripted run from fresh state or an export appends to `<stem>.<pid>.<name>` and removes those at exit; the private state file and the exit's moving of files by prefix are gone from root.zig. Old state files: in a new save, `<stem>.state` (one slot or eight, any of the three formats) is imported once: slot 0 becomes the present (in today's layout), slots 1-7 marks "1".."7" (migrated to it, as before); the file is read through a read-only mapping and left exactly as it was. It is never read again: the save then has a session. A file that is no state file is said and left. .sketchbook/'s move of an older build's `<stem>.state` from beside it stays, now by stem. sketchbook-probe is deleted (86 lines, its build step, Sketchbook's probe_exe, App.addProbe): it mapped the state file. Reading the save instead would show State as of the newest keyframe, up to a minute old, never the frames after it, which only `update` can turn into State; and it would need a read-only open the host has no other use for. The planned 9P state/ tree reads live State from the process. A kill -9 now loses what the session log always lost: the frames not yet committed (under a second: in test-kill 15 of 255 frames, the next run starting from frame 240's State), keyframes and marks queued since the last commit (a mark commits at once, synced), the session's end time and an open clip's end. The mapped file lost nothing to a kill. A power loss reopens at the last commit the disk holds whole (`mend`); commits are fsynced only for marks and at exit, so what the OS had not written back is lost (not measured); the mapped file, never synced, could tear page by page. Measured: drat-meout's State, 20 extra jump keyframes in a 2,400-frame script, 100,708 B more than the same frames without them: about 5 KB a keyframe, where the whole State (17.7-20 KiB) was written each time. Tests: zig build test, 168/168 steps. test-kill runs for a recording and a non-recording build, and the second run checks `updates` is 240 (replayed), not only the session's frame count. test-paths: the XDG directory holds `replay.xitdb` alone; .sketchbook/ holds `.gitignore` and `replay.xitdb`; the next run's State is the one the last left; an older `old.state` beside .sketchbook/ is moved in once, never over a file, and left as it was when it is no state file. test-same: a run from fresh state leaves no file at all. Rewritten: memory.zig's state file tests as State's (migrate, unchanged) and OldState's (refused untouched; drat-meout's v1 fixture imports every value, the file unchanged), Host's snapshot import as importOld (State live, two marks, the file byte for byte as it was), Host's setup test without a file, the timeline test on a State. micscope 67/67, 10/10; spheres 75/75, 3/3; noc e2e 292/292; the drat-meout copy 87/87, 30/30. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | Keyframes share pages: each writes only the pages of State that changedGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A keyframe was a whole copy of State, so a 4 MiB State edited once a minute wrote 4 MiB a minute. Now a keyframe stores State as `pages`, an xitdb list of 4 KiB blobs (the last one shorter), with its `size`: it starts from the list of the keyframe before it (its slot written, and the cursor frozen, so a keyframe queued in the same commit is copied, not changed), and puts only the pages whose Wyhash differs from that keyframe's, which Sessions keeps in memory (`hashes`, one u64 a page). An all-zero page is an empty slot: no bytes. `written` records the bytes of pages a keyframe wrote, each page being written by exactly one keyframe, so the live size the exit compaction weighs is the batches plus every keyframe's `written`. A State unchanged since the last keyframe is still skipped (but before a reload), now by its page hashes. Keyframes from before pages keep their whole `state` bytes, and `load` reads both (`Loaded.paged` says which). Export and import shared pages once: `copy` remembers each blob's place in the source and the slot it was copied to, and writes that slot again for a page another keyframe already brought (xitdb takes slot writes). Measured (Debug, unit tests): a 4 MiB State, one u64 edited a minute, grows the database 144-153 KB a minute, 86 KB of it the minute's 3,600 ticks; a keyframe alone in a commit is 10,160 B with one changed page and 1,376 B with none (it was 4 MiB either way). A 1 MiB session of ten keyframes a byte apart exports to 1,133,486 B (it was over 10 MiB). The hash pass over State, best of five on a loaded machine: 2.2, 36 and 71 ms at 1, 16 and 32 MiB in Debug; 0.04, 1.3 and 2.9 ms in ReleaseFast. Not done (the spec's later fast paths, nothing needs them yet): restore copying pages without defaults and migration for an unchanged layout, the divergence check comparing pages first, formatPath skipping leaves. Tests: zig build test, 166/166 steps, 134/134 tests. New: a 4 MiB State edited each minute for ten minutes, under 230 KB a minute and every keyframe reading back with exactly the edits made before it; a lone keyframe under 12 KiB with one changed page and under 8 KiB with none; an exported ten-keyframe session under 1 MiB and an eighth, reading back. Changed: the compaction test's live size counts five 8-byte keyframes, not six (the first State is all zeros, an empty page). test-kill, test-past, test-import, test-same and test-paths unchanged. micscope 67/67 steps; spheres 75/75, 3/3 tests; noc e2e 292/292; the drat-meout copy 87/87 steps, 30/30 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | micscope: a take starts its file empty; a deleted take's file stays, and whyGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Phase 1 left two loose ends in micscope's take files. A new take could continue an old file when its id met one already written without a jump in between (the jump is what moves next_id past written files), and a deleted take's file stayed on disk. The host gains one call beside appendFile: f.host.writeFile(name, bytes) writes a new, empty file of that name, through the same vtable entry with a `replace` flag. The old file is unlinked, so a readFile mapping of it keeps its bytes, and the host's cached mapping is retired (kept until exit, the sketch may hold it) so the next readFile maps the new file. The web host writes nothing, as for appendFile. micscope writes each take's file so when the take begins: on the frame whose transport request is newly `recording`, live, and not a jump (a jump's requests are restored State's, not a beginning; a fresh Session counts old requests as handled, so a restart mid-recording keeps its file), before the takes are read; `open` writes a file's samples so too. A deleted take's file stays: its State entry comes back with any seek or mark from before the delete, marks are kept with no end, and an exported session carries them; neither the sketch (which cannot see the history) nor the host (which cannot read State's meaning) can tell when none is left. So "never, safely": the file is kept. Tests: zig build test, 164/166 steps, 132/132 tests (the appendFile test now also replaces a file and reads back only the new bytes); the one failure was the Typst bench's 1 ms bound (1.024 ms), timing code this change does not touch, on a machine loaded by other builds; it passed in the next full run (166/166, with the change above this one). micscope's zig build test, 67/67 steps, 10/10 tests. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | Delete the Store; State is checked against the 64 MiB a save holdsGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | A sketch's data is State: flat bytes, what grows has its capacity in its type. The Store, a heap in a file mapped at 0x2000_0000_0000 with 64 GiB reserved, its power-of-two allocator, its root adopt and migration, and its test, are gone from memory.zig; so are Context.store and store_root, Info.store, Memory.store, the Store declaration's glue, Init.store, Frame.store and Console.store, the web host's store in wasm memory, the host's StoreFile wiring and `<state>.store` file, the `.store` suffix in moving an old state into .sketchbook/, the build's tests' `rm` of it, and layout.check's `pointers` flag (State is the one checked memory now). Its one real user, micscope, moved off it in the change before. Old `.state.store` files are not read, converted or deleted, and stay ignored by .gitignore. A sketch that still declares a Store gets no error for the declaration: nothing reads it, and a `*Store` parameter is a compile error (no argument of that type). layout.of(T, .state) refuses a State bigger than layout.max_state, 64 MiB, one constant: "State is N bytes, and a save holds at most 64 MiB: lower a capacity (an array, an sk.List), or keep what need not be saved in Session." The pointer-hash gap the spec found (a Store pointer's element type changing kept the old bytes) is gone with the only persisted memory that held pointers. README: no Store row, allocator row, migration paragraph, file bullet or known limits; draw and command lose their store parameter; State's row says 64 MiB at most; data that grows and is the user's work goes in a List in State or, bigger than a save, in files the sketch appends to. Tests: zig build test, 166/166 steps (the store's unit test gone; new: a 65-MiB State fails to compile with the message above, by expect_errors). micscope, spheres, noc's e2e and drat-meout's test unchanged and green. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | micscope off the Store, its takes files written through Host.appendFileGabriel Schneider2 days
|/ | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The library could read a file and not write one, so micscope kept its takes in the Store: a tape appended every frame while recording, which a save of 64 MiB could not hold (under six minutes of 48 kHz audio, and micscope allows ten-minute takes). Now a sketch has one call that writes: f.host.appendFile(name, bytes) appends to `<state>.<name>`, beside the state file (in .sketchbook/ under `zig build run`), creating it, and returns the file's path for readFile, or "" when nothing was written. It is pointer and length in, a C-callconv entry in the vtable like newSound. Only draw and command have a host, so a write is not replayed, like sound. The web host writes nothing and returns "". readFile still maps a file once, so what is appended after is not in what it returned. A scripted --fresh run works on `<state>.<pid>`; the files it appends to are `<state>.<pid>.<name>`, and the exit now moves every file of the run (found by that prefix in the state's directory) to the given name, or removes them for an export, where it moved the state and its store by two fixed suffixes. micscope: State lists the takes (sk.List(Take, 64): id, source) and the counter, next_id; `update` adds a take when recording starts and removes one on delete. Each take's samples are `take-<id>.f32` (mono f32 at the host's rate), appended to by draw as it records and by `open`, which also puts them straight into Session (the web keeps no files). Session holds the tape (every take's samples, read from their files once a process) and a clip per take (start, len, and heard, the playhead, which a restart no longer keeps); draw makes the tape follow State: a take State lost leaves it, one it lacks is read from its file. A deleted take's file stays, so a seek back finds it again; after a jump (start, seek, load, set, reload) draw moves next_id past take files already written (--fresh keeps them, and a seek back finds the future's) with a `next-id N` command. Gone: the Store, the remove request, the `takes N` command that told State the Store's count, adoptTape. Old micscope.state.store files are not read: their takes stay in them. README: appendFile among the host calls, a paragraph on it, and the private run's appended files. Tests: zig build test, 164/164 steps, 133/133 tests (one new: appendFile appends beside the state and names the file). micscope's zig build test, 67/67 steps, 10/10 tests; transport.script reads `takes.len`, loses the miscounted-takes check with its mechanism, and gains a deleted take read back from its file after `load` and the counter moved past written files. Pictures: the four scripts' 18 screenshots before and after, compared by pixel: the differences are where two runs of one build differ by themselves (playheads, the microphone's take lengths, the live view). Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* Merge the audio work and the incremental reload loopGabriel Schneider2 days
|\ | | | | | | | | | | | | The mixer's knee, newSound, sfxr, voice rate and groups, the scope's public pieces, micscope and spheres as examples; with the loader workaround for Zig 0.17.1's incremental linker and the panic-trace link. The README's hot-reload bullet takes the incremental loop's paragraph; zig build test: 164/164 steps, 132/132 tests. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * README: the incremental reload loop and its limitsGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | `zig build lib --watch -fincremental --debounce 0` brings edit to frame from 0.53 s to 43 ms on a small sketch and from about 1.2 s to 55 ms on drat-meout (medians of 10 on a loaded machine; compile 7-10 ms instead of 0.3-1 s). The hot-reload paragraph says so, and what it costs on Zig 0.17.1: a new linker behind a host workaround, what to do if a reload runs the wrong code, a larger library, resident compilers, and a multi-file save that may build twice. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * Keep a loaded sketch library's name valid, for panic tracesGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | A panic's stack trace finds a library's debug info by the name dlopen was given, and the load link was deleted right after loading: every frame in a sketch printed as ??? (a sketch that links libc; one that does not is not seen by Zig's own dl_iterate_phdr at all). Link and fd now live as long as the library is loaded, and Library.close removes them; a host that dies leaves its dangling links in $XDG_RUNTIME_DIR. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
| * Load libraries from Zig 0.17.1's incremental linkerGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | `-fincremental` selects Zig's new ELF linker, and 0.17.1's writes DT_VERSYM without DT_VERDEF or DT_VERNEED when nothing is versioned: glibc then reads a null version table at the first relocation against an export, and dlopen faults. When a library has that shape, the host loads a copy of it in an anonymous memory file with DT_VERSYM dropped (nothing in it is versioned, so nothing is lost); the build's own file is never written, and every other library loads as before. The copy is 10 ms for the counter's 28 MB library. Fixed in Zig after 0.17.1 (6d27011edb): the check then never fires. The reload test's second build goes through the new linker. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | README: what the sound code does now, and the truth about sound on the webGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The sound section says what each part does: voices with their rate and group and f.gain, when the host mixes them (once a frame, topping its queue up to 2048 samples, about 43 ms, ahead of the device), streams and the microphone, the mixer's curve, newSound and sfxr (from the changes before this one), and that --export writes no sound. Known limits said synthesised voices were silent on the web. Every voice is: web.zig drops each .voice command (and now .gain), whatever its sound; decodeSound gives .none; loadSound knows only files the page decoded. It now says so, and what does sound there: streams and the microphone. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
* | micscope: on the scope module, its copy of the scope code goneGabriel Schneider2 days
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | micscope carried the code the scope module was lifted from: seven shaders byte for byte, its layouts but for a comment, and a private live view (Live, analyseLive, drawLive) that was Scope.push, scroll and spectrum. Now the live view is ss.live, a scope.Scope, pushed the microphone and drawn with the panel's world rects and the camera (Views.camera), every frame, clipped away while a recording stands in for it so its columns keep up as before; the tuner reads its history from ss.live.gpu.tape. The take panels run scope.kernels and scope.pipelines over the tape with scope.layouts' blocks, wavePass and spectrogramPass inlined at their one use; maxFreq, min_freq and floor_db are the scope's. src/layouts.zig keeps only the tuner's blocks, the build compiles only the tuner's two shaders, and the tuner names notes with scope.midi, scope.hz and scope.note_names. Takes, transport and tuner are as they were. 1003 lines out, 91 in. Tests: zig build test, 67/67 steps, 10/10 tests (the live history's own test went with it; the scope module tests the same). Pictures: the four scripts' 18 screenshots, captured before and after with the same scripts and compared pixel by pixel (two runs before differ by themselves wherever wall-clock playback or microphone timing shows: the playheads, how far the live view has filled). The one difference not of that kind is the live spectrum: micscope made every image at most 132 rows, so its 184-row spectrum was stretched from 132; the scope makes it at its size, so the live spectrum's lines come out crisp (at most 86 in a channel, inside its rect). The take spectra keep micscope's 132. Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T