<feed xmlns='http://www.w3.org/2005/Atom'>
<title>computeranim.git/anim/src/nodes.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-12T10:03:05Z</updated>
<entry>
<title>canim: the introduction, from the review</title>
<updated>2026-11-12T10:03:05Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-12T07:45:57Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=4907e35bc45d12102d0e09380994814fc2e0a369'/>
<id>urn:sha1:4907e35bc45d12102d0e09380994814fc2e0a369</id>
<content type='text'>
The introduction records the plain build (clang -O0, no instrumentation),
so reverse's frame is the compiler's own push, mov and sub. The stack
chapter says its convention once and keeps four free words over rsp so
a push moves the pin and nothing else; reverse's rows stand under main's
and are stepped, each touching its word, the call before the push, the
aim drawn head first to the row it returns to. The close-up frames the
bytes and the stack together with their 128 bytes marked. Nothing is
named before it is shown; offsets are written in hex as the operands are;
the dump folds into its tag; the map is announced before it is shown.

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: relations as one data-oriented subsystem; aim; the ASan pair; the introduction's chapters</title>
<updated>2026-11-12T04:40:04Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-12T02:46:02Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=60e07feef401d9044db3a1c925cb9d1f6d20dac9'/>
<id>urn:sha1:60e07feef401d9044db3a1c925cb9d1f6d20dac9</id>
<content type='text'>
From the user. Relations between panes are one subsystem: per-frame
tables of places and values in struct-of-arrays, owned by the frame;
the kinds one table of data; a resolver of pure passes (join, filter,
priority, cut) unit-tested on hand-written tables. Ported kinds draw
byte-identical frames; a synthetic map of 4000 places and 6000 values
resolves in 0.56 ms against the old table's 5.7. aim, a word holding a
code address tied to its row, is the first new kind, off unless a scene
turns it on.

The ASan pair: one overflow built plain and with ASan, recorded by
instruction; the frame as bytes eight a row; the plain run goes on alone
in the column, its return address aimed at main's row until the letters
reach it; the fault at ret. The introduction's three chapters are built
and tested, not yet exported. Annotations, rows and scrolls that changed
in one frame now fade; captions stand twelve seconds at most.

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: 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: what the second review found, fixed</title>
<updated>2026-11-11T07:20:25Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T05:11:12Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=5922ee911b9a6604f60dc83be36ba9e6c9abac98'/>
<id>urn:sha1:5922ee911b9a6604f60dc83be36ba9e6c9abac98</id>
<content type='text'>
A system call stepped over plays in order: the registers set, the
crossing from the call row with the kernel's window under it, the stores
after rax. A strike covers the bytes that changed. The band's view
changes with the argument framing. In the descent a callee sits under
its caller's return row, and rows fade before others glide. The heap
scene follows the storyboard's nine captions: pushes at a run without
marks, each free and the malloc that takes the head back walked, the
tcache's loupe over the stack and closed with each advance, a chunk in
neither list drawn, the freed node travelling to malloc's row. In the
dive the map falls into the corner and becomes the minimap; on the map
boxes are as long as their rows. A narrow read is shown at its width.
The chart checks captions and one-frame changes.

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: quieter marks, the stack's roles, the loupe, arcs, the minimap, the map and the dive</title>
<updated>2026-11-11T02:55:42Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T02:36:18Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=81d97a9e38c740a96af13a8a981878947a508bc0'/>
<id>urn:sha1:81d97a9e38c740a96af13a8a981878947a508bc0</id>
<content type='text'>
From the user's notes on the second videos. The current row is a white
wash, a strike a softened vermilion, held a turned corner. A stack row
has its offset from rsp and its role from the tracer (a saved register,
a local by name, argc and argv). The loupe is the telescope as a floating
panel: the memory round what a pointer leads to, a pointer inside it
opening the next. A pointer to a row of its own panel is an arc in a
lane, in dumps, loupes and the stack. Every scene has the minimap; the
map is the same moment with every panel at full length on 3840 by 2160,
and the list opens on it and dives to the working frame, each panel
travelling to its place. Recordings hold more round each stop.

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: what the review found; the band as two panels; list and sort by instruction</title>
<updated>2026-11-10T22:01:23Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T21:06:30Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=e63b0624f57472d40af32a006c32cc47d403b822'/>
<id>urn:sha1:e63b0624f57472d40af32a006c32cc47d403b822</id>
<content type='text'>
The first videos were reviewed frame by frame and the catalogue changed
with them. A lens is a drawing over the program column and its view over
the state column, so the stack keeps six slots, its window on the whole
frame. Operands are whole. list and sort are recorded by instruction
from main (record --from), so their registers strike, links reach nodes
and cells, rows that ran are marked and jumps are drawn. A call's node is
a projection of its return address; pins travel and keep their side; a
mark covers the bytes that changed, at the element's width; a syscall's
result is stored after the kernel returns it and every panel is of one
moment; fast passes are veiled; the clock stands still during a step;
captions get their reading time and a scene's first step comes by four
seconds.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
<entry>
<title>canim: the renderer speaks the design language</title>
<updated>2026-11-10T19:43:58Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T19:05:20Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=165bb6c1344b98de7bef1d3c2b72147b4a40797a'/>
<id>urn:sha1:165bb6c1344b98de7bef1d3c2b72147b4a40797a</id>
<content type='text'>
The blocks, their states and the tokens carry the catalogue's names:
atoms in ui, chain/reg/slot in rows, insn with its line column, jump lane
and annotations (read, write, taken or not, a call with its arguments, a
return, a syscall) in disasm, bytes and hexdump with field paper and the
reading column, the three splits and relayout in stage, the ties (thread,
link and pin, projection, echo). A lens is a band over the whole context,
its drawing left and its bytes right. Frames' spans on the stack, each
instruction's line and a callee's parameter count come from the tracer.

A gallery scene draws every block; the test compares six of its pages
with pictures kept in test/gallery, drawn from a recording kept there
too. The scenes are ported; the motion checks report no pop and no
metronome in any of them.

Co-Authored-By: Claude Fable 5.2 &lt;noreply@anthropic.com&gt;
</content>
</entry>
<entry>
<title>canim: animations of recordings, as a debugger's whole context with a lens beside it</title>
<updated>2026-11-10T18:14:31Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-10T17:48:26Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=7e9bf9e6e85c6c6e7a400d4fa0b43b77133ed3cb'/>
<id>urn:sha1:7e9bf9e6e85c6c6e7a400d4fa0b43b77133ed3cb</id>
<content type='text'>
A package of its own (anim/), on sketchbook's anim module and pardes's
syntax. A scene opens a recording, takes a cursor into it, and declares
blocks that read the moment the cursor is at: the state column (registers
each followed as a pointer and inked by where it points, the stack
telescope, the backtrace), the program column (the whole source, the
disassembly in address order, and the scene's lens: a node-link list over
a hexdump of its heap, array cells, a call tree, a syscall crossing), and
ties between them. Motion is a step told as a sentence (the line fires,
its effects cascade a level at a time, the mark moves on last), timed by
what the step contains; walk, hurry and sprint pace a loop. Five scenes
from real recordings of fib, a linked list, a sort and syscalls.

First drafts, by the agent's own handover: the frame of the design's
second revision, the hexdump lens and the ties; no disassembly
annotations, no gallery, scenes not yet reviewed against the mocks.
</content>
</entry>
</feed>
