<feed xmlns='http://www.w3.org/2005/Atom'>
<title>computeranim.git/anim/scenes/sqlite.zig, branch main</title>
<subtitle>Tracing debugger and animations of running programs (ztrace, canim)</subtitle>
<id>https://git.0x4200.cafe/computeranim.git/atom?h=main</id>
<link rel='self' href='https://git.0x4200.cafe/computeranim.git/atom?h=main'/>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/'/>
<updated>2026-11-12T00:45:12Z</updated>
<entry>
<title>canim: a column of text as an experiment; the disassembly tied to the stack</title>
<updated>2026-11-12T00:45:12Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T23:08:07Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=15de88cf82c187635c1989e91bfa639a10304066'/>
<id>urn:sha1:15de88cf82c187635c1989e91bfa639a10304066</id>
<content type='text'>
From the user. A scene may set its text in a column beside the panes a
beat is about: col.beat names the panes and their rows, where the text
is placed (beside, below, above, or on a drawing) and what it is level
with; panes the beat leaves out fold to their title bars on a shelf,
their changes struck there. Tried as two scenes beside the originals:
the call followed down (column) and a bubble on sort's rings
(column_sort).

annotation = .tied names the word an instruction touched and draws a
touch to its stack row; offsets count from the frame's base; rsp's pin
travels with its amount before the stack follows; .whole keeps the full
chain. carry = .arrow draws a value's way between memory and a register.

Co-Authored-By: Claude Opus 5.5 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>canim: the disassembly under the source everywhere; rings</title>
<updated>2026-11-11T22:11:00Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T20:42:07Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=b54c6776953d3243ab5b8e676e747713827ab320'/>
<id>urn:sha1:b54c6776953d3243ab5b8e676e747713827ab320</id>
<content type='text'>
From the user. In every split the disassembly stays under the source;
registers a scene never changes fold three to a row, and the stack takes
the room: nine to twenty slots where it had six. The graph's first form
is rings: a loop a ring its blocks sit on, an inner loop a smaller ring
touching its parent, a way out leaving along the tangent; layers stay
for functions without loops. Its layout comes from the code alone and it
shows nothing from after the moment: a block not reached yet is quiet
and is reached, a fold of what is not reached yet opens when the run
arrives. A pane unrolls from its strip into its whole column and rolls
back. The sqlite scene's strips move before their panes.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>canim: what the verification review found, fixed</title>
<updated>2026-11-11T13:14:30Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T12:41:45Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=390872b7bb9cdcf3e8095442af88af0dfcb40602'/>
<id>urn:sha1:390872b7bb9cdcf3e8095442af88af0dfcb40602</id>
<content type='text'>
A register's chain reads memory as its panel shows it, and follows again
only after the bytes land: rsi no longer shows what read returns before
the kernel writes it. Bytes keep their old value through the arm and
change at their own strike, in every dump, stack word and loupe. The
dive lands once. Captions lead what they name: the longest still in the
syscalls scene is 2.8 s where it was 13. Pins hold through a sprint; a
row of a view carries the pin of the register that points at it; a left
child's badge sits on its left shoulder; a log scrolls with the row that
arrives. The zoom scene's camera holds the disassembly's rows and the
stack in one view. Six programs, the title says now.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>canim: nothing changes in one frame; the map's space is used; the heap scene at its storyboard's length</title>
<updated>2026-11-11T09:50:11Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T09:49:10Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=378379807fb4cd751e90808c8363caddb365bcd8'/>
<id>urn:sha1:378379807fb4cd751e90808c8363caddb365bcd8</id>
<content type='text'>
The motion check counts a third of the one-frame changes it did: the
minimap's changes fade, and a register's value, a flag, a role, a pin's
names, a tag's note, a backtrace row, a call tree's node and a dump row
crossfade where they changed at once. What still fires is named in the
README; an encoder's keyframe and the gallery's cuts are exempt by name.
No caption stands over twelve seconds or under its reading time. The
heap scene is 78 s: what the storyboard does not narrate runs, and each
free's line cascades onto its call row (line stepping stops at a
breakpoint for that). On the map, leftover space holds the stack
continued, dumps round what the registers and the stack point at, open
loupes and the key: between 1% and 13% of a map is page, where it was 14%
to 42%.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
</content>
</entry>
<entry>
<title>canim: a continue is a wave; what arrives after a fade is plain; a pin only where its register points</title>
<updated>2026-11-11T01:06:03Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T01:02:01Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=8b5d0340c9f9b3168c67f04e57cfa03712ac992c'/>
<id>urn:sha1:8b5d0340c9f9b3168c67f04e57cfa03712ac992c</id>
<content type='text'>
From the designer's review of the SQLite scene. Between far stops the
changed registers strike two frames apart in pwndbg's order, and links
and pins set off with memory. A stack window or a dump that fades in
carries no marks of changes the viewer did not see. At rest a moved
register kept a pin at its old place as well, in every scene: gone. The
kernel's answer is filled before the return arrow leaves, and rax strikes
as it lands. Every dump has one reading, by type (a char quoted, a bool
by name); line numbers are as wide as the program's largest; pins' names
keep the side they came to. Names and measures follow the catalogue
(.loose, theme.metric.calls, time.pin, time.continue_wave).

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
<entry>
<title>canim: a scene from a real program: SQLite's row on its way to disk</title>
<updated>2026-11-10T23:27:13Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T23:16:54Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=dc3b58781420be6070fca896e55776bc27db905d'/>
<id>urn:sha1:dc3b58781420be6070fca896e55776bc27db905d</id>
<content type='text'>
Three inserts stopped at sqlite3BtreeInsert with their payloads read off
the caller's stack, the commit's backtrace from unixWrite up to main, the
pwrite64 crossing into the kernel, and page 2 as the kernel took it: its
header, its cell pointers and the three rows, read by field. The scene
is built only where SQLite's source is (-Dsqlite=DIR); its recording is
181 moments, 95 KB.

What a real program asked of the blocks: a dump read by the fields a
scene gives it, with the rows between collapsed; addresses of twelve
digits and line numbers of six; the backtrace as a lens's drawing; a
continue's motion (shared frames slide, a far window fades); memory drawn
only where the stop read it. In the kernel lens a register is framed as
carrying an argument only while it holds it at the stop shown, and an
allocator row is read only where an allocation follows the word.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
</feed>
