<feed xmlns='http://www.w3.org/2005/Atom'>
<title>computeranim.git/anim/src/hexdump.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-12T16:19:32Z</updated>
<entry>
<title>canim: the introduction as one video, with a chapter on registers</title>
<updated>2026-11-12T16:19:32Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-12T14:32:59Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=eab50d1c040774351f332a1568fa332c377860bd'/>
<id>urn:sha1:eab50d1c040774351f332a1568fa332c377860bd</id>
<content type='text'>
From the user. One scene, intro, in four chapters: memory, registers,
the stack, code and meaning (210 s). The registers chapter builds the
panel before the stack needs it: sixteen rows with their chains, rip
pinned on the code band and rsp and rbp on the stack's, rdi opened into
its parts as mov edi changes one byte, a call to malloc stepped over
with its result in rax, the registers a scene never changes folded. The
chapters join at seams that say their title and keep it as the clock's
label; one recording (from push(9), no agent, the heap from --heap) and
one clock.

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 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: a minimap in each pane; source wherever it can be had, libc's included</title>
<updated>2026-11-11T19:17:33Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T17:43:13Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6'/>
<id>urn:sha1:3093eb55ac4a7054f51f06ea2786b5f9c9ec73f6</id>
<content type='text'>
From the user. Each pane with more than it shows carries a strip of its
whole column at its right edge, the pane's window outlined and what
happens off it marked there; the corner minimap is gone and the dive
folds each column of the map into its pane's strip. The source panel
follows the pc into any file the build has: glibc's own, from the
distro's debuginfod by an optional step that caches them by build id
(zig build sources; nothing else touches the network), and musl's, from
Zig's lib directory. The syscalls scene shows open64.c on the way down,
and a new scene follows the same call through a Zig-built musl. A
graph's counts and inks are as of the moment shown.

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: 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: a call followed down to the kernel; rows that say what they do; the heap from the inside</title>
<updated>2026-11-11T04:16:48Z</updated>
<author>
<name>Gabriel Schneider</name>
<email>gbrls@0x4200.cafe</email>
</author>
<published>2026-11-11T03:06:30Z</published>
<link rel='alternate' type='text/html' href='https://git.0x4200.cafe/computeranim.git/commit/?id=c3d9f7ba5effd615374b1359ad98ecf801559f83'/>
<id>urn:sha1:c3d9f7ba5effd615374b1359ad98ecf801559f83</id>
<content type='text'>
From the user. The disassembly can descend: the syscalls scene is glibc's
hello by instruction, and open is followed from main through its PLT
stub, whose jmp reads the GOT, into libc's wrapper to the syscall row,
which crosses to the kernel's window under it, and back up. The band
keeps the calls so far as strace writes them. Operands lose their size
words and show a width as byte cells only where nothing else says it. A
compare shows its values and the flags it leaves, a jump the flags it
reads, lea its result, an indirect jump its target and the slot it read,
a call that has run its C form. The backtrace has its newest frame at
the bottom. A new scene shows glibc 2.44's heap from blocks that exist:
chunks read by fields (a size with its bits, a protected pointer), the
free list as arcs, the tcache in a loupe, the program's list over
malloc's own.

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>
</feed>
