# canim Animations of how a program ran, from a `ztrace` recording, on sketchbook's `anim` (live scenes). The frame is a debugger's whole context, as pwndbg shows it, with one lens over it; the names, sizes and colours of everything in it are the design language's catalogue (`../design/README.md`), and how it moves is `../design/motion.md`. Code and design share one set of names: a block of the catalogue is a function or a component of the same name here. ```sh zig build record # the recordings, into zig-out/recordings zig build sources # fetch the library sources their lines name (the only step that uses the network) zig build run -Dscene=fib # a scene in a window, hot reload (zig build lib --watch) zig build export -Dscene=fib -- DIR --fps 60 --size 1920x1080 # frames as PNGs (or - for raw RGBA) zig build videos -Doptimize=ReleaseFast # every scene: out/NAME-1080.mp4 and out/NAME-2160.mp4 (x264, 60 fps, aq-mode=0) zig build test # unit tests, each scene run headless, and the gallery against its pictures zig build gallery # the gallery's pictures drawn anew into test/gallery zig build bench # what a recording costs a frame zig build bench -- NAME BY [FUNCTION] # a recording's steps (BY: moment, line, over), with what each changed zig build bench -- relations # the relations' passes timed on a working frame's tables and a map's (CANIM_RELATIONS=1 on a scene: each frame's counts) python3 tools/chart.py chart out/fib-1080.mp4 --out out/motion/fib # the designer's timing chart and checks (POP, CROWD, METRONOME, CAPTION, AIR) CANIM_MAP=1 zig build export -Dscene=fib -- DIR --size 3840x2160 # every frame the scene's map filling it, as `list` opens on it: a map at 1:1 ``` Needs what sketchbook and ztrace need, and `setarch`, `clang` (the pass plugin), `ffmpeg` (videos), python with numpy and Pillow (charts), `curl` (`zig build sources` alone). The `sqlite` scene also needs SQLite's amalgamation (`-Dsqlite=DIR`, the directory of `sqlite3.c` and `sqlite3.h`; by default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`) and `objdump`; where the directory is not there the scene is not made, and the rest builds and tests as before. Dependencies are by path (`..` is ztrace, `../../sketchbook`, `../../02-pardes-code`); `zig-pkg` is a symlink to pardes's. ## A scene ```zig const anim = @import("anim"); const canim = @import("canim"); const recordings = @import("recordings"); pub const background = canim.background; pub const scene = anim.Live(frame, struct {}); fn frame(s: *anim.Frame) void { const rec = canim.open(recordings.steps); // a recording the build made and embedded var at = canim.cursor(s, rec, rec.lineMoment(10, rec.call("main", 0).enter)); at.levels = .{ .idea = .calls, .source_rows = 10 }; // what a step is timed by at.journey(.line, rec.call("fib", 0).exit.?); // the clock's whole way // The stage: the band (the lens) over the program column and the state column. const ctx = canim.context(s, at, .{ .split = canim.layout.split.subject }); const tree = canim.callTree(s, .{ .cursor = at, .stage = ctx.stage, .function = "fib" }); const joins = ctx.ties(s); // thread, link, projection; add it last var says: canim.Narrator = .{}; canim.establish(s, .{ ctx.clock, ctx.registers, ctx.stack, ctx.source, ctx.disasm, tree, joins }); says.line(s, "`fib` calls itself."); // old caption out, a gap, new one in, then stillness at.walk(s, .line, rec.lineMoment(6, rec.call("fib", 0).enter)); // each step in full, timed by its content at.hurry(s, .line, rec.call("fib", 4).enter, .{}); // a run: ramps in and out, counted on the clock ctx.stage.relayout(s, canim.layout.split.none); // a change of split, 48 f s.wait(canim.theme.time.before_cut); } ``` `frame` runs every frame and builds the whole timeline each time; a component is an `anim` object (`fadeIn`, `fadeOut`) that draws the program's state at the cursor, at the box its `Stage` gives it now. **The cursor** (`src/cursor.zig`) moves in steps from one moment straight to a later one (`Recording.Stop`: `.moment`, `.line`, `.over`, `.call`, `.syscall`). For each step it writes a timetable, a `Plan`: the cascade. The line fires (12 f); each level the step touched strikes 18 f after the one before (after the last of its registers, which strike 6 f apart), in the order CPU, memory, idea (a level the scene does not show, or the step did not touch, or touched nothing drawn, gives up its slot; a drawing made of bytes strikes when the projection from them arrives, 24 f after them, and its write 12 f later still; a call's node when the projection from its return address does, 36 f after); the writes of one step strike 6 f apart (those that take a place: not a stack frame the step has already left, a callee's words under rsp), each keeping its old value through its arm until its own strike lands (s+3: `Now.struckAgo`, `shownAt`; what the kernel fills, once the last byte of the word lands); a register's chain reads memory as the panels show it: from the bytes' strike its later hops fade out (3 f), and 4 f after they land they are followed again (`extend`, `Now.following`); a hold to read; the mark advances last; a rest. `walk` plays steps in full, `hurry` ramps the pace down and up again (each step 0.6 of the one before) to a run (0.30 s a step: nothing struck, no held corner, no arc, a dump's values crossfading over 8 f; the arcs fade back in as it ends) or a sprint, `step` takes an explicit `Plan` (`Array.swap`, `syscalls.step`), and `continue` goes to a stop far from this one (a breakpoint): the line it leaves fires, the registers it changed strike in a wave 2 f apart in pwndbg's order (fill 6 f, no arm, no pulse), then memory and the idea, a 36 f hold, the mark out and in (6 f each, the source fading through first if far), a 24 f rest. Components read it through `Cursor.now(at)`; each pane's minimap (its strip) reads the same values 6 f behind and five more mirrors a frame apart, with the panes' windows as they were as long ago (`Cursor.lags`, `time.minimap_lag`, `time.minimap_fade`: its drawings are averaged), so nothing on it starts on a primary onset's frame and nothing on it moves a pixel in one. **The annotation and the carry, two knobs** (`Levels`, design/README.md `insn` and "4. Ties"). `at.levels.annotation`, read when `canim.context` is made: `.tied` (the default) names the word an instruction reads or writes and gives one hop (`next → 405010`, `prev ← 0`, a global by its data name with its whole chain, `head → 407050 ← 9`), a register's first value (`rax 405010`), and a move of rsp or rbp first (`rsp -8 · saved rbp`, `fib(4) · rsp -8`, `rbp = rsp`, `→ 4011ad main+45 · rsp +8`); the stack counts its offsets from the frame's base (`· offsets from rbp`) with two `free` words of headroom over rsp, and a walked step goes cause to effect: its touch from the row to the word, the word, rsp's or rbp's pin travelling with the amount on it, the window following last. `.whole` is pwndbg's chain, offsets from rsp and the old cascade, for a scene whose story is the address itself (heap, sqlite, the gallery). `at.levels.carry` (`.off` by default, `.arrow`, `.value`, `.after_touch`: the arrow after the instruction's touch, a store's too) is read at each step, so a beat can set it before a walk and put it back after. `at.levels.introduction` (read when the context is made) says what the working frame leaves to the eye: the stack's offsets and a pin's amount with `0x` where hex and decimal differ (`-8`, `+0x10`), a return address's role (`the way back`), a store of the value its word held struck as any write: ```zig at.levels = .{ .idea = .calls, .source_rows = 8, .annotation = .whole }; // before canim.context at.levels.carry = .arrow; at.walk(s, .moment, to); at.levels.carry = .off; // the value's way, for one beat at.aim(s, .standing); /* ... */ at.aim(s, .off); // a word holding a code address tied to its row, for some beats at.aim(s, .drawn); /* ... */ at.aim(s, .standing); // drawn as a step's, at full ink, then down to 60% ``` `aim` is off by default everywhere (design/README.md, "4. Ties": the author's to turn on, never the budget's): `.standing` draws, for the words on screen in memory that hold the address of an instruction whose row is shown, one tie to that row, in and out with the knob (18 f, over what follows); `.step` the one of the word a walked step writes or reads; `.drawn` stands it drawn as a step's is (head first at full ink, 18 f, the row's address framed as it lands, 6 f), a `.standing` after it falling to 60% (18 f). Its head is 10 by 10. **The text column** (`src/column.zig`, design/README.md "column"). A scene can tell its beats with the panes a beat is about in the left column and its text beside them, level with the row it speaks of, every other pane folded to its tag on the shelf (y 48), a register struck on its tag as on its row. It is the author's instrument: each beat says which panes stand and with how many rows (`canim.column_rest`: what the column has left), where its text is placed (`.beside`; `.below`, the working frame whole with its caption; `.above` or `.on` a drawing across both columns), what the text is level with (`.pc`, the default: the row the beat's first step is on; `.{ .row = addr }`, `.{ .head = "open" }`, `.floor` (where the kernel's window opens), `.{ .block = addr }`, `.{ .y = 744 }`) and where its stem points (`.level`, `.none`, `.{ .to = … }`), and the folded panes' notes (the registers', the source's and the disassembly's are computed where the beat gives none). Between beats, in a rest, the last text dims; the panes that leave fade (6 f) and fold where they stand, closing to their tags, which then travel to the shelf (18 f: only a tag crosses another pane, never a panel); those that stay glide (24 f; a pane crossing to the other column 24 f down its own, 24 f across), one that changes its height keeping its rows (a descent's rows glide between its two heights' layouts, the rest fading at the moving edge; a source's window glides); those that come unfold (18 f) and fade in (6 f); an older text in the way glides up (or down where there is no room above), the new one arrives with its stem, and the stem draws back as the step fires. A bubble about a folded pane (its level a row of a folded disassembly, a block of a folded drawing) points at the pane's tag on the shelf. A bubble still being read more than 84 f after its beat's steps is said once on stderr (`column: bubble N is still read …`), unless the beat says its rest is meant (`.held = true`). Three texts stand at most; at a run only the newest. `scenes/column.zig` is the trial (`open` followed down), `scenes/column_sort.zig` the wide placements on sort's rings: ```zig const col = canim.column(s, ctx, .{ .lens = log, .titles = .{ .band = "system calls", .view = "its bytes" } }); col.beat(s, .{ .at = .below, .say = "A program cannot open a file itself.\nIt asks the kernel, and waits." }); cur.walk(s, .line, rec.lineMoment(6, main.enter)); col.beat(s, .{ .panes = &.{ .{ .source, 3 }, .{ .disasm, 11 }, .{ .stack, canim.column_rest } }, .say = "The call pushes where to come back to, `main+45`, and goes down to open's stub.", .level = .{ .row = call }, // default: the pc's row .notes = &.{.{ .band, "none yet" }}, }); canim.descent.step(cur, s, .moment); ``` ## The scenes | Scene | Shows | Split, lens | Recording | | --- | --- | --- | --- | | `title` | the series (six programs, named) and the legend of the marks the scenes use | a card | | | `fib` | recursion: each call a frame and a node | `subject`, `calls` | `steps` | | `list` | a list reversed: each `next` turned; it opens on the map and dives into the frame; after the first load the pointer loaded opens in a loupe, and the `next` in it one deeper | `subject`, `nodes` | `list` | | `sort` | insertion sort as its blocks, its loops as rings: one trip of the inner loop walked a block at a time (each block's rows a cascade onto its last, then `leave` along the edge it takes: the compare's chips framed, the edge drawn gold, the mark round the ring, the target's count struck; the swap's block `reach`ed the first time, its pill filling; `turn` round the inner ring's foot, `1 turn` struck at its centre), the disassembly unrolled for a beat (the function whole, `unroll` and `roll`), the next trip at a run, the long middle a sprint on the map (`surface`, the gold going round the rings and down the linear column, the counts growing, `dive`), the last value's trip walked again, the way out run | `blocks` (`graph.Blocks`, `rings`: the drawing 880 by 344 over the program column, no view, the source six lines and the disassembly eleven under it, the registers and a stack of twenty beside); on the map the same drawing over the source, the disassembly linear beside it (`Context.Options.graph`) | `sort` | | `syscalls` | glibc's `hello`, by instruction from main: `open` followed down (main's call ringed, the PLT's stub passed, libc's wrapper run to its last three instructions and those walked, its source beside it where the build has it (open64.c, and sysdep-cancel.h where the pc is in what that header's macro made; `zig build sources`), the kernel's window at the floor with the call in C's form and `returns`, and back up), then `read`, `close`, `write` stepped over, each in three parts: the instructions before the call a cascade onto the call row, the crossing from that row with the kernel's window opening under it (the rows after it making room), the stores after it 18 f after rax | `beside`, `syscalls` (the calls so far, as strace writes them); the disassembly a `descent` (`Context.Options.descent`) | `hello` | | `musl` | the same `hello` built by Zig against musl, static: `open` followed down with no PLT and no GOT, the source panel following the pc through musl's own files (open.c, `__syscall_cp.c`, the one line of `syscall_arch.h` that is the `syscall`), the kernel's window, and back up to `main` | `beside`, `syscalls`; the disassembly a `descent` | `musl` | | `heap` | glibc's malloc under a list of three: three pushes, two pops, a push, told by motion.md's storyboard (nine captions; pushes 2 and 3 at a run; each `free` and the `malloc` that takes the head back walked; what the storyboard does not narrate runs: the calls into push and pop with their prologues, the returns to main but the one under the second free's long caption); the chunks by fields (`size`, `protected`, `key`), the program's list over the tcache's free list with its `bin` (a chunk in neither list drawn in the program's row, unarrowed), the tcache in a loupe over the stack, its stem down the gutter from its chunk's row, opened in each step that changes the tcache and closed at its advance | `subject`, the scene's own drawing (`nodes` in two rows) and view, both on its map too | `heap` | | `zoom` | one line of C as its instructions, the call's bytes | `none`, the camera at x1.16 on the instructions and the stack in one view, cause and effect (the stack's window set before the move and held); the map's drawing the calls of `fib` (`Map.drawing`) | `steps` | | `sqlite` | a row's way to disk in SQLite: from `sqlite3_step` to `sqlite3BtreeInsert` (three continues, the row's struct on the stack), the commit's `unixWrite` nine calls under `main`, `pwrite64` of page 2 into the kernel, and the page read as a B-tree leaf | `subject`, `backtrace` (`Context.Options.backtrace`), then `syscalls`; its view a `hexdump.Dump`; as the caption names them, rdi's `BtCursor` opened in a loupe, then rsi linked to its row in the view (`Context.tiesWith`); the page's fields named a group at a time, 2 s apart; the backtrace lens drawn on its map | `sqlite` | | `gallery` | every block in its states, a page or a state each 3 s; at 21 s the `blocks` lens (sort's rings at rest, `leave` mid-way, a `turn` landing with its ring's count struck; libc's `open` in `layers` at its `syscall`, what it has not reached folded), at 24 s the moves of a first time (sort's first swap `reach`ed, its pill filling; `open` stepped past its `syscall`, its fold mid-`unfold`; sort in `layers` panned to the pc; the fold open, at rest). Its context pages fold the registers its one step does not change | all three, `blocks` | `gallery`, and for the graph pages `test/gallery/sort.ztrace` and `hello.ztrace` (the second page's picture keeps the old name `graph-map.png`) | | `column` | the text column (design/motion.md, "A scene in the column"): `syscalls`' story on the same recording and steps, beat by beat as the storyboard's table C1 to C12 has it, its texts as it cuts them (C4's 57 characters): the opening `below` (the working frame whole, its caption); the arguments beside the source and the disassembly over the registers; the call and the stub's jmp beside the descent over a stack of twenty words (the touch from the call row down the gutter to the free word, rsp's pin climbing); the wrapper at a run over a source of two lines, the text level with open's head; its last three beside the registers; the crossing beside a descent of twenty-four rows, the text level with the kernel's floor; back up, the text at main's call row; `read`, `close`, `write` stepped over, the bytes over the source, each text beside its call row; the close `below`. Every other pane on the shelf, the registers' strikes on their tag | the column (`column.zig`), the working frame `beside` at the opening and the close | `hello` | | `column_sort` | the column's wide placements on sort's first trip: the opening `below`, then the rings across both columns twice their size, the others on the shelf (`sort.c line 12`, `disassembly jne …`), a text `on` the drawing in the corner the rings leave free with its stem round the drawing's top to the pc's block; then a text `above` it; then the working frame again | `blocks`, then the drawing across both columns (`Stage.zoom`) | `sort` | | `intro` | the introduction, one video in four chapters (design/motion.md, "A scene: the introduction"), each a function of its own file the scene calls in order (`intro_memory.zig`, `intro_registers.zig`, `intro_stack.zig`, `intro_code.zig`), each opening on the last picture of the one before at a seam (`title`: 30 f still, the texts out, the title said in the caption's place, `II Registers`, the clock's label crossfading to the chapter's, 60 f still, the opening under the title; mock 62). **I Memory** (I1 to I10): the 128 bytes at the top of the stack under the camera at x2 (`128 bytes at 7fffffffecc8`); `regroup` (the return address walked, the rest at a run); three addresses framed; the address space to scale in the column (`segments`, `enlarge`), texts beside; the dump's `tie` and `link` onto the stack's box; a visit at x2; `ink`; three chains. **II Registers** (II1 to II8, mocks 58 to 61), from push(9) at line 40, before I's moment: the 128 bytes fold to the shelf (rising to its height, then along it); the registers at the state column's top, every register a row, a row at a time, the name then the chain; rip's row, `◂ rip` on list's code band (`Segments.pins`, `ink`'s echo), `frame up`, the clock and its label beside it; rbp and rsp framed, their pin in the stack's band, rax, rcx, rsi with the heap's; push's six rows at the program column's foot with no panel round them, the texts beside on the left from here (an older one gliding down under a newer, three at most: `Asides.floor`); rip and its row framed together; rdi opened into its `parts` (`unpack`), `mov edi, 0x10` walked, the operand, the part `edi` and its bytes framed together, the byte `09` to `10` struck with the row's `rdi 0x10 16`, `pack`; `call malloc@plt` stepped over (`Cursor.over`: rdi framed with its hanging row, rax struck first with the row's `malloc(16) = 405050`, then rcx, rsi, rdi in a wave); a continue to reverse's first instruction; `fold` (the ten registers never changed into their cells, the rule last), the 128 bytes back at the rows III's stack gives them. **III The stack** (III1 to III5, mock 31), on II's context: the words become the stack panel where they stand, the convention, rsp's pin and link, the call (main's rows, the `aim`), `push rbp`, `mov rbp, rsp`, `sub rsp` walked, roles, spans, `frame up` on the disassembly and the stack. **IV Code and meaning** (IV1 to IV5, mocks 32, 33, 36): the code's bytes, `decode`, `align`, `stack` into the working frame (the one clock stepped on to the load, 185 to 191), the nodes from the heap's bytes, the minimaps, the map | the working frame `below` and the column (I); the working frame `below`, then texts beside (II, III); `aligned`, texts above, then `subject`, `nodes`, the map (IV) | `intro`: one clock from its first stop at line 40, `moment 6 of 193` to `191` | | `asan` | plain against AddressSanitizer on `overflow.c` (design/motion.md, "A scene: ASan against a plain build", A1 to A16): a `pair` (A1 to A9, A14 to A16: the shared source, each run's disassembly, registers and frame as bytes eight a row with ASan's shadow byte beside each row, `only here` and `differs` bars, the parting framed `attention`, ASan's stderr in place of its registers once stopped) and the column for A10 to A13 (ASan folded to one shelf tag, its report's first line on it; plain's disassembly a descent, main's window over fill's whole; plain's frame the column's rest; each text level with the field the letter lands in; `aim = .standing`: the return address aims at main's row after the call, glides to `fill+1` at i = 24 and frays at i = 25); i = 27 held 4.9 s (mock 38, the poster); the fault at `ret` (SIGSEGV, rip stays) | `pair.split`, then the column | `overflow`, `overflow_asan`, `overflow_report` | ## The blocks The catalogue's layers, and where each block is. Every block is drawn in every state the code has in the `gallery` scene. | Layer | Block | Where | Notes | | --- | --- | --- | --- | | 0 tokens | grid, colour, type, the splits | `src/theme.zig` | per "Token changes" (`layout.split` and `layout.fit`, `metric.registers` (the quiet cells), `time.unroll` (`unroll`, `roll`, a far jump's travel; the extend's 4 f is `time.extend` now), `metric.calls`, `time.pin`, `time.continue_wave`, `time.relayout_fade` there; the insn's character counts gone); JetBrains Mono NL (`.code*` faces) for all mono, Medium under 30 | | 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`; and at a view's row's end, `Ui.pinEnd`), `bracket` (`quiet`, `tie`, `thread`), `tag` | `src/ui.zig` (`Ui.address`, `.value`, `.arrow`, `.written`, `.corner`, `.read`, `.cellWritten`, `.cellRead`, `.current`, `.trail`, `.unknown`, `.chip`, `.pinRow`, `.pinUnder`, `.bracket`, `.panel`) | marks as mock 15's column B: `current` the white wash (`color.wash`) and the gold plaque; `struck` the softened paper (`color.struck`) with bold bright digits; `held` a turned corner (9; 12 on a lens's cell), in over the cool's last 6 f (`Heat.corner`, `time.strike.corner`); `armed`, `read` | | | `byte` | `src/rows.zig` `bytes` | `number`, `pointer`, `text` (a string's ink), `loose` (a byte of no field: the allocator's, padding, past what a dump is of), `unread`; `pad`; `bytesAt` moves the bytes right of a long (stack) address, by the dump's widest; a write's arm, strike and held corner cover the bytes whose value changed, first to last (`Run.changed`, `Now.changedBytes`), struck a byte a frame from the low address (what a read fills, 2 f apart); until its strike lands (s+3) a run keeps its old bytes and their reading, through the arm, read by its old field where the step retypes it (`hexdump.keepOld`, `Fields.was`) | | 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more`; a register's reads memory as the panels show it, the step's bytes from their strike (s+3): its later hops fade out from the strike and are followed again 4 f after the bytes land (`Now.following`, `Marks.hops`). `slot`: pins from 16, the offset ranged right to 172 (under `tied` from the frame's base, the call frame information's CFA register: `context.frameBase`; under `whole` from rsp; a `free` word's crossfading), the address at 184, the chain, its role ranged right where the room ends (48 sooner in a pane: its strip), from `zt.telescope.slots` (`saved rbx`, a local's name in primary, `n, high half` for a narrower local in the word's top four bytes, `argc`, `argv[0]`, `argv end`, `envp end`, `auxv`; `i, n` where locals share a word (`Slot.also`); the stack protector's copy `canary`; nothing for a return address or `.none`). `bytes`: the bracket at 24, the address at 34, the bytes 12 after it and at 132 at least | | | `arc` | `src/rows.zig` (`Arcs`), `src/hexdump.zig` (`pointerArcs`) | a pointer to a row of its own panel: lanes at 4, 10, 16 in a dump or a loupe, 4 and 10 on the stack; longest outermost, a chain in one lane; standing at 60% toward the page, full in the step that writes or reads it and always in a loupe; rewritten: the old dashed with the arm, fading from 6 f after the strike as the new draws (12 f), quieting with the cool; a lane change glides while the arc that causes it draws or fades (`Arcs.assign`, with and without the arcs on their way); a stub to the rule for a target in the region past the window, only in its step; a saved rbp's only in its step, going with its advance (18 f); a dump withholds the arcs an open loupe carries | | | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564 (540 in a pane, whose strip takes 48 of the row; `map.content`); size words dropped from every operand, a `width` of byte cells (`metric.width`) after the `]` where no register outside the brackets has the access's size and the mnemonic does not fix it; `nop` and `endbr64` faint; a PLT target named (`401070 open@plt`); the annotation from 564 or a character after the operands, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`, `waiting`, `pass`; the jump lane from the jump just before the pc's moment. The row's detail, every value the recording's at that moment: a compare's two values and the flags it leaves as chips (those the conditional after it reads; CF ZF SF OF when none); a conditional's `taken`/`not taken · reads` and its flags, `→ target` when it leaves the window, and while it runs the setting row's chips and rip's framed as read (an echo); `lea`'s `= value`; a call through memory or a register `→ target name · read from open@got, 403fd8` (out of room the slot goes, then the digits); a call through a PLT stub by the function it reaches (`the resolver` while its slot is lazy); `fs:[0x28]` as the stack's canary (`canary` where the row has no room); a `rep`'s count and step; `syscall` with its name and number, its arguments under it by register, typed (`-100 AT_FDCWD`, `O_RDONLY`), the rows they hang over giving up their own annotation; a call that has run in C's form with its result (`read(3, …) = 15`, an address in hex: `malloc(16) = 405050`; out of room the arguments go from the right, the result stays); a call stepped over (`Cursor.over`, `Plan.result`): its callee and its arguments hanging under it, framed as read from 18 f, then as rax strikes (48) its C form and its result, struck with rax (an echo), the hanging rows going (6 f); a memory access narrower than a word read at its width (`rows.narrow`: `7fffffffecc4 ◂ 15`). The annotation's form is the scene's knob (`Levels.annotation`, above): under `tied` a word the stack shows by its role and one hop (`tiedWord`; a local's name, the one of a shared word that holds the bytes accessed; an unnamed word, a spill, by its address and one hop; a store's value cut with `…`, never dropped), a heap word with a view on screen by its address and one hop, a word no pane shows its whole chain with its data name in place of the address (`head → 407050 ← 9`); a register set its first value; a move of rsp or rbp first (`stackMove`: `rsp -8 · saved rbp`, the role from the push's own stop, `rsp -0x20 4 words`, `rbp = rsp`, `leave`'s, `fib(4) · rsp -8`, `→ 4011ad main+45 · rsp +8`), the amount struck as rsp's pin lands; the row publishes where the touch leaves it (`ties.touch_row`); under `whole` the row as before. What the step leaves on its own row (`lea`'s `=`, a register's first value, a compare's flags, the canary's word, `rbp = rsp`'s value) fades in from its strike (12 f; at a run the run's ease); a row the advance changes (its state, its trail, its line number, the moment its annotation reads: the pc's row back on itself, a loop's turn at a run) is drawn as before and as after the advance and crossfades over its middle, at a run over the whole advance (8 f, the run's ease). A `pair`'s (`Disasm.run`, `.aligned`, `.stopped`): its run's name on the tag (`plain · fill`); the pc's line's first row at the window's top while the pc is in its upper half; a stopped run's call `4e8450 __asan_report_store1 never returned`, its plaque gone, the tag `· stopped`. The introduction's (`Levels.introduction`): a register's first value struck with it (the parts' bytes are), and no `· rsp -8` on a call row (it walks none); `Disasm.mark_in`, the pc's mark coming after the rows it stands on | | | `descent` | `src/descent.zig` (`Descent`, `step`) | the disassembly a call deep: the root's window on top (main), each callee's under the row that called it (that row `waiting`, ringed, its annotation the call in C's form), a PLT stub gone through kept as its `jmp`, `pass`; a head row over each window (the name at 40, Go Medium 18; what it is ranged right: `libc.so.6 · open64.c` (the file of its function's entry, where the build has the source), `libc.so.6 · no source`, `the PLT · its jmp reads open@got, 403fd8`, `the PLT, jumped through`); the call lane at x 14; the nearest caller takes the rows the deepest does not use, all above its call row (one row after it, the return row, the callee's head directly under that), and where its function starts first the rest go back to the deepest window; three code windows at most, the rest one `more` row; each window's addresses its own width; the tag the deepest function and its module (`open · libc.so.6`); at a `syscall` (and the stop after it) the floor's three rows are the kernel's: in a crossing the lane down from the plaque (3, vellum), the window filling down, `the kernel` and `openat, system call 257`, the call in C's form, `returns` struck, `rcx, r11: clobbered`, the answer climbing the lane (24 f, `glide`), the window drawing back at the advance. A crossing stepped over opens the same window under the call row, past the arguments hanging under it, the rows after them making room (18 f) and closing up with the window. Every row keyed (an address, a head), so a step is the rows both stops have gliding (and a change of the panel's height at rest the rows both heights' layouts have, `Stage.resizing`; a row's shared digits are of its own window's rows that show) and the rest leaving or arriving on its verb's timetable, in two moves, never at once: `descend` (2.9 s: the given-up rows fade 66–78, the kept ones glide 78–96, ring 84–96, lane 96–114, head 108–120, rows 114–138), on through a stub's `jmp` (2.2 s), `ascend` (2.5 s: the window closes 48–72, lane back 72–84, the kept rows glide 84–102, the given-up ones fade in 102–114), `cross` (`syscalls.step`); a row whose state the verb changes (the call row to `waiting` with its hanging arguments, a jmp to `pass`, a waiting call taking its result) crossfades; with it the source's line `waiting` where the pc is in code without source (ringed, the tag `main waits at line 6 · the pc is in libc's open`, crossfading over the 12 f before the advance, as a stack span's name does) and the thread waiting (primary, 2); where the build has the library's source the panel goes on with the pc into it. Its strip is the deepest window's function's linear column (a `Disasm` drawn for the strip alone, `Map.In.strips`), that window framed on it; going down or up it fades through as the mark lands (`map.through`) | | 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | on a beat a scene plays: `Registers.fold` (0 every register a row, 1 the quiet ones folded into their cells, the dive's fold on the scene's clock, `glide`; the rule over them drawing once they have, 12 f), `Registers.parts` (`reg`'s `parts`: one register's value as its eight bytes from 72 on a pitch of 30, high first, the zeros in front at `pad`, spreading out of the value as it was written and closing back into it (`unpack`: the rows under it make room 18 f, the bytes spread 12 f, its parts' rows widest first, a bracket under the bytes each is and its name before it, 12 f each, 6 f apart; `pack`: the parts out 12 f, the bytes close and the rows close up 24 f); a write strikes the bytes it changed, as a dump's; `echo`: the part an instruction names and its bytes framed as read), `Registers.framed` (a register's value, rip's too, framed as read on a beat); `Context.Options.moves`, the scene's set where it is not its clock's way's (the introduction's one set for its four chapters). The registers `quiet` (`Registers.moves`, `movedBy`, `registerRows`): the scene's set chosen once, from its clock's way (`Cursor.journey`: the registers any of its steps of that kind changes, net, with rsp, rbp and rip), each a row with its chain; the rest folded three to a row on a pitch of 285 under a 2-unit rule, in pwndbg's order (`rows.quiet`: the name faint at 12, the value at 60, a pointer cut to `more` at once, a code address alone; framed as read while it carries a system call), rip last; the panel as tall as its rows and the stack the rest (`layout.fit`); in a `dive` it arrives whole from the map and folds as it lands (`Zoom.fold`: each quiet row gliding into its cell, the chain past its first hop gone over the first 40% of the move, a rule fading in); rip's value crossfading over the advance, a flag set or cleared over the 6 f it lands in (`rows.RipWas`); the backtrace newest at the bottom, `#0` last, the oldest dropped from the top (`newest at the bottom · 2 more above`), as a panel, the calls lens's view, the backtrace lens and on the map, all one block (`backtraceRows`: frames leave, slide and arrive; what a kept row says that changes, its depth, its pc's offset, its line, and the tag's count, crossfades, 12 f before the advance); the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), a word's role and offset, and the tag, crossfading (12 f from memory's strike) where the step changes them, rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike (12 f each; at a run half its step each), and what it brings, and what changed before it, is plain; while rows slide they keep their roles (those of both windows are read), and a word becoming a saved rbp, or no longer one, has its arc go or come with its role; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace`. Under `tied` the window has two `free` words of headroom over rsp (a leaf's locals under rsp are the frame's), the tag says the base (`· offsets from rbp`, crossfading as it changes), and when rsp or rbp moves the rows hold while the pin travels (`Plan.pins`: the amount on it, `rsp -18`, counting row by row, a vermilion bracket over the rows crossed, each row gained or released as it passes, the newest frame's span riding it, the register struck as it lands; rbp's pin flies to rsp's, `pop rbp` moves rbp first), and only then the window follows (`Plan.follow`); under `whole` as before | | | `source` | `src/source.zig` | fourteen lines alone, eight with a lens, six with `blocks`; the file the pc is on a line of, of the recording's sources (`Recording.sources`, `shown`: the program's own, or a library's the build gave; else the last such line, a frame up, where the pc waits), whole in a window, its middle third; its lines cut at 63 characters in a pane (67 on the map); the trail's bars (of that file's lines) crossfading with the advance; numbers as wide as the widest file's largest line (SQLite's six digits), the text moved right by as much; another file: the panel fades through (12 f out, 12 f in), its tag's title and note crossfading with it, its strip with it (`map.through`); a window going farther than its own height in one file: the advance is 48 f, the window gliding on the strip for the first 24 (the gold lit on its new row there), then the pane out and in | | | `disasm` | `src/disasm.zig` | under the source in every split: 17 rows (11 as subject and with `blocks`), fewer above near a function's start; on the map 69 from the function's start where the pc is in its first three quarters (a strip's column stays still while the pc walks it), else round the pc; the line column as wide as the source's, a row's number where its line is of the file the source panel shows (libc's rows open64.c's while it shows open64.c, main's none then); two windows that overlap scroll, others fade out and in; its tag's function (a descent's tag too) crossfading with the advance; a 2-unit `rule` across over each block's first row (not its function's), and the block's visits by the moment shown ranged right, faint (`×3`), where the row's annotation leaves room, crossfading with the advance (`graph.Rules`, a descent's windows too); the rows clipped above the panel's padding (a row scrolling out takes its rule with it) | | | `graph` | `src/graph.zig` (`read`, `layout`, `place`, `Blocks`, `Rules`, `leave`) | the function's blocks from the recording (`zt.telescope.blocks`; a block of `nop` padding nothing goes to left out), their edges by how each ends, and the run over them by the moment shown and nothing after (design/README.md, Forbidden): each block's visits, each edge's count, the last three edges taken, the pc's block, counted where one stop in the function follows another across an edge (`exact`: by instruction; by line, visits only). Laid out from the code alone (`place`: never the run's counts), in two forms (`Blocks.form`): `rings` wherever the function has a loop (natural loops merged by header, back edges by the walk from the entry in address order; each a ring, its pills upright at their centres clockwise from the header at 9 o'clock, radius as its pills need, 12 apart and 24 of arc between two; a nested loop a smaller ring outside its parent touching it at its header, the parent's 3 o'clock; an edge to the next pill an arc of its ring cut at the pills' frames, the back edge round the ring's foot, a fork inside a loop an arc 30 inside, a way out along the tangent out of the pill's foot 30 in from its far end, then quarter circles of 16; outside every loop the blocks as `layers` lays them, the entry left of the header, the blocks after under it; `3 turns` 30 under the ring's centre, from the first) and `layers` (layers by the longest path, a block under its fall-through predecessor, a taken target right of it, back edges up lanes on the left, every corner a quarter circle of 12; panning by thirds round the pc's pill where it is taller than its pane). A block a pill 24 high: its offset, the program's callees after it, faint (the tracer's `__zt_*` left out), its visits ranged right, room kept for `×99` so it never widens as the run counts; not reached yet on the page, `rule` framed, faint, no count; the pc's framed gold 3. Edges not taken yet `rule`, taken `dim`, the trail's golds, the newest 3. Too big for its pane (`layout`), the blocks not reached by the scene's first moment fold (`cursor.first`: the code beyond each way the run had not taken, `+5b … · 7`), keeping a fold's room; a fold opens when the run reaches a block of it and never closes (`unfold`: the pills beyond make room 24 f, `glide`, the fold's blocks fade in quiet 12 f, 2 f apart, then the mark lands). `leave` and `turn` along the curves (12 f and 2 f a 100 units, 12 to 42 f; the turn's count at the ring's centre armed as the mark leaves the latch, struck as it lands); `reach` (the edge from `rule` to gold under the mark, the pill filling page to `raised` 12 f, `×1` in 6 f and struck). Kept per function, form, room, first moment and open folds (`memo`), counted again each frame. On the map the drawing is the lens's at its size over the source, the disassembly linear beside it (`Rules`) | | | `blocks` lens | `src/graph.zig` (`Blocks`), `theme.layout.split.blocks` | its drawing the graph, 880 by 344 over the program column (`rings`, or `layers` for a function with no loop: `Blocks.form`); no view: its rows are the disassembly under the source (eleven), each block's first row ruled with its visits, the thread from the source's line to them; the state column the registers and a stack of twenty from its top | | | `hexdump` | `src/hexdump.zig` | malloc's words: a field read as `size` (`0x20 a m P`, the bits as rip's flags) or `protected` (`→ 405050 ^ 405`, `NULL ^ 405`, its arc to the pointer it protects), and a field's `note` (Go 18 faint: `key`, `top`, `slots left`); a lens's view (`hexdump.panel`): `bytes` rows and their reading, veiled at a sprint; a row whose bytes the step changed where the recording saw no write (memory nothing watches, read anew at a stop), or that became known, crossfading over 12 f (`rowPasses`); one reading for every dump (`hexdump.reading`), a list a character apart (a pointer's arrow keeps its own room, no character before it, as in a chain), a typed number as its type reads (`char` quoted, `bool` by name); the address room once a dump, by its widest; `Dump`, a view of a region by the fields a scene gives it (`Field`: where, how long, read as a number, big-endian or not, a pointer, text, or left to the eye), the rows that hold a field and a `more` row for each stretch left out, and where those rows outnumber the window, a window kept round the first row a mark or the step is on, the rest folded into `more` rows; marks the scene plays, and the step's only from the stop it came in at (`since`); the bytes a syscall was given as the kernel took them (`given`), and only what the debugger read at the stop (`seen`) | | | `loupe` | `src/loupe.zig` (`canim.loupe`, `Loupe.open`, `.close`) | from a register, a loupe's field, or a dump's row read by the scene's fields (`.row`: malloc's tcache, `num_slots[0]` and `entries[0]`, the rest `more`); five rows round a pointer's target, lifted (`color.lift`, `lift_tag`, `shade` 12 and 16; 20 and 26 deeper), hanging from its pointer (its tag on the row's foot, 92 left of the digits, clamped to the stage), a 4-high bracket under the digits its stem, the target's fields framed bright; one opened from the band's view lies over the stack, never the registers, its stem down the gutter's right lane (x 962), its fields struck once it has opened (6 f after, 6 f apart: `Fields.struck`); a deeper one with no room to the right hangs under the one it opens from, its stem down to its tag; a note that does not fit is cut at a word with `…`; `open` 36 f (read 6, stem and rise 18 with the shadow, the frame 6 f after), `close` 12 f; it opens again after a close | | | lenses: `nodes`, `array`, `calls`, `syscalls`, `backtrace` | `src/nodes.zig`, `src/array.zig`, `src/calls.zig` (`Tree`), `src/syscalls.zig` (`Crossing`), `src/context.zig` (`Backtrace`, `lens`) | the drawing in `band` (over the program column), its view in `view` (over the state column): `nodes` and `array` a dump (`hexdump.panel`), `calls` the backtrace with arguments, `syscalls` the calls so far as strace writes them (oldest on top, the newest coming in once it is back, held; the rows make room for it, a full log scrolling a row, 24 f, `glide`, but from rest at least a pixel a frame (the rows are drawn on whole pixels), the count above crossfading; out of room a row gives up its faint names first, then its arguments from the right, and keeps what it returned; a path by its string, the kernel's capture where the stop did not read it) over the bytes the call crossing in the step is given or fills (in with the argument framing, 12 f out and 12 f in; what a read fills landing a byte every 2 f, struck, the stack's words with them; a write's buffer framed as read while the kernel takes it; cleared with the log's new row: between crossings `no call crossing now`), `backtrace` (eleven rows as subject, five beside) a `Dump` the scene gives; an `under` pin's names in the order they came, the first left (past the second a count, or with `Nodes.named` by name where they fit before the next node), faded out through the middle of a register's joining or leaving (`Pins.text`); a call node's look (gold, ringed, done) crossfading as the tree's moment changes (6 f), and at a sprint a new node coming in over its step; a left child's result on its left shoulder, off its parent; a view's row a register points into carries the register's `pin` at the row's end (`hexdump` `rowPin`; 48 to the left in a pane, its strip at the right), the reading ending before it; at a sprint the array's pins hold and move where a phrase ends | | 4 tie | the relations: `thread`, `link` (and its `pin`), `projection`, `touch`, `carry`, `aim`, `echo` | `src/relations.zig` (the tables and the pure passes), `src/ties.zig` (`Ties`, the resolver; `anchor`, `show`, `find`, `of`) | the relations are one data problem (design/README.md, "4. Ties"): each frame's tables are in the frame's own scratch (`sk.Frame.user`, made at its first place: no process globals, two players at once each have theirs): `places` (a key, the place's kind in its top byte and its address below, its box, its pane; struct of arrays) that panels say as they draw (`anchor`), `values` (what a pane shows that may be an address: the value, its box, its pane, the word holding it, a register's index, its panel's rules: `show`, from the registers, the stack's words, a pair's frame), and the facts the panels publish beside them (the stack's window, the touch's row, the thread waiting); both sorted once by key (or value) after a change, a lookup a binary search (`find`), a join a merge of the two sorted sides (`relations.join`). `Ties`, added last, is the resolver, six passes, each a loop over one table: candidates (each kind's join, or the step's events against the places), the knobs (`relations.filter`: a kind whose default is off, `carry` and `aim`, only where the scene turned it on; the budget never turns one on), priority (`byPriority`), the budget (`cut`: the thread; one beat; a link, a projection and a touch, two of them, the touch giving way first; a carry; one aim), then each kind's route and drawing. The kinds are one table of data (`relations.specs`: knob, class, priority, most). Map panels say their places into the map's own tables. `CANIM_RELATIONS=1` says each frame's counts and times on stderr; `zig build bench -- relations` times the passes on a working frame's tables and a map's. The kinds' pictures and timings are as they were: fib, list, zoom, sqlite and column render identical frames before and after (every frame compared). `aim` (`Cursor.aim(s, .standing | .step | .drawn | .off)`, off by default): a word in memory holding a code address whose row is on screen, out of its panel's rule nearer the gutter, up the left lane (x 950), onto the disassembly's right rule, the row's address framed in code's ink, its head 10 by 10; standing at 60% toward the page, in and out with the knob over 18 f (`.drawn`: head first at full ink, 18 f, the address framed as it lands, 6 f); the step's full ink after the word's strike, back with the advance; written again, its head glides to the new row 24 f after the strike, or it frays (dashed over 12 f, gone over 18 more) where the new value is no code. Draws in the channels: a link climbs to a node by the gutter's left lane and goes down to a slot by the right, its name riding its head, a target past the stack's window a stub and a row count; to a view's row (`dump_pin`) by the left lane, into the row's edge; on a beat the narration names (`Context.tiesWith`, `ties.Beat`): the register framed as read, then its link, held, drawn back with the frame, its head fading over the draw-back's last third; a projection from the view's bytes, or from a frame's return address to its call's node. Under `tied`, `touch` (`Plan.touch`): from the row's right rule along the gutter's middle lane (x 956) to the word, onto the stack's rule nearer the lane (its right one where the stack stands under the disassembly, a column's beat), in read's or write's colour, the first of the three lines to give way; `carry` (`Levels.carry`, `Plan.carry`): the value's way between a stack word and a register along x 962, primary, an open chevron, `.value` its digits on a raised chip, `.after_touch` after the instruction's touch to the word (a store's too). Places a column's text is level with: `row` (a disassembly's row by its address, a descent's head by `descent.headKey`), `floor`, `block` | | 5 frame | `map`, `minimap`, `dive`, `surface` | `src/map.zig` (`Map`, `split`, `strip`, `Map.strips`), `Context.map` | the working frame's panels bound to a stage of 3840 by 2160 (`map.split`, packed by content: each box as long as the most rows its panel has wanted, `measure`, the backtrace's as long as the deepest call chain of the scene's way, so that it is packed once; the drawing, the source and under it the backtrace; the disassembly; the view (none where nothing draws one), the registers, and in the column's rest the stack going on, `stack, continued`; the stack from 16 words above rsp; and the first two columns' rest (`Split.spare`) given, in the catalogue's order, to `map.Spare`: a five-row dump round each place the registers (pwndbg's order, not rsp or rbp) and the 64 words up from rsp point at outside the stack and the code, none within another's rows, then the loupes open (`Map.loupes`, lifted, nine rows), then the key (the recording and the moment, the marks as drawn, the inks); only then page); its rows published while `ui.mapping` (the dumps' too); the working windows outlined (2 `dim`, 4 out), each window published with where its step took it from and how far its scroll has gone, so its outline glides; the thread across the gutter (x 1008), gold; a scene without a band can put a drawing on its map (`Map.drawing`); with `Context.Options.graph` the map's drawing is the `blocks` lens's (`graph.Blocks` at its size, 880 by 344, over the source: `split`'s band is the working frame's), the disassembly linear beside it with its blocks ruled. Each pane's minimap (`map.strip`): a strip 40 wide inside its frame at its right, under the tag, on `well` (`theme.strip`), drawn from its column of the map (the source's boxes, the stack's with `stack, continued`, the view's dump; the disassembly's the linear rows round the pc, drawn for the strips alone where the map has a graph or a descent: `Map.In.strips`) at 4 units a row and 36 of 880 across, from what the map drawn for it collects (`ui.strokes`, `ui.collected`: each run of text a stroke 3 high in its ink 65% from the page, the marks 4 by 4 at a row's left in the catalogue's order, an arc with an end off the window a 2-unit line down the left edge, a block's first row ticked); a column longer than the strip the rows round its window, the window in the middle, clamped to the ends, three faint dots where it goes on (fading in over its first row's scroll); the window framed 2 in primary; a mark no working window shows (a word struck or read on the stack or in the view's dump) flashing on its row (a ring 8 to 14 in the mark's colour, 12 f). The strips are one image a frame (`Map.strips`): the map drawn for them six times, each from the cursor's mirror a frame later (6 to 11 f behind: `Cursor.lagInto`) with the panes' windows as long ago (`past`), every strip drawn as it shows (its rows, dots and window in place) and the six averaged, so that every change on a strip fades in over 6 f from 6 f after its onset and nothing on it moves a pixel in a frame; the panes blit their part (source, disassembly and its descent and the `blocks` lens's view, stack, a dump's view: not the registers, a drawing, a loupe, the backtrace, the `syscalls` lens's log). A pane with a strip has 48 less for its rows (`map.content`); its strip is its own context's map's (`map.maps`, each frame's contexts, matched by the pane's box: a scene in chapters has several). `Map.show`, `.dive` (outlines bright 6 f, veil to 24, each panel from its window to its place 60 f, 6 f apart, a panel drawn over another setting off first (drawing, view, disassembly, stack, source, registers) so that none in its place is crossed by one on its way, opaque on the way, its rows on the window's rows, its tag and rules in from 84 f; with each, the rest of its column (the rows its strip shows) squeezing from its place on the map into the strip, its width and height each on its logarithm (to 36 of 880, 4 of 24 a row), its window's outline riding on it, gone into the strip's own drawing over the 12 f before its pane lands (`Map.squeeze`, `stripShows`); the map's other parts fading where they are, 24 to 72; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`); the clock's count ranged right at 1856. `unroll` and `roll` (`Map.unroll`, `.roll`, `map.Unroll`, added over everything by `Context.ties`): the panes veiled and the strip's window framed bright (18 f), the pane's whole column growing out of its strip (36 f, `glide`) to as many rows as the stage holds (24 a row at most; right on the strip's edge, the window's rows level with the pane's where the stage allows), its scale on the logarithm from the strip's, the window's outline riding from the strip to the pane's rows in it; held as the scene says; `roll` the reverse (36 f), the veil lifting (18 f). A far jump in the same column at a walk (the source's window farther than its height to lines the map's column of the file holds too, `source.unrolling`, `inColumn`: no step said faster in a hurry) is `unroll`, the window travelling along the column (24 f, `glide`, the mark lighting gold at its new line as the window gets there, the tag's note changing then), `roll` (96 f: `Cursor.travel`), the pane going into the column and coming out of it at its new place, never a fade. Out of the column (another function, a long file) the map's column goes over as the advance starts, so the strip (6 to 11 f behind, a 6 f crossfade) shows where the pane goes before the pane fades through (`over`, `far` on the map at half its height); a window going farther than the column holds keeps its place on the strip until the column goes over (`spanOf2`); the tag's line range changes with the pane's fade; the map's disassembly is measured by the moment the pane shows (a continue repacks the map as the pane gets there), and a recording of breakpoints has its deepest chain read at every stop (`deepest`: the backtrace's box packed once) | | | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject`, `blocks` (`theme.layout.split`, layout A: the disassembly under the source in every split; the source 14, 8, 8 and 6 lines, the disassembly 17, 17, 11 and 11 rows; `blocks` a drawing of 880 by 344 over the program column and no view, the state column the registers' and the stack's from the top), each for a registers panel of eleven rows; `layout.fit` gives the scene's registers their rows and the stack the rest above the backtrace, whole slots, any rest above it (`Stage.registers_rows`: every split a `relayout` goes to keeps them); the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots; `glide` (a column's moves: no fit, no fade), `column` (the clock under the text column), `zoom` (the band's drawing drawn larger, its tag not: `graph.Blocks`) | | | `column` | `src/column.zig` (`Column`, `canim.column`, `beat`) | the shelf (y 48: each folded pane's tag in the frame's order, its note: the scene's, or computed for the registers (those the step changed, the first's value struck as on its row, crossfading with the strike), the source (`line 12`) and the disassembly (`jne 4011af`), crossfading with the advance); the panes from 84 to 1032, 12 apart; texts: `beside` (Go 40 on 54, at most 40 characters a line, 16 of padding, on `raised` while newest, dimming to `dim` without paper, three at most, level with their row, riding it until the panes change or the row goes, an older one gliding above the newest's place or under it), `below` (the caption band), `above` (a band over the drawing), `on` (where the scene puts it, its stem round the drawing's top lane); the change between beats (`change`: fade 6 f, fold where it stands and the tag to the shelf 18 f, glide 24 f (a pane crossing to the other column going down its own first, then across, 24 f each), unfold 18 f, fade in 6 f; a pane that changes its height keeps its rows: `Stage.resizing`, the descent's two layouts glided between, the source's window glided); a stem about a folded pane to its tag; `Beat.held`, and a bubble read past its beat flagged on stderr | | | `segments` | `src/segments.zig` (`read`, `Segments`, `Place`) | the address space to true scale from the recording's mappings (permissions, file offsets), the tracer's own (its ring, its preloaded agent and the agent's bss) left out: a slim bar the column's height, its ends' addresses and its size; clusters split at gaps of 16 MiB or more, and a band eight times the rest of its cluster in a box of its own; `enlarge` a box at a time (its bands with start, end and size, leaders to the bar), 108 wide; an edge's address in the ink of the band that starts there; a file name past the column's edge cut with `…`; kept above y 888 under the camera (`clipStage`); `Place`, a dump's place on it (the `tie` and the `link`), and for a camera's visit the place marked on its box (`tick`: a 2-unit line across the box in the stack's ink, `128 bytes` over it); live (`Segments.pins`, the introduction's II2 and II3): rip a `row` pin at the end of its band's row (`◂ rip`), rsp and rbp an `under` pin in the stack's band, rbp's name left, each in rising 8 as the scene plays it; `ink`'s echoes, up to 24 | | | the introduction's dump | `src/regroup.zig` (`Words`) | 128 bytes sixteen a row, no ink, the addresses faint, its header the address it starts at; `regroup` to eight a row (bytes become words, low byte last, a word that is no address with `0x`; a word in the top four rows has its offsets over it in the header's row (veiled with the rest), `low byte` left of `+0` and `high byte` right of `+7`, and its bytes fly over that row, 40 up, each with its offset over it, one in the air at a time (24 f each, 18 f apart: the 36 f of motion.md, 6 f apart, crossed in the air there), a label going as its byte lifts and coming as it lands; nothing printed over a row), `fold` (the rows glide up into the header, 24 f, the header becomes the tag, which goes to the shelf, 24 f: to the shelf's height first, then along it, over what stands under it; back, the reverse), `back` (its header back over its rows after it was tied to its place, before a fold), `top` (set anew while folded, it unfolds there: II8 brings it back at the rows III's stack gives it), `ink`, `extend`, `become` (the bytes go, then the words and addresses glide into the stack panel's rows); with no heap word in the bytes, the first other address is framed | | | `aligned` | `src/aligned.zig` | the source and its instructions in one panel, each line level with its code: `interleaved` and `columns`; the lines without their indent; the mnemonics after the longest instruction's bytes; the pc's row annotated (what it reads, its chain); `decode` (an instruction's bytes to its row), `align` (one form to the other: the bytes go first, then the columns glide) and `stack` (to the working frame: the heads' paper, rules and tag out 12 f, the lines to the source panel's rows 36 f, the instructions down their column 24 f and into the disassembly's rows 24 f, those its window does not show fading past its edge; the scene fades the panels in under them) | | | a text standing alone | `src/aside.zig` (`Aside`, `Asides`) | a column's bubble where no `Column` stands (the introduction's texts beside, and above its aligned code, two lines of 80 characters there: `Asides.wrap`); a newline breaks where the author says; one the new text would stand on leaves first, then a gap; with a `floor` (the introduction's II), one in the way glides down under the new one instead (24 f, the new one arriving after), the others under it with it, as far as the floor (past it, it leaves), and three stand at most; `shortcut:` it repeats `column.zig`'s bubble drawing | | | a caller's rows alone, a stack built a column at a time | `src/descent.zig` (`Caller`), `src/context.zig` (`Stack.reveal`) | `Caller`: a descent's head row over a call, the row it returns to and the next, each a `row` place for an `aim` (chapter II's main); `reveal`: the stack's offsets, roles and spans each under the page until the scene's clock lets them in top down (`column`, 2 f apart, 12 f each) | | | `pair` | `src/pair.zig` (`split`, `Frame`, `Report`, `Marks`, `Clock`, `Shelf`) | two runs on either side of the seam (design/README.md, `pair`): `split` each side's stage; `Frame` a frame as bytes eight a row read by its fields (`hexdump` `eight`: fields live from a moment, the letters keeping a string's ink in a pointer's field, the shadow byte of each row beside it, tall in the column, its words said as values for the relations); `Report` a stopped run's stderr in place of its registers; `Marks` `only here`, `differs`, `attention` and the `fault` (hazard bands round an ink plaque, SIGSEGV); `Clock` one rule and each run's moment; `Shelf` a folded side's tag | | | `clock`, `caption`, `veil`, `card`, `chapter` | `src/words.zig`, `src/root.zig` (`Narrator`, `Camera`) | the clock still while a step plays, its piece fading in once the mark lands; a caption stays its reading time; the title card is `scenes/title.zig`; a chapter's title said in the caption's place (`Title`: Go Medium 40, the numeral faint, the name bright, in rising 8 as a caption) and its name the clock's label (`ChapterLabel`: Go 18 faint, ranged right 24 left of the count at its widest, `moment 193 of 193`, so that it stands still as the count grows, or alone at 1856 where there is no clock yet; the chapters' names crossfading at a seam, and from alone to beside the count out, then in, never over it) | | 6 verb | `fire`, `arm`, `strike`, `cool`, `read`, `extend`, `link`, `project`, `travel` (pins), `advance`, `cascade`, `continue` (`Cursor.continue`, `Plan.wave`), a call stepped over (`Cursor.over`: rax struck first, in the CPU's slot at 48, then the others in a wave from 66, 2 f apart; a hold of 36 f; 2.4 s), `unpack` and `pack` (`Registers.parts`), `fold` on a beat (`Registers.fold`), `title` (a scene in chapters: `scenes/intro.zig`, `seam`), `run`, `sprint`, `establish` (`Context.establish`: a drawing's elements fade in rising, no lines), `scroll`, `relayout`, `visit`, `say`; `unroll` and `roll` (`Map.unroll`, `Map.roll`, above); `reach` and `unfold` (`graph`, above); `leave` and `turn` (`graph.leave`, from a block's last row, `graph.toEnd` to get there, along the curves of `rings` or `layers`: fire 0–12; the compare's chips framed as read from 18 (the CPU's slot, the jump's echo), held while the edge draws gold, head first, 24–42; the mark (a gold plaque, its point the way it goes) along the edge 42 to 42 + 12 f and 2 f a 100 units of the drawing's edge (42 f at most), round the ring's foot for a turn; landing, the advance; the target's count armed and struck 6 f after (a ring's turns at its centre armed as the mark leaves the latch, struck as it lands), cooled to nothing by the step's end; the trail recoloured over 18 f from the landing; a rest of 42 f from the landing); over a graph at a walk of several blocks, a run or a sprint the trail, the counts and the gold crossfade with the advance (8 f at a run, the step at a sprint), the pan gliding with it | `src/cursor.zig` (the timetable), `src/graph.zig` (`leave`, `instant`), the blocks (each draws its state at the instant) | tokens in `theme.time`; a level gives up its slot when nothing it touched is drawn (`Recording.drawn`); a label that changes in place with a step crossfades over the 12 f before the advance, or from the step's start where that is sooner (`Now.renaming`); at a run what marked a value goes with the run's ease (8 f) and a pin changes over it; at a sprint an ember and what grows come in over the step (4 f), never in a frame | `Recording` (`src/Recording.zig`) is the index every block reads: lines, calls, syscalls, allocations, which registers and bytes each moment changed and read (a debugger's `touch` reads count), each moment's `touch` and `branch`, and each instruction's line. ## The recordings `build.zig` records the programs of `tools/` under `ztrace record` (the debugger: registers, the stack, what they point at, the instructions round the pc with their lines and callees' parameter counts, what each stack word is (`zt.telescope.slots`), at every stop: `--stack 1024 --around 256 --disasm 69`, what the map needs, except where noted), each by a bare name in a directory of its own with an empty environment, without address randomisation, with the tools built `ReleaseFast` (a step through the agent's or the runtime's code is a moment, and a slow tracer stretches the clock's retry loops it steps through). The instrumented ones are built `-no-pie -fno-stack-protector -Wl,-z,now`: short addresses, no resolver and no canary stepped through that the source does not say. A dynamic program's libraries (glibc, the loader) are named by their own debug info where the debuginfod client's cache has the file of their build id (`$DEBUGINFOD_CACHE_PATH`, else `$XDG_CACHE_HOME/debuginfod_client`, else `~/.cache/debuginfod_client`): their frames carry names and lines. The recorder finds it by `DEBUGINFOD_CACHE_PATH`, which the program inherits and keeps in its environment, so it is `debuginfod`, a link beside the program to the cache: the program's environment says `DEBUGINFOD_CACHE_PATH=debuginfod` (rdx at main's start points at it), nothing of the machine. A static musl program's are its own (Zig builds musl from its sources with it). **Sources.** A recording's lines name files other than the program's own (libc's `open64.c`, musl's `open.c`). The build gives each scene those it has (`tools/sources.zig embed`, every build, no network: the recording's `-sources` module, `Program.sources`, path and text): musl's from Zig's lib directory (`zig env`), the rest from the debuginfod client's cache, `//source/` (a directory of canim's own beside elfutils' entries there: elfutils' own source layout is not documented on this machine, and gdb does not share it). `zig build sources` fetches into it what it lacks, of the modules named by a separate debug file (a distribution's library, never the program's own), from the first server of `$DEBUGINFOD_URLS` or `/etc/debuginfod/*.urls`: `curl /buildid//source`, which sends the build id and the path and curl's defaults. Without the cache (or before the step) a scene shows a library without source, as before. The source panel follows the pc into any file it has (`Recording.shown`). | Name | Program | Stops | Moments, bytes | Also | | --- | --- | --- | --- | --- | | `steps` | `fib.c`, static musl, `-O0` | every instruction | 1999, 601 KB | | | `hello` | `hello.c`, the system's clang and glibc, dynamic: `-O0 -g -no-pie -fstack-protector-strong -Wl,-z,now` (a PLT bound at load, no resolver; the canary) | every instruction, `--from main`, `--steps 132` (to main's return) | 166 (30 of them the loader's syscalls before main), 110 KB (83 KB before libc was named) | reads `tools/note`; PLT stubs and GOT slots named (`open@plt`, `open@got`) | | `heap` | `heap.c` (design/mock/heap.c), the system's clang and glibc, dynamic, as `hello` | every line, `--from main`, `--steps 46` (to main's return: libc's lines, named now, would take it on through `exit`), and pop's `call free@plt` (`break_call`: a breakpoint objdump finds, which a line-stepping recorder now stops at) | 78, 74 KB | `--heap` (`ztrace.heap.glibc`: chunks, the tcache, bins, the arena); `-w 0x405000,1024` (the chunks' bodies) and `-w head` (the global the list hangs from: unwatched, a recording keeps a global as last seen) | | `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 4446, 984 KB (4396, 751 KB before libc was named) | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them) | | `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 2913, 1035 KB (2920, 743 KB before libc was named: the count differs by a few moments from one recording to the next, not looked into) | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through | | `musl` | `hello.c` again, built by Zig for `x86_64-linux-musl`, static, `-O0 -g` (musl compiled from its sources with it: no PLT, its lines its own) | every instruction, `--from main`, `--steps 166` (to main's return) | 173, 55 KB | reads `tools/note` | | `gallery` | the old `list` by line, kept in `test/gallery/list.ztrace`; for the graph pages `sort` and `hello` as recorded on 11 November (with blocks), kept in `test/gallery/sort.ztrace` and `hello.ztrace` (`gallery_sort`, `gallery_hello`) | | 134, 88 KB; 776 KB; 87 KB | the gallery's pictures depend on the drawing only | | `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096` | 181 (42 stops, 138 syscalls), 494 KB | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source | | `intro` | `list.c` again, as the compiler alone makes it: the system's clang `-O0 -g -mno-red-zone -no-pie -fno-stack-protector -Wl,-z,now`, glibc, no instrumentation (no red zone: reverse's prologue is `push rbp; mov rbp, rsp; sub rsp, 0x18`, its locals at `rbp-8`, `-0x10`, `-0x18`) | every instruction, `--from list.c:40` (main's push(9), the first stop at moment 32: the clock counts from it), `--until list.c:22` (past the load); run as `./list` | 226 (32 of them the loader's system calls before main; malloc's 162 instructions in push(9) stepped through), 208 KB | the program's alone (no agent: the step over `call malloc` changes only rax, rcx, rsi and rdi, and r11's word); `--heap` (glibc's heap at each stop: the list's nodes are the chunks in use there, the scene reading its allocations off it, `Recording.allocationsFromHeap`, `Recording.allocated`), `-w head`; its locals named by the debug info (`zt.telescope.slots`); the types the nodes lens needs (`head`, `struct node`) declared by the scene (`Recording.declare`): the tracer reads none from the debug info | | `overflow` | `overflow.c` (design/mock/overflow.c: a loop writing 32 bytes into `char buf[16]`), the system's clang `-O0 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector`, glibc | every instruction, `--from main`, to the fault | 298, 60 KB | the recorder says `exit 139`; the SIGSEGV on the moment after `ret`, rip unchanged | | `overflow_asan` | the same with `-fsanitize=address`, `ASAN_OPTIONS=detect_leaks=0` | every instruction, `--from main`, `--until __asan_report_store1` (its first stop there: past its `endbr64; push rbp; mov rbp, rsp`, as `-b` places a function's breakpoint) | 788, 257 KB | `--asan` (the shadow); the fake frame's header parsed by the scene from memory; the scene finds its moments by what the instructions are (the parting turn's load, `je`, the partial check's `cmp` and branch, the call), none by a count | | `overflow_report` | the same run | `--by syscall --stack 0 --telescope 0 -s 4096` | 707, 401 KB | the report: its `write(2, …)`s, shown from their capture; `exit 1` | What builds each program: `fib.c` (`steps`) and `hello.c` for `musl`, Zig's build (`addExecutable`, musl, static); `hello.c` for `hello`, `heap.c` and `sqlite.c`, the system's clang against the system's glibc, dynamically (`hello`'s PLT and GOT are the scene, as a C programmer's build lays them; the heap scene is glibc's own allocator; `sqlite` is built as the bench builds it, and its scene is glibc's `pwrite64`; `list.c` for `intro` likewise, with its own flags: `Recording.cc`); `list.c` and `sort.c`, `ztrace cc`, the system's clang with the instrumentation pass, a plugin of that clang's LLVM. A recording of a program built without the pass tells no variables: a scene declares the globals and named types it draws in the pass's notation (``Recording.declare("head", "*`struct node`")``), a global found at the address the recording names `head+0`; `Recording.variable` gives a local of the newest frame by the debug info (its slot's name), assigned once a store has touched it since its call began. Every recording the build makes carries each function's blocks (`zt.telescope.blocks`, at the first stop in it) and a `branch` event at each stop on a jump: the graph and the linear rows' block rules read them. The old `list` of the gallery has none, and draws none. Under `tied` the touched word of a step is the recorder's `touch` (a `push`, `call` or `enter` writes 8 at rsp-8, a `pop` or `ret` reads 8 at rsp, a `leave` 8 at rbp, as the tracer records them now); a recording made before that (the gallery's) has the word derived from rsp and rbp (`cursor.stackTouch`). A global's data name (`head+0`), the role a `push rbp` is about to write (`saved rbp`, at the push's own stop), a shared word's other locals and the canary's name are the tracer's; the return-address word a `call` is about to write has no role at the call's own stop, so its row says `fib(4) · rsp -8` alone. A recording that begins inside a call (`--from`) has that call open from its first stop (`Recording.index`, from the frame chain). Writes are the bytes whose value changed, to the element the instruction stored (its `touch`); a store of the same value is kept apart (`storedSame`) and counts as assigning a local (and as a name coming to a node's pin). A register's change over a step is net: a call's rsp put back is not struck. A call into the vDSO (the runtime's clock) is one moment, as the tracer now records it: `list` and `sort` have `--stack 1024` like the rest. An address no symbol holds is named from its module's first mapping (`list+2c89`). ## Motion, as measured `tools/chart.py chart` on the 1080p exports (the designer's `design/motion/motion.py`, its checks and its regions told where canim's panels are, by split and by each scene's registers panel (layout A: the registers as tall as the scene's rows, `chart.py`'s `split(…, regs)`; sort's the `blocks` split's: the drawing, the source and the disassembly under it, the registers and the stack), each pane's strip a region of its own (`source strip`, `disasm strip`, `stack strip`, and `view strip` where the view is a dump: `motion.strips`, the pane's region stopping 42 short of its right edge), secondary action like the words (no CROWD), its one-frame changes POPs; the clock, its count ranged right at 1856, its own region, whose count changing in a frame is no POP; the caption's box from 940, under the clock's count and a run's step counter). `design/motion/motion.py` itself has the strips' regions by split too (`--regions none|beside|subject|blocks`, and the default frame's columns less their strips). POP: any region still for 12 f that changes in one frame and is still again. A one-frame change that is right is counted apart by name (`POP exempt`), never dropped: `keyframe`, x264's I frame (`-g 600`: 10, 20, 30 s) re-quantizing a still region, under 200 pixels moved (motion.py reads the video's I frames with ffprobe; the caption check skips such a frame and the one after it too); `cut`, the gallery's pages, which are the catalogue's pictures cut one to the next (chart.py names their times). The videos are x264 without adaptive quantization (`aq-mode=0`, 18% larger): with it a still glyph's edge was re-quantized as the rest of the frame moved, a one-pixel column flickering in fib's caption band at 7.45 s that the instrument took for an extra caption (the rendered frames there are identical; with `aq-mode=0` fib's first 600 frames have no such column). CAPTION: up over 720 f, up under 90 f + 3.6 f a character (chart.py counts the characters of the scene's `says.line` strings as shown; where the video's arrivals and the scene's captions do not pair up it says so and checks no reading time), or the picture moving within 60 f of its arrival; chart.py does not count the list's dive (150 to 300 f) as a caption's change. | | fib | list | sort | syscalls | musl | zoom | sqlite | heap | gallery | title | column | column_sort | asan | intro | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | POP, before / after | 3 / 3 | 10 / 10 | 4 / 4 | 13 / 13 | 7 / 7 | 2 / 2 | 6 / 6 | 15 / 15 | 9 / 9 | 0 / 0 | 4 / 4 | 6 / 6 | 16 / 16 | – / 0 | | of them the strips', before / after | 1 / 1 | 4 / 4 | 3 / 3 | 9 / 9 | 1 / 1 | 1 / 1 | 0 / 0 | 4 / 4 | 3 / 3 | 0 / 0 | 2 / 2 | 3 / 3 | 0 / 0 | – / – | | POP exempt, before / after | | keyframe 1 / keyframe 1 | | | | | | | cut 5 / cut 5 | | | | | – / none | | CROWD, before / after | 3 / 3 | 7 / 7 | 8 / 8 | 4 / 4 | 6 / 6 | 3 / 3 | 2 / 2 | 16 / 16 | 5 / 5 | 0 / 0 | 0 / 0 | 0 / 0 | 15 / 15 | – / 0 | | METRONOME, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | – / 0 | | CAPTION up over 720 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | 0 / 0 | 1 / 1 | 1 / 1 | – / 4 | | CAPTION under its reading time, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | | not checked | not checked | not checked | – / not checked | | CAPTION picture moving within 60 f, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | | not checked | 1 / 1 | not checked | – / 4 | | AIR, before / after | 0 / 0 | 0 / 0 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 1 / 1 | 1 / 1 | 0 / 0 | 0 / 0 | 1 / 1 | – / 3 | | seconds, before / after | 48.2 / 48.2 | 83.9 / 83.9 | 74.5 / 74.5 | 85.4 / 85.4 | 66.8 / 66.8 | 34.9 / 34.9 | 62.9 / 62.9 | 80.2 / 80.2 | 27.0 / 27.0 | 12.3 / 12.3 | 95.3 / 95.3 | 29.5 / 29.5 | 120.0 / 120.0 | – / 210.6 | "Before" is the last pass's "after". This pass exported (at 1080 and 2160) the introduction alone, `intro`, new as one scene (its regions are the two columns: `chart.py`; its three chapter scenes and their charts are gone, the last pass's cells for them: intro_memory POP 1, CROWD 0, AIR 1, 70.0 s; intro_stack 0, 1, 1, 42.5 s; intro_code 0, 0, 0, 44.8 s); every other scene's cells repeat the last pass's. The column's, column_sort's and asan's "caption" regions are not a caption's (the text column, a drawing's band), so their CAPTION lines are not a caption's; the column's own check is the renderer's (`column: bubble N is still read …`): C2's bubble (74 characters) 1.8 s past its three steps. The introduction's texts beside are not in the caption band either: the band is empty for I's column part (from 23.35 s), II from II4 (94.15 s), III (130.22 s) and IV's texts above (167.02 s), which the instrument reads as four captions up over 12 s with the picture moving; the reading times are the scene's own (`Narrator`, `Asides`: each text waits until the last is read; the titles theirs). Its AIR is three chapters' last pictures held while their last text is read and the seam's 30 f before the texts go (67.22 s, 5.0 s: I10's 91 characters; 122.48 s, 4.6 s: II8's 93) and IV3's reading (183.33 s, 3.7 s). No POP: the draft's three were looked at, frame by frame, and are gone (96.33, the pc's mark coming to its row, now eased; 108.90, r11's later hop changing at the step's first frame, now with memory's strike over 6 f; 206.23, the clock gone under IV's map as it surfaced, now the same clock over it). The chart: `out/motion/intro`. This pass changed (the introduction as one scene, with its chapter on registers): - `intro` (`scenes/intro.zig`) is the introduction's one scene and video; its chapters are functions of their own files, called in order, each opening on the last picture of the one before at a seam (`title`); the three chapter scenes and their videos and test scripts are gone. Chapter II, registers, is new (`scenes/intro_registers.zig`); III goes on on II's context (its registers, its code, its cursor: III's beat that built the registers is gone, and rsp's and rbp's rows and reverse's rows no longer arrive in it); IV's clock is the same clock stepped on to the load. - The recording `intro` starts at `list.c:40`, push(9), the program's alone (no agent), with glibc's heap at each stop (`--heap`): the nodes' memory blocks are the chunks in use there (`Recording.allocationsFromHeap`, which the scene calls: the allocations read off the heap where no agent told them, `Born.gone`; `Recording.allocated`, used by the objects' liveness and the dump's reading; the `heap` scene, which draws the heap its own way, does not call it, and times its steps as before). - New blocks and verbs: `Registers.fold` on a beat, `Registers.parts` (`unpack`, `pack`, its echo), `Registers.framed`; `Context.Options.moves`; `Cursor.over` and `Plan.result` (a call stepped over, its result first; `ties.strikeDelay`, `Now.register`); the call row's annotation in that step and a call's result in hex where it is an address (`malloc(16) = 405050`; in any scene: the other videos were not exported again); `Disasm.mark_in`; the introduction's first value struck with its register, and no `· rsp -8` on its call row; `Segments.pins` (`◂ rip`, rbp and rsp in the stack's band); `Words.top` and `.back`, the tag's way to the shelf (its height first, then along it); `Asides.floor` (an older text glides down under a newer one, three at most); `words.Title` and `ChapterLabel`; each pane's strip from its own context's map (`map.maps`). - Outside the introduction the pictures are as they were (the gallery's pictures compared by the tests), but for a call's result that is an address. The pass before (the introduction, a correction round after a review of its three chapters frame by frame) changed: - The recording `intro` is the plain build (`-O0 -g -mno-red-zone`, no instrumentation; `Recording.cc`), so II walks reverse's own `push rbp; mov rbp, rsp; sub rsp, 0x18` and III's map has no tracer's calls; the nodes lens reads the types the scene declares and the locals the debug info names (`Recording.declare`, `Recording.variables`, `Recording.variable`). - I: the first text names only what will be on screen (`here are 128 of them`; the header `128 bytes at 7fffffffebc8`; the tag `the 128 bytes`), the bytes come a lead after it, 18 f apart; the walked word's bytes fly over it, one in the air at a time, nothing printed over a row of memory; the fold glides the rows into the header, which becomes the tag; the rows' addresses take the stack's ink as the box lights; the visit is at x2 framing the box and the dump's top rows, the place ticked `128 bytes` (`Place.tick`), no label cut at the frame's edge; `0x` on a word that is no address; I5 says each file, I10 the arrows. - II: the convention said where the stack first stands (lower addresses drawn higher), four `free` words over rsp held (no row moves); the call before the push, rsp's link to its word as II2 names it; the aim drawn head first at full ink (`Cursor.aim(.drawn)`, its head 10), then 60%; reverse's first rows a disassembly under main's, the push walked with its touch and rbp's value carried to the word (`Levels.carry = .after_touch`) and struck though unchanged; rbp's row with rsp's; `the way back` on return addresses, `0x` on offsets of 10 and more (`Levels.introduction`); `rbp marks the frame's base`. - III: II's state column stays, veiled, until the decoded code spans it; `Later, at line 21`, rax's link to its node; III2 says each line heads its instructions; the width squares and the minimaps said; node 9's pin `head cur rax` in full (`Nodes.named`), its row `9 → 405030` (a dump's pointer reading lost the character before its arrow, every dump: the gallery's pictures drawn anew); the map's text lands before `surface`, a caption. - What reaches past the introduction (those scenes not exported again): an aim's head is 10 by 10 (asan's was 8); a beat's link (`tiesWith`) fades its head over its draw-back's last third (sqlite's went in a frame); a dump's pointer reading has no character before its arrow (list, heap, sqlite, the gallery); `Cursor.jumpWalked` (a cut that leaves the steps' history), `Asides.wrap`, `Stack.Reveal.apart`, `Nodes.named` and `Place.tick` are new and off by default. Two passes before changed: - The ASan run is recorded `--until __asan_report_store1` (no count), and the scene finds its moments by what the instructions are; the pair's disassemblies name their run, ASan's stopped call reads `never returned`, and the two are aligned by line (`Disasm.run`, `.stopped`, `.aligned`; "What is not done", the ASan pair). - A run's crossfade, at its blocks: a disassembly row the advance changes crossfades over the whole advance at a run (8 f, the run's ease, as a dump's values; it was the advance's middle, 4 f), and the pc's row too where the moment its annotation reads changes (a loop's turn coming back to its row at a run changed it in the advance's middle frame: `disasm.zig`); a register's chain crossfades with its value at a run where what it reads changed under the same value (`context.zig`, `cursor.chainMoved`: ASan's rbx `→ 7bfff58f0020` at A6's first turn). asan's A6 had 13 of its 29 POPs (36.57 to 41.08, 12 to 108 pixels): none now. list's 50.22 (the disassembly, 18 pixels) is gone. - What else moved in the counts is not this pass's code: syscalls' 67.30 (90 pixels, looked at frame by frame) is a free word over rsp taking the next call's return address (`4011ad` to `4011c5`) in one frame, as it did before; the steps round it no longer move there, since the `hello` recording the build makes now (today's tracer) has 0 in `n`'s high half where the last export had `0xf00000000`, and its 4.07 and 49.80 are gone. list's new 50.25 (caption, 13 pixels) is the encoder: the rendered frames 3014 to 3017 are identical in the caption band. heap's 23.77 (drawing, 14 pixels) is the same change at the same frames as the last export's, now after 12 still frames at the instrument's size; its 37.17 is gone. - `mov rbp, rsp`, looked at in consecutive frames: in zoom (its own step, at a run, 20.0 s) rbp's pin rises to rsp's row, rsp makes room, rbp's head fades as it lands (f1200 to f1212), and at `sub rsp` rsp leaves and rbp's head comes back (f1229 to f1242), every frame a part of the move; in fib it is inside a step by line, so rbp lands on the saved rbp's row, not rsp's (f586 to f623, smooth). fib's and zoom's counts are unchanged. Three passes before (the introduction) changed, outside its three scenes: a pin joining another's row in front of its names (`mov rbp, rsp`: rbp onto rsp) lets its own head go as it lands, not in the advance's frame (`Stack`); the pc's triangle on `aligned`'s plaque is drawn where it is (it was transformed twice, off the stage); `segments` leaves the tracer's own mappings out, inks an edge by the band that starts there and cuts a long file name; the build records `intro` (`Recording.until`, `.program`). The pass before that changed, a kind of one-frame change at a time, each at its block (the catalogue's rule: nothing changes in one frame): - An instruction's in-step annotation (`lea`'s `= 402004 ← "note"`, a register's first value, a compare's flags, the canary's word, `rbp = rsp`'s value) fades in from its strike (12 f; at a run with the run's ease) (`disasm.zig`); a row the advance changes (its state, its trail, its line number) is drawn as before and as after and crossfades over the advance's middle (`disasm.zig`, `descent.zig`); a descent's plaque lands over the advance's second half; a descent window's shared digits are of its own rows that show. - Scrolls of the source and the disassembly move at least a pixel a frame from rest (`cursor.glidePixels`): a glide's first frames, each under a pixel, stood still a frame on whole pixels. - The stack's `call` spans are matched by the frame they are (its foot), not by depth: a call's step drew `_start_c` twice in its first frame; a new frame comes in with rsp's pin, a frame taken off shrinks to its foot and goes, the newest from the pin's middle. rsp's amount on its pin comes in over 6 f; a stub arc (a pointer past the window) and a saved rbp's arc come in over 12 f with their step and go with its advance; a write's arm frame comes in over 4 f (the catalogue's 2 f left a few pixels for one frame). - What the kernel fills (a `read`'s buffer) strikes a byte every 2 f by its own landing times, each value at s+3, the fill under it; the list's view scrolls its dump's window (24 f) where it jumped; a node's lone pin name that had kept the right goes over to the left fading out and in, and two names whose order a step turns crossfade; the shelf's struck digits crossfade to bold; heap's own drawing lets its count's and the top's marks leave as marks leave. - The column: panes that leave fold where they stand and only their tags travel to the shelf (6 f rows, 18 f fold), panes glide 24 f, one that changes its height keeps its rows (the descent was empty 40 f at C7), a source window of one or two lines shows its line (it showed lines 1 and 2 of the file at C5 and C6); a drawing's tag note fades where it no longer fits; C1 to C12's texts as the storyboard cuts them. - Lengths: the steps the captions do not name run (musl's prologue, its arguments, `__syscall_cp`'s frame; zoom's `mov rbp, rsp` and `sub rsp`; list's last loop test said faster), and long captions retimed: fib's first walks to its frame made (13.6 to 11.6 s), list's two end at the loop's test (12.07 to under 12 s), sort's last value split in two (12.8 s), zoom's frame-building one (14.3 to 11.1 s). sort is 1.6 s longer for its split. - The relations (Part 1.5, above): their pictures and timings are as they were, every frame of fib, list, zoom, sqlite and column compared before and after. The relations' cost, measured (`CANIM_RELATIONS=1`, a line a frame; `zig build bench -- relations`): | | places | values | candidates | drawn | sort | the resolver's passes | all, a frame | | --- | --- | --- | --- | --- | --- | --- | --- | | fib, the working frame, each frame | 64 (74 at most) | 27 | 3 at most | 3 at most | 5.5 µs | | 23 µs mean, 69 µs at the 95th, drawing included | | list, the working frame | 87 (96) | 28 | 5 | 3 | 5.6 µs | | 16 µs, 52 µs | | list, the map (269 frames) | 790 (827) | 288 | | | | | sort and join 57 µs mean, 81 µs at most | | bench, a working frame's tables | 300 | 120 | 16 pairs | | 21 µs | join 0.9 µs, passes 0.6 µs | the old table: 11 µs (a lookup a scan) | | bench, a map's | 4,000 | 6,000 | 746 pairs | | 516 µs | join 19 µs, passes 29 µs | 0.56 ms; the old table 5.7 ms | The old table's real cost a frame was not measured (it held under 512 places and was scanned per lookup): at the working frame's size it was as cheap; the tables' gain is the map's size and the frame owning them. What fires still (the finals; located where it says so): - asan, 16: plain's registers' chain string growing at each store of A15 (80 pixels, every 0.8 s, its rbp and rsp hops reading the letters) and plain's disassembly at each (14 pixels, not looked at); 100 pixels at 66.6 s in plain's disassembly (into the column), 702 at 83.68 (the descent's main window going over); 16.68 the source (95), 47.58 and 60.15 the disassemblies (14, 38), not looked at. Its CAPTION over 720 f is the column part (no caption band there), its AIR the poster's held rest (meant). - syscalls 13, 9 of them in the strips: six the disassembly's strip region crossed by a touch's head (12 to 15 pixels, looked at: the touch leaving the row's rule over the strip), three the stack's and the source's strips (38 pixels, not looked at); 67.30 the stack (90 pixels, looked at: a free word over rsp, which takes no place, given the next call's return address in one frame, above); 59.48, 81.70 the stack (24, 25 pixels, not looked at); 44.88 registers (12, not looked at). - column 4: 28.53 the source's strip as the pane shrinks to two lines at rest (its strip is drawn at the pane's height, not lagged: looked at); 52.92 and 82.77 the shelf (106 pixels, not looked at); 60.98 a strip. - fib 3, list 10, musl 7, sort 4, zoom 2, sqlite 6, heap 15, column_sort 6: list's 50.25 the encoder (above); list's 13.62, 42.52 and 71.55 the nodes (120 to 280 pixels: 71.55 a pin's names, now crossfaded, the others not looked at); musl's 55.68 and 64.28 in the descent (112 pixels, not looked at); heap's drawing (88 to 197) and its stack strip (68 to 71) not looked at; zoom's 17.40 registers (12 pixels) and 24.67 its stack strip. - The gallery's 12.62 and 15.40 are its relayouts (a page a state), 9.00 its step. ## What is not done - The column: a text `on` a drawing sits where the scene puts it (`Beat.where`) and its stem goes along the drawing's top lane and down to the part it speaks of; nothing checks that it keeps 16 clear of every element and path, nor falls back to `above` where it cannot (the catalogue asks the renderer to find and check the place). On the way back to the working frame a drawing whose working box is the band (y 48) glides over the shelf's tags before they unfold (`column_sort`, 26.6 to 27 s): the order is the catalogue's (glide, then unfold), but the band's box and the shelf are at one height; its tag's note now fades where it no longer fits. A strip of a pane that changes its height at rest is drawn at the pane's height now, not lagged and averaged (the source's strip at C5, one frame). At a sprint the scene does not surface to the map with a text `on` it. Only the registers', the source's and the disassembly's tag notes are computed (the lens's and the stack's are the scene's). A text rides its row until the panes change or the row goes, then stays: remembered by the process as frames are drawn in order (`last_level`, `latched`: an export, a player playing), so after a seek a text whose row has gone sits at 400 until its row is seen again. The panes keep their minimaps (mocks 49 to 53 draw none). The lens is one object: its view can stand with its drawing folded (the bytes over the source), not the other way round. The bubble check is the renderer's own (stderr, once a process), not chart.py's: the instrument still cannot pair the column's texts with what it sees (its "caption" region is the text column, where texts dim and glide). C2's bubble (74 characters) is flagged: 1.8 s past its three steps. - The ASan pair (`asan`): the disassemblies' tags name their run (`plain · fill`, `asan · fill`; `Disasm.run`); ASan's stopped call reads `4e8450 __asan_report_store1 never returned`, its plaque gone, the tag `asan · fill · stopped` (`Disasm.stopped`, 12 f as its registers give way, mock 38); the two disassemblies are aligned by line (`Disasm.aligned`: the pc's line's first row at the window's top while the pc is in the window's upper half, the window filled from above where the code ends under the pc), so the two runs' rows of one line start level at a line's start (A3, A4); a line longer than the window's upper half (ASan's line 4, thirty rows) scrolls with its pc, as before. Plain's registers read rbp's and rsp's chain as a string of A's (the mock's `← 0x4141414141414141` is not `rows.chain`'s); a field keeps one held corner (the newest write's), not one a byte; the clock says `i 27 · plain moment N · asan moment M`. In the column, plain's descent follows the frame chain, which the overwritten return address ends in `fill` from i = 24: main's window goes over 82.4 to 83 s, after the aim has glided to `fill+1`. The scene is 120 s against the storyboard's 112: the two-line captions' reading times and the column's changes. A15's stores leave one-frame changes (above); the renderer says A12's bubble (`column: bubble 3`) is read 1.5 s past its beat's steps. The fake frame's header is parsed by the scene from memory, plain's fields from the instructions' rbp offsets, and the two runs' stops are matched by pc. - The introduction (`intro`), exported: where it differs from its storyboard and mocks. One video, 210.6 s against 206: I 0:00 to 1:11.7 (71.7 s against 71.4), II to 2:06.6 (54.9 s against 52.0: an older text in the way glides down under the newer before it arrives, 24 f each time, and II5's step and `pack` take their own frames), III to 2:43.0 (36.4 s against 35.3), IV to 3:30.6 (47.6 s against 47.5). The recording's moments are the storyboard's (6 at II's start, 7, 169 after malloc, 182 at reverse, 191 at the load, of 193); its stack is 256 bytes lower than the mocks' (the 128 bytes at `7fffffffecc8`: a run with no agent preloaded). The clock's label stands where it is beside the count at its widest (`moment 193 of 193`), so it is 48 left of `moment 6` (mock 58: 24 left of the count, moving with it); from alone at 1856 to beside the count it goes out, then in, with the clock (12 f each), never over it. The tag of the 128 bytes crosses the registers' tag on its way back (II8: along the shelf's height, then down); in `fold` the quiet rows going down cross the rows going up, as the dive's fold does. Push's six rows scroll a row as the pc comes onto the call (the window keeps the pc in its third row; mock 60 holds it). The chapters' own beats are as they were (I's, III's less its registers' beat, IV's); IV1's `08is` (a mono run's spaces in a text beside drawn wider than measured, `aside.zig`) is as it was. The chart's caption checks cannot pair the texts beside with the caption band; their reading times are the scene's own (`Narrator`, `Asides`). The register set is the one II's steps change (rax rcx rsi rdi, rbp rsp), computed from the recording, eleven rows from II8 to the end. - The relations: arcs within a panel (the stack's, a dump's, a loupe's) are still each panel's own (`rows.Arcs`, lanes per panel), not rows of the frame's tables; the column's stems are drawn by the column, their targets found in the tables; a loupe's stem and a dump's place are not kinds yet. The beat's `emphasis` is not built; the carry keeps its own budget (it was drawn beside a link and a projection before, and is still: the catalogue counts it among the two active lines). The tables are made and sorted every frame, not cached per moment and window. An aim for the step (`.step`) has no slot of its own in the step's timetable (it draws after the word's strike, over what follows). The map's places and values are tabled and measured (`CANIM_RELATIONS=1`), but the map draws no relation of the frame's: its thread and arcs are its panels' own. - The tie to the stack (Part B's leftovers): the window's scroll to a touched word outside it happens in the fire's frames, with no slot of its own; in a step by line all writes land before the pins and the call row does not fire within the step; `enter`; a `sub rsp` longer than the window slides the rows (no `unroll`); at a run the pins are not drawn over the veil; a carry to a dump's run, a loupe's row or a call's return row, and a carry's stub off the window; the touch giving way to a link down the right lane over the same rows. Data names are used only in a tied row, not inside chains; a 4-byte access to a global keeps the whole chain, unnamed. - The graph: the map draws the `blocks` drawing only where the scene asks (`Context.Options.graph`: sort); the catalogue has it whenever the recording has the function's blocks. Not built: the descent on the map (the callee's drawing under its caller's), a list scene whose lens is reverse's ring (the list's subject is its nodes; reverse's ring is built and unit-tested, not drawn in a scene or the gallery), a 2 510-block `sqlite3VdbeExec` (folded from the start to its reached blocks). At a run the mark goes pill to pill along the edge only where a step crosses one edge: sort's run steps by line, three edges a step, and keeps the 8 f crossfade of the counts, the gold and the trail. In an `unfold` the edges crossfade between the two layouts rather than ride with the pills, and where the opened layout is wider than the pane the drawing shifts sideways just enough (65 units in the gallery's). `rings`' general cases beyond sort's two nested loops (a second loop in one parent, a second loop at the top level, a way between the blocks before and after a loop, a way out from a pill not at 9 or 3 o'clock) are drawn but not kept clear of the rings (`shortcut:` in `graph.zig`). Sort's angles are computed, not the mock's hand-placed ones (`+84` at 256°, the mock's `+1e` at 225°; `+c5` at about 116°, the mock's `+5f` at 75°); the header's way out leaves 30 in from its pill's end (the mock draws 12); pills keep room for `×99`, 12 wider than the mock's; libc's `open` in `layers` puts a taken target right, as the rule says (`+f0` in the right column; the mock placed by the run's path). The map's frames draw slower than before (about 0.35 s against 0.15 s: the 69 linear rows the map now draws beside the drawing, not the graph's own code). A finished loop is not folded; an indirect jump's taken targets do not become edges; a function change is not crossfaded (sort ends at its `ret` for that). - Sort's recording is the instrumented build: eleven blocks (`setg`, a `test`/`jne`, two blocks of a lone `jmp`), as the mock now has them; its prologue's calls are the tracer's (`__zt_var`), left out of `+0`'s pill. - The descent: the kernel's three rows are kept at the floor from the `syscall` to the stop after it, so the rows under the call move up again a step later. The fold past three windows (`2 calls: fib fib`), a lazy PLT's resolver row and the vDSO's window are written but no recording shows them; on the map the descent's box is as long as the rows it has wanted (the map draws the descent only where it is shown: the strip's column is the linear rows round the pc). At a run the windows do not open and close in 8 f with no lane (the syscalls scene walks every step of the descent). - `open("note", O_RDONLY) = 3` does not fit 832 from 540 (27 characters): the arguments go from the right, `open("note", …) = 3`. A call's arguments come from as many as the source's call writes, typed by the system call of the function's name (`open`, `read`): a libc function with no system call of its name has its arguments in hex. - The heap scene's drawing and view are the scene's own components (`Lists`, `Chunks` in `scenes/heap.zig`), not blocks of `src/`: no second scene needs them. It is 78 s against the storyboard's 79.4: the seconds over it went to steps the storyboard does not narrate, walked as cascades (the calls into push and pop, 3.1 s, and their prologues, 2.9 s, four times; the returns to main); those now run, and the return under the second free's caption is walked again (its reading time is longer than its steps, and the picture would stand still 3.5 s). Each `free` is now mock 18's: its line's instructions a cascade onto its call row (the recording stops there: `break_call` in build.zig, a breakpoint at pop's `call free@plt` found by objdump, which `--by line` now honours), then the call stepped over from that row (a continue's wave, the line not fired again). A `size` bit that changes is not struck on its chip. The heap's map has its drawing and view but no arena panel. - The map: `continued` is built for the stack and the source (which goes on under the disassembly when its column cannot hold its 69 lines; in no scene now, since the disassembly fills its column wherever the source is that long). The stack continued shows the words past what the recording holds as unknown rows (`··`), not folded into one `more` row after the process's start. A dump round a pointer is the bytes, typed by the objects the recording knows, its target not framed. Loupes are map panels only where the scene names them (`Map.loupes`: list, heap), and on the minimap they are strokes, not lifted blocks. The disassembly's and the view's boxes are still as long as the most rows wanted so far (`map.measure`, a frame behind; the backtrace's is now packed once, by the scene's deepest chain, so its box can be taller than the frames of the moment). The sqlite map draws the backtrace lens, not the calls so far it changes to, and no view. - The strips are the average of six drawings a frame apart (6 to 11 f behind), the panes' windows in them as long ago (`past`, kept by frame number: after a seek the first eleven frames draw the windows as they are): every change on a strip fades over 6 f, at the cost of drawing the map six times a frame while anything moves (once at rest), text collected but not shaped. Their images are a process-wide cache of the host's. Native shapes are not antialiased and images are sampled nearest, so a window gliding moves a pixel at a time: averaged, each pixel step fades over 6 f. The map's disassembly is the function from its start where it fits (so a strip's column stays still in a function); a jump to another function scrolls the map's rows, and on the strip that slide is averaged into a 6 f blur, under the pane's fade through (`map.through`). The drawing for the strips draws every part of the map but the registers, the backtrace and the spare dumps. - A pane's content is 48 narrower in the working frame (`map.content`), the map's not: the gallery's rows and any panel drawn outside a context too. The `syscalls` lens's view (the log over the bytes crossing) has no strip but its reading is still cut 48 sooner. A conditional jump's annotation (`taken · reads zf sf`) is not cut by its room: with a library's 12-digit addresses it runs under the strip by a few characters (syscalls' hurried run through `open`, sort's view). - A far jump in one file to lines the map's column also holds, at a walk, is `unroll`, the window's travel and `roll` (96 f), built and seen in frames, but no final shows one: heap's (line 15 to 30, 75.7 s) comes in a hurry, a sentence said faster, where it fades through as at a run, and sqlite's step back from `pwrite64` goes 44 lines in a column the map packs at 38 (`inColumn` reads the map's own column). At a run, and out of the column, the window glides on the strip for the advance's first half, then the pane fades out and in (48 f); the catalogue's 24 f glide, then 12 f out and 12 in, is that at a walk's 48 f, but a run's step is 18 f and the fade has its share of it. A far jump of the disassembly alone fades through over the advance, its strip going over as the advance starts. A file change (another source) fades the panel and its strip through over 24 f; at a run over the run's 8 f advance. A jump out of the column at a walk is still not told on the map (`surface`, the jump, `dive`): sqlite's continues fade through, the strips first. Its strips now keep their windows through a continue, go over as its advance starts (6 to 11 f behind it, a 6 f crossfade), about 20 f before the pane's fade, and the tag's line range changes with the pane; the step back from `pwrite64` advances over 48 f (the scene's plan; the crossing's own travel is 12 f). - The stack's window does not keep the touched word in its middle half until a step touches outside it (the catalogue's hysteresis): it is still centred on the word the last three steps touched, wherever the frame is longer than the window (with 12 to 20 slots, few are). - A quiet register is folded by the scene's clock's steps: a scene that walks finer than its clock (sort, by blocks, its clock by line over calls) could change one unmarked; none of the scenes does. - The heap scene never stops inside malloc or free (they are run through, by the PLT, at a line a stop): there is no frame of theirs to name, and no line column of theirs to show. Their lines are in the recordings as names only where a frame is (sqlite's, list's and sort's `__libc_start_call_main`, `libc_start_call_main.h:59`). - `dive`: every panel travels 60 f (the catalogue's 72 f), so that seven of them 6 f apart land by 120 f; each pane's column squeezes with it, its rows the strip will show (the column's rows past them fade with the map, where they are), and goes into the strip's own drawing over the 12 f before its pane lands (the catalogue: 84 to 96 for all), the text drawn real all the way (no strokes until the strip's); a graph's disassembly (sort) has no linear column on the map: its strip comes in as its pane lands, from nothing; the drawing does not crossfade between sizes (the list's are the same, subject on both). Only the list opens on the map; only sort surfaces (its sprint plays on the map), and no far continue plays on the map. - A loupe hung from a register keeps to the stage but does not yet move past the current marks or a changed row; on the 1920 stage a deeper one hangs under the first, not 120 to its right. The catalogue's stem is 3 in its strokes and 4 in the loupe's anatomy: it is 4 here. - At a run a dump's values, a register's (and its chain, where what it reads changed under the same value), a stack word's and a disassembly row's annotation crossfade (8 f); a node's value in `nodes` and a cell's in `array` still change in a frame (the heap's drawing crossfades its own). - The gallery keeps the old recording of the list (`test/gallery/list.ztrace`): on the build's list (by instruction) its loupe page has no second loupe, the nodes being 32 bytes apart and a loupe's five rows holding the next one's target already. - Back pointers between nodes still run under the nodes: a page keyline round each pin's stub and head shows them passing behind it (there is no lane for them in `beside`). - An `under` pin's names are in the order they came to the node (the recording read back from the stop shown), so a name that lands where another is stays on the right it travelled on; but one left alone where it was on the right keeps that side only for the step in which the other left, and takes the left at the next. A third name coming to a pin whose two sides are taken is counted (`+1`), unless it is a variable the scene names and a register holds the right, which it then takes; on its way it is drawn over the right-hand name (list, 7.5 s). A pin's count (`+1`) can run into the left-hand name of the next node's pin (list, 26 to 57 s). (In the stack's lane, rsp or rbp travelling alone keeps its place among the names it leaves and joins; both travelling to rows with other names is not handled.) - Pins travel with `time.pin`'s times, but on `standard`, not the catalogue's `glide`, in the stack's lane and the array; a pin in a drawing sets off when the idea strikes (the projection's arrival), not 18 f after its word's strike. - The disassembly scrolls or fades over the mark's advance: 24 f where the source's window moves too, 12 f where the mark only jumps. - Whether the stack's window faded at a step is judged by the slots it shows now: after a relayout to fewer, a step that scrolled may lose its ticks. - A frame's name on a `call` span is never cut (`metric.span.name_max`, 300 units, is not built); the calls tree's small and folded sizes are not built. - A link to a slot past the stack's window ends in its stub and row count: drawn in the sqlite scene only (rsi to the struct on the caller's stack, `23 rows`, 5.0 s; in a continue a link sets off with memory's strike, when the window is at its new place). One to a slot above the window would put its count over the panel's tag. - A call's result badge is on its outer shoulder (a left child's left, off its parent's disc; it lay on the parent, fib 24 s on): in fib(5) none lies on a node, but two neighbours' badges between their nodes are 4 units apart (`1][1`). Past about ten leaves nodes and badges collide (the catalogue's known case). - A view's row a register points into carries its pin at the row's end, its head toward the row (`Ui.pinEnd`): the catalogue's `row` pin has no lane in a dump, whose bracket and address take its first 34 units. The reading gives way to it (the read buffer's text reads `"Hello, …` while rsi's pin is on its row; the top's `top` note goes while a register points into its row), and a link to the row ends at its left edge, not at the pin. - The zoom scene's camera goes to x1.16, not the x1.5 decided: the stage (1792 wide) holds the instructions' mnemonics to the stack's roles at x1.16; at x1.5 the stack's chains (`fib+42`) and roles (`saved rbp`, `n`) the captions name fall off its right edge, or the mnemonics off its left; the stack's call spans are off its right edge at x1.16. - Bytes the recorder merged into one written span (a free's link and key, stored by two instructions next to each other) strike as one. - The `pages` lens is not in the band (`Timeline` is the old far view). - The map's drawing flags (`ui.mapping`, `ui.strokes`, `ui.collected`, `ui.bound`, `ui.chrome`), a dive's per-panel transforms (`context.zoomed`), the map's measured rows (`map.held`), the strips' images and the windows they keep (`map.atlas`, `map.past`, `map.current`), the ties' table and the thread's waiting are still process-wide globals, set and read in one frame's drawing (the measured rows a frame behind); two players at once would want them on the frame. Only the strips' lag is passed down now: their drawings get the frame's values with the cursor's replaced by a lagging mirror's (`Cursor.lagInto`), and `Cursor.now` no longer reads `ui.strokes`. The rest is read by components the frame reaches only through `anim.Placed`, which carries no frame state; moving them means a `Ui` that carries them from every component's first `context.at`. - A recording holds the bytes it has seen, each as last seen: it cannot tell a byte read again and unchanged from one not read since. Memory nothing watches (SQLite's page cache) is read at a stop only where a pointer leads (32 bytes), so a view of it says what the stop read (`hexdump.Fields.seen`); a syscall's buffer is shown as the kernel took it, from its capture. The recorder should say what it read at each stop. - A backtrace row's `file:line` is its call's, where the recording has the instruction before its return address (the debugger records the instructions at a frame's return address, their lines with them): a library's too where its debug info was found (glibc's `libc_start_call_main.h:59` and `libc-start.c:372`, musl's `__libc_start_main.c:95`), else none. - A program's frame arguments are in the backtrace only for calls the recording tells (an instrumented program's); at a breakpoint the callee's are in its registers, which the scene's captions name. - The sqlite scene changes what is over the band (the backtrace lens, then the calls so far) and its view (the SQL at rbx, the row, the page) by fades scripted in the scene (12 f out, then 12 f in); the kernel's side does not bring its elements in as at `establish`. - `zig build test` prints "failed command" for each scripted scene: that is the run echoing its stderr (the Vulkan headless warning), not a failure; the summary line is the verdict (none printed when it passes).