| Commit message (Collapse) | Author | Age |
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. Registers come second, between memory and the stack:
sixteen rows each with its chain, rip pinned on the code band and rsp
and rbp on the stack's, a register opened into its parts (rdi, edi, di,
dil) as one write touches one byte, a call to malloc stepped over with
its result in rax, the registers a scene never changes folding three to
a row. The four chapters join in one timeline: a 2.1 s seam with the
chapter's title said and kept as the clock's label, one recording's
clock. Mocks 58 to 62.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
| |
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
The storyboard and catalogue follow what the introduction became after
its review: the plain build, chapter II's six beats with the stack's
convention said and the call before the push, the regroup's bytes flying
one at a time over their row, the dump folding into its tag, the Eiffel
visit at x2 with the 128 bytes marked, hex offsets, names only after
the things. The aim's head is 10; a beat's link fades its head as it
draws back. Mocks 29, 30, 31 and 37 redrawn.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
one data model
From the user. aim joins a value on screen that is a code address (a
return address, a function pointer, a GOT slot) to its row in the
disassembly, off unless the scene's author turns it on; when the word is
overwritten the head glides to the new row, or frays when it no longer
points at code. Every relation is now one model, as data: tables per
frame of places, values that may be addresses and the step's events; the
kinds as one table of their joins, knobs, priority, ink, route and
timing; a resolver of six passes over those tables, one budget, and no
kind drawn because the budget has room.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
introduction storyboarded
From the user: the column style is a tool a scene's author can use. It
is a standard form beside the working frame (which stays the default):
for stories of rows going down and back. A scene changes form in a rest,
in a fixed order, about 70 frames each way. Bubbles fit their reading in
their lead and steps; panes change only when the subject moves. The ASan
pair (112 s) uses the pair, then the column while plain runs on alone,
then the pair for the fault; the introduction (123 s) mixes the frame at
x2, the column for the address space and the stack, and text above the
aligned code.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. A scene may set its text in a column beside the panes a
beat is about: col.beat names the panes and their rows, where the text
is placed (beside, below, above, or on a drawing) and what it is level
with; panes the beat leaves out fold to their title bars on a shelf,
their changes struck there. Tried as two scenes beside the originals:
the call followed down (column) and a bubble on sort's rings
(column_sort).
annotation = .tied names the word an instruction touched and draws a
touch to its stack row; offsets count from the frame's base; rsp's pin
travels with its amount before the stack follows; .whole keeps the full
chain. carry = .arrow draws a value's way between memory and a register.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
text as an experiment
From the user. A fact is printed once, in the pane that holds it: under
annotation = .tied a row names the word it touched and a touch line
ties it to its stack row while a step is walked; .whole keeps the full
chain. An instruction that moves rsp or rbp says the amount, and the pin
travels row to row with the rows it gains or releases marked, the stack
following only after it lands. Every strip is ordered cause before
effect and numbered. carry is an optional arrow from memory to a
register. An experiment sets a column of text bubbles beside the panes a
beat is about, each bubble level with what it speaks of, tried on the
call followed down; text may also stand below, above or on a drawing.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. In every split the disassembly stays under the source;
registers a scene never changes fold three to a row, and the stack takes
the room: nine to twenty slots where it had six. The graph's first form
is rings: a loop a ring its blocks sit on, an inner loop a smaller ring
touching its parent, a way out leaving along the tangent; layers stay
for functions without loops. Its layout comes from the code alone and it
shows nothing from after the moment: a block not reached yet is quiet
and is reached, a fold of what is not reached yet opens when the run
arrives. A pane unrolls from its strip into its whole column and rolls
back. The sqlite scene's strips move before their panes.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. A loop is a ring its blocks sit on, upright, an inner loop
a smaller ring touching its parent, a way out leaving along the tangent;
layers stay for functions that are trees of branches; the track is
withdrawn. A graph shows only what the run has done by the moment shown:
counts so far, a block or edge not reached yet drawn quiet, a fold of
what is not reached yet that opens when the run arrives (reach, unfold);
the rule stands in Forbidden for every block. A pane unrolls from its
strip into its whole column and rolls back, so the whole function or the
whole stack can be shown for a beat and a far jump is travelled.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user, on the sort render. Registers a scene never changes fold
three to a row, so the stack is twelve to fifteen slots and the
disassembly keeps its place under the source with eleven to seventeen
rows; a blocks lens has no view. The graph leaves the layered picture of
the reverse-engineering tools: blocks are pills on one line in the order
they run, a loop an arch over its blocks with the turn count at its
centre, every bend a quarter circle; sort's eleven blocks and both loops
are seen whole across the band. Sheets 42 and 43 set the layouts and the
graph's forms side by side.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
| |
From the user: the pair read best with the return half written. Its
eight stores are walked one at a time, each turning the reading a step
stranger, with a rest at the half-written word while the ASan side
stands on its report. Mock 38 is the scene's poster.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. In the pair a frame is a dump of eight bytes a row read
by its own fields, so each turn of the loop is one more letter and the
letters are seen to cross from buf into the saved rbp and the return
address, which reads as code until they reach it. Each pane with more
than it shows carries its own minimap, a strip of its column of the map
at four units a row with the pane's window outlined and what happens off
the window marked there; the corner minimap is gone, and in the dive
each column of the map folds into its pane's strip.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
aligned in two forms
From the user. The address space is a slim bar to true scale with its
two ends written, each cluster enlarged once beside it, and every band
carrying the addresses where it starts and stops and its size; no
rulers, no factors. The stack's bytes on screen are tied to their place
in it. regroup is drawn: a word's eight bytes fly out low byte first and
land reversed as its sixteen digits. aligned has two forms a scene asks
for by name: interleaved, a line as the head of its instructions, and
columns, the source beside them with each line as tall as its run.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
| |
From the user: the view's worth is the feel of the space's size, with its
ends in the picture. The whole user half is one rectangle to linear
scale, the mappings hairlines where they are, and what cannot be read is
enlarged beside it with the magnification's lines and its factor. The
mocks are rough: lines through labels, the program's bands unnamed.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. segments is the textbook picture: one rectangle, high
addresses on top, each mapping a band in its ink (heights by the log of
their size, holes folded with their size beside them), labels outside on
leaders, a file's mappings bracketed as one, the stack's and the heap's
growth as arrows, rsp and rip pinned in their bands. aligned is one
panel: a line as the head of its instructions, line numbers and
addresses in one column since both say where, a rule over every head.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
disassembly aligned
From the user. Three short chapters teach the frame by assembling it:
bytes become words, words that are addresses take the ink of the mapping
they point into, the stack's conventions are shown on those same rows by
a real push and call, an instruction's bytes decode into its row beside
its source line, and the working frame stands at the end. segments is the
process's mappings as rows, the legend's long form. aligned is a split a
scene chooses: each source line level with the first row of its
instructions. Verbs for building a view: regroup, ink, column, frame up,
decode, align.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user. The disassembly's alternate form at a larger scale is the
graph of its basic blocks: a block a box of rows with its offset, lines
and visit count; execution flows down and a back edge is the one thing
that climbs, in its loop's lane with the turn count; what the run never
reached folds away. On the map it takes the disassembly's place; in the
working frame a blocks lens draws its shape and the rows are its view.
Verbs leave and turn carry the mark along an edge.
Two runs of one program share a frame as a pair: the seam is the gutter,
the source shared above, rows only one run has and values that differ
marked at the seam. The scene it is made for sets a plain build against
an ASan one in a stack overflow: the frame beside its shadow bytes, the
store beside its check, and the step where they part.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
at its storyboard's length
The motion check counts a third of the one-frame changes it did: the
minimap's changes fade, and a register's value, a flag, a role, a pin's
names, a tag's note, a backtrace row, a call tree's node and a dump row
crossfade where they changed at once. What still fires is named in the
README; an encoder's keyframe and the gallery's cuts are exempt by name.
No caption stands over twelve seconds or under its reading time. The
heap scene is 78 s: what the storyboard does not narrate runs, and each
free's line cascades onto its call row (line stepping stops at a
breakpoint for that). On the map, leftover space holds the stack
continued, dumps round what the registers and the stack point at, open
loupes and the key: between 1% and 13% of a map is page, where it was 14%
to 42%.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
A caller keeps one row after its call and its callee sits under it;
opening and closing fade what is given up before what is kept glides,
and nothing changes in one frame. A system call stepped over is three
parts: the registers set, the crossing from the call row, the stores
after it. A loupe never covers a row its step changes, hangs over the
stack when opened from a view, and closes with the advance. A run draws
no strikes and no arcs, and a caption never names what the pace veils;
the heap scene's captions have landing and leaving frames. The map's
boxes are as tall as their rows. The veiled map travels into the
minimap. The motion instrument checks captions and fires POP on any
one-frame change after stillness.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
the heap as a scene
From the user. Direction and nearness are rules: the idea, the source,
its instructions, the callee and the kernel go down the frame, a call
goes down and a return comes up, and every tie runs one of those ways.
The disassembly can descend: a window a call depth, the caller keeping
three rows with its call waiting, a PLT stub its jump, the kernel at the
bottom on vellum, with verbs descend, cross and ascend. The kernel leaves
the band, which keeps the calls so far as strace writes them; the
backtrace has its newest frame at the bottom. Size words are dropped
from operands and a width is shown as byte cells where nothing else says
it; a compare shows its values and flags, a jump the flags it reads, an
indirect call its target and the slot it was read from. libc's heap is a
scene of blocks that exist (a dump by fields with a size and a protected
pointer read, arcs as the free list, a loupe into the tcache, the list
drawn over malloc's own), storyboarded on glibc 2.44. Mocks 16 to 18.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
From the user, on the loupe's mock: a pointer in memory named a row two
above it and nothing showed it. In a dump, a loupe and the stack a
pointer whose target is a row of the same panel is an arc in a lane at
the panel's edge, as a jump is in the disassembly: quiet while it stands,
full ink in the step that writes or reads it, a stub when the target is
just off the window. A chain shares a lane. A loupe carries the arcs
among its own rows; the stack's frame chain gets one only when touched.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
| |
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user, on the 4K mocks: the space was not well used, and the
dense view is better as where a scene starts or as a minimap than as the
frame it works in. The map is the same moment with every panel at full
length on 3840 by 2160, packed by content. The working frame is the 1920
stage again, each panel a window on its column of the map, with the map
at a twentieth in the caption band: windows outlined, marks no window
shows flashing there. dive and surface carry a scene between the two,
each window travelling to its panel's place. The loupe hangs from its
pointer in the working frame. Mocks 16 to 18 are withdrawn; 19 is the
map, 20 the dive in four instants, 21 a loupe with the minimap.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
From the user, after the second videos. The stage is 3840 by 2160 at the
same type size: four columns (source, disassembly, state, stack), 69
lines, rows and slots with no lens, 43 with a lens as subject, dumps of
32 rows. Code reads at 1440p and up; the caption, the clock and a lens's
drawing are doubled, and the camera at x2 is the old frame. The stack's
rows carry their offset from rsp and a role. A loupe is the telescope as
a floating panel: the memory round what a pointer leads to, lifted over
the context, a pointer inside it opening the next. The current row is a
white wash, a strike a softened vermilion, held a turned corner; sheet 15
sets the alternatives side by side.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
The SQLite scene needed blocks the catalogue had no name for; each is
placed. A dump is read by its type or by fields a scene gives it, rows
without one folding into a row that counts them; bytes that are no field
are loose; what a stop did not read is unread and what the kernel took is
given. Addresses and line numbers are as wide as the program needs. The
backtrace can be a lens's drawing, and a lens can change in place. A
continue is a verb of its own: registers strike in a wave, far windows
fade through and arrive without marks, frames two stops share slide. The
kernel's answer is filled before it travels. The calls tree has sizes
past ten leaves and folds past thirteen. Mocks 13 and 14 are two stops of
the SQLite recording.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
|
| |
|
|
|
|
|
|
|
|
|
|
|
|
|
| |
An independent review of the first videos, frame by frame, is placed in
the catalogue. A lens is a drawing over the program column and its view
over the state column (the dump; the backtrace for calls), which leaves
the stack six slots as subject: the frame whole, from rsp to past rbp.
Operands are whole. A mark covers the bytes that changed. A pin travels
and keeps its side. A call's node is a projection of its return address.
Fast passes are veiled. Captions have numbers a scene can be checked by,
and a scene's first step comes by four seconds. Effects before causes
and panels from different moments are forbidden by name. Mock 12 draws
fib(4) calling fib(2) from the recording.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
|
| |
|
|
|
|
|
|
|
|
|
|
|
| |
The README is now the catalogue: atoms, rows, panels, ties, the frame and
the verbs, each block specified once under the name the code uses, with
rules of composition and what is forbidden. From the user's notes on the
context mocks: a lens is a band across the top, its drawing on the left
and the bytes it is drawn from on the right, a hexdump with each field's
bytes marked and read at the row's end; the disassembly is seventeen rows
in address order with a source-line column and an annotation for what
each row read, set or jumped to; a register is pinned to the node it
points at by name; hex is unbroken; and four kinds of tie say which pane
is a view of which (thread, link, projection, echo).
|
| |
|
|
|
|
|
|
|
|
|
|
| |
The user's premise: show what pwndbg shows, hide nothing; the semantic
views stay as a lens on the machine. So every frame holds the registers
(all, each followed as a pointer), the stack telescope and the backtrace
in a column that never changes, and the source, the disassembly and the
scene's lens in the other. A value's ink says where it points (stack,
heap, code, data; rwx underlined), its paper says what happened to it.
JetBrains Mono NL for everything mono; the floor is mono 20, which a
phone does not read: what narration depends on is also in the caption.
Mocks 9 to 11 are drawn from a real recording of targets/list.
|
| |
|
|
|
|
|
|
|
|
| |
motion.md: the animation principles as they apply here, a timing chart at
60 fps for each kind of event, revised motion tokens, and a timestamped
critique of the five scenes as first rendered. motion/motion.py draws a
per-panel timing chart of a video and tiles its frames into contact
sheets; charts/ and sheets/ are what the critique was read from. Measured:
in fib 75 steps start three or more panels on the same frame, 68 changes
have no frame in between, and the run is 68 evenly spaced steps.
|
|
|
Lapis page and vellum ink; a role is a form as well as a colour (current,
write, read, pointer, allocated, freed, fault, kernel); panels as acme
windows; Go Mono for the machine and Go for the narrator; motion as whole
frames at 60 fps. design/mock/gen.py redraws the mocks from the tokens.
|