<feed xmlns='http://www.w3.org/2005/Atom'>
<title>sketchbook.git/examples/live/src/main.zig, branch main</title>
<subtitle>A small Zig platform for sketching games and toys</subtitle>
<id>https://git.0x4200.cafe/sketchbook.git/atom?h=main</id>
<link rel='self' href='https://git.0x4200.cafe/sketchbook.git/atom?h=main'/>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/'/>
<updated>2026-11-17T15:15:01Z</updated>
<entry>
<title>examples/live: each byte's place is laid out when the text moves, not every frame: the places and their layout are kept in the Session beside the revision they were made at, and made again at a jump (a revision counts keys, it does not name a text); with the text library optimised, drawing the code in a Debug host goes from 2.85 ms to 0.38 ms a frame at the storyboard's 320 bytes and from 28 ms to 5.3 ms at 3.5 KiB; zig build test 92/92 steps</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T12:56:27Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=b52da82a9405ac4c9f1c18e2ef53594d5c1f6721'/>
<id>urn:sha1:b52da82a9405ac4c9f1c18e2ef53594d5c1f6721</id>
<content type='text'>
Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the canvas is the window's pixels, so the code is sharp</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T12:35:51Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=3373059db38e3b0bbf6105e91180300a4f1c6ead'/>
<id>urn:sha1:3373059db38e3b0bbf6105e91180300a4f1c6ead</id>
<content type='text'>
With a GPU the canvas is an offscreen texture at canvas pixels, which
the host scales (linearly) to the window: the demo's fixed 1280x720 in a
larger window drew its code at 16 px and showed it blurred. `draw` sets
the canvas to the room the host has (`window_width`/`height`, at least
640x360), so a glyph lands on a whole pixel of the display at any window
size, and lays out by it: the picture fills it, the scope sits at its
bottom, the mode and time at its right. The picture is drawn at most 720
rows high (half that past 64 instructions, as before) and scaled up, so
a large window costs the GPU what 1280x720 did; square units hold, as
its width follows the room's aspect.

Headless the room is the canvas unless `--size` gives one, so every test
picture is the one before, pixel for pixel. The display here is a 3840x2160
screen at scale 1, where this is all device-sharp needs; at a density of
2 the window is not asked for its pixels (SDL_WINDOW_HIGH_PIXEL_DENSITY),
so the compositor scales it: a change to the host, not to the demo.

zig build test: 92 of 92 steps.

Co-Authored-By: Claude Opus 5.5 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the name a line defines a step larger, by its syntax node</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T12:34:02Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=ae807468f15e81ea3b62fee4741ee6b246e6df8b'/>
<id>urn:sha1:ae807468f15e81ea3b62fee4741ee6b246e6df8b</id>
<content type='text'>
`paragraph` gives a span the scale 1.25 * 1.2 (`step`, 19.5 px against
16.25) where the grammar's class is the one queries/highlights.scm gives
a definition's name node, `(definition name: (name) @keyword)`, and that
node alone: chosen from the tree, not from the text's shape. The names
are 12 pixels a character to the rest's 10, and a line with one is 26
high to 22. Everything of the last change lands on the mixed sizes, as
everything is placed by sk.text.places: ranges, the carets, the
problem's mark, the band, and the press that finds a number to drag.

The scripts follow the layout: 220 on line 1 is now at x 182 to 212
(after the larger `out`), so the drags in test/live.script and
test/story.script press at 187 instead of 181, every move 6 pixels on;
the values they expect are the same.

zig build test: 92 of 92 steps.

Co-Authored-By: Claude Opus 5.5 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the code drawn as a paragraph, every place measured</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T12:32:28Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=ccdb7e478248fcf8489eb8a6f9b58178107a26f5'/>
<id>urn:sha1:ccdb7e478248fcf8489eb8a6f9b58178107a26f5</id>
<content type='text'>
`code` draws the editor's text with one f.paragraph: the code face at
1.25, a span in its class's ink where the grammar's class changes
(`paragraph`, which `update` calls too). Every range, the caret and the
problem's mark are boxes from sk.text.places, one layout of the same
paragraph: a byte's box runs from its place to the next byte's on its
line (a `\n` and the end a space wide), a range a box a line it covers.
The band is the layout's size. The constant 10x22 cell goes: `update`
finds the byte under a press with the same places (the last byte whose
line holds the pointer's y and whose x is at or left of it), then the
number token there by the grammar's parse, as before.

The pictures do not move: at this face and size the measured advance is
10 and the line 22, so every storyboard beat's code band is the part 2
picture's, pixel for pixel (0 of 960x600 differ in each of 11 beats;
only the scope and the lead in the corner, which vary run to run, do).

zig build test: 92 of 92 steps.

Co-Authored-By: Claude Opus 5.5 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: drag a number, the program following as it moves</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T10:58:27Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=4350e6840940da0b7af800faf5a1455a1de1908e'/>
<id>urn:sha1:4350e6840940da0b7af800faf5a1455a1de1908e</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: hear this, the expression a node walk leaves the selection on</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T10:57:28Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=610ffe373f0f5dd5ccb59bf575f5479ad1ecdbaf'/>
<id>urn:sha1:610ffe373f0f5dd5ccb59bf575f5479ad1ecdbaf</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the language's grammar, its colours and a new line's indent</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T10:51:24Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=f37732448a2a374281c9610d05a10315e97dcbbf'/>
<id>urn:sha1:f37732448a2a374281c9610d05a10315e97dcbbf</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the editor's text drawn, its ranges, caret and mode</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T10:48:52Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=fad609ddb13cbc0f33150fc3a9dfc25051641cd8'/>
<id>urn:sha1:fad609ddb13cbc0f33150fc3a9dfc25051641cd8</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: pardes's editor in State, typed with helix's keys</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T10:42:48Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=ed185f305731309cbddb981166678a552f2fda84'/>
<id>urn:sha1:ed185f305731309cbddb981166678a552f2fda84</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
<entry>
<title>examples/live: the scripted proof, a session played back and sought</title>
<updated>2026-11-17T15:15:01Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-17T09:10:20Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/sketchbook.git/commit/?id=8dc369f343fda8f54756376728f4690386c20a69'/>
<id>urn:sha1:8dc369f343fda8f54756376728f4690386c20a69</id>
<content type='text'>
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 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNBECMWcJD5pdS4SR6T
</content>
</entry>
</feed>
