paint in the memory of other programs

the cool S, a heart, and a cat scribbled above a program's stack

core is a program that I wrote which spills the viscera of other programs onto the screen and allows you to prod them. it could be called an “esoteric debugger” or a “paint program.”

the visual content of the program is constructed as follows:

  • pages of memory (hardcoded for now as 4096 bytes) are arranged on a Z-order curve.
  • each page of memory is displayed as a 256x128 rectangle.
  • each pixel represents a bit. a white pixel represents one, and a black pixel represents zero.
  • the bits are arranged in rows, and the bytes are arranged in columns

the text and data segment of a program

as well as the display of program memory, core allows for its manipulation. if core shows you a picture of a program’s insides, then it is only natural that it allows you to scribble on it. the overcommitted empty space below the stack stack provides an inviting empty space to scribble in. it’s a perfect place to hide your terrible secrets in some poor, innocent process.

WARNING: scribbling on programs may cause loss of data!

core is the logical conclusion of blinkenlights, “Allblinkenlights,” if you will. the intended experience is evocative aimlessness. the human visual system is highly parallel and very good at recognizing patterns. you are encouraged to allow these patterns to wash over you.

many textures arise from different kinds of data in memory. ASCII text is incredibly recognizable, by virtue of being a 7-bit encoding, as well as having a biased distribution of values. 64-bit pointers are similarly easy to recognize because their last two bytes will either be zero or one.

a view of the stack of a program. there are text and arrows scribbled in empty spaces, pointing to ASCII data, *envp and *argv, and return addresses

in the mesmerizing undulations of complex programs, these textures may blink or move around or stay boringly still. if you are keen, you may catch some large data structure being allocated or filled in. or you may see the first generation of a garbage collector fly by as short-lived objects are created at a rapid rate. in games, the stack can be seen flickering rapidly and changing every frame.

core can make stark the immensity of memory and the way that programs use it. data structures and programming patterns appear in the physical reality of which bits are toggled where.

I was very keen to see what a program would look like that uses continuation passing style implemented as in the famous paper, CONS should not CONS its arguments, part II: Cheney on the M.T.A. I compiled a game programmed in CHICKEN scheme and was delighted to see a stack that moved like a waterfall.

a stack continuously filled with pointers

graphical programs can be the most interesting. visual patterns in graphics in memory can emerge vividly.

sprites from super mario brothers are visible in the memory

when attached to virtual machines or emulators, core gains omniscience over an entire operating system.

many, many pages filling the VM memory porously

it is astounding to see an immense creature flicker to life. pages fill empty space in speckled patterns. panning over a chasm, the page tables can be seen vibrating and filling in with new allocations. it is reminiscent, perhaps, of insects, like a beehive.

one could not hope to wholly understand the way that physical memory is arranged, but they may peer voyeuristically into random pages of process memory, abound with text strings and recognizable graphics.

windows XP icons are visible in the memory: two Xs, an information symbol, and a question mark bubble

more XP icons: more Xs, an alert symbol

programs often exist in the mind as something ineffable, intangible, and abstract. even their physical existence is locked inside black plastic squares, harboring impossibly tiny transistors. in my opinion, to lay visceral the individual bits in a computer program is an idea that despite being simple, is immensely potent.

peer into the core.

ferrite core memory