im gonna just ramble here a bit, i hope this is ok
im thinking about number spaces lately - basically im thinking about using 32bit addresses for things, and how big a number is 32bits. and then how i can use the 32-bit constraint to create a list of procedural (but finite) dungeons, or characters, or whatever.
(these images were made in icosa, an art program by andi mcc)
each 32 bit number corresponds to a single dungeon, a single character, a single whatever. a single text, where the space of all texts is defined, all bits are specified and all permutations are valid.
leviathan, as a book publisher, publishes all permutations of books.
if you let each octet be a different variable (each with 255 permutations), these variables together create the whole id
you can create a lot of different number spaces within this number space the same way a system architect subnets a network
x xx y yy z zz a aa
0000 0000 0000 0000 0000 0000 0000 0000
this is only one way to break down 32 bits
you could do it any way
index index
0000000000000000 0000000000000000
0000000000000000 0000000000000000
path path node
000000000000 000000000000 00000000
path page page page page page
000000000000 0000 0000 0000 0000 0000
000000000000 000000000000 00000000
path page page page page page
000000000000 0000 0000 0000 0000 0000
any number of dimensions of any length so long as they define a 32 bit space (the space of these spaces is finite, and small)
what kind of data can be packed into a 32 bit space and still be totally defined?
for instance what books can be totally defined in this way?
im thinking - can you pack all the variables for a mystery novel into 32 bits, if so write a mystery novel as a set of permuations of possible mysteries based on those variables and then generate all of the books based on that pattern? then you'll have written 4 billion books. is this desirable? maybe you could include some kind of meta mystery that could only be glimpsed by reading many mysteries.
for instance what books can be totally defined in this way?
im thinking - can you pack all the variables for a mystery novel into 32 bits, if so write a mystery novel as a set of permuations of possible mysteries based on those variables and then generate all of the books based on that pattern? then you'll have written 4 billion books. is this desirable? maybe you could include some kind of meta mystery that could only be glimpsed by reading many mysteries.
all
things must be generated procedurally from 32 bit addresses. no matter
what the 32 bit input is, the program always displays something. those
32 bits should be totally defined by the program. such that whatever
bits you feed it it still generates a valid permutation of the thing.
all 32 bits are defined therefore all permutations are valid.
if every machine accepts a 32 bit number, interprets it and displays that permutation, what are the ramifications of that?
what
if you put the number in the wrong machine, what if the machines feed
into one another - all these datatypes we can create this way would
collide and decay, and what kind of stories would that create?
one
story i had was null, the void, is always scary, you never want to use
the null state, you always throw that one away. the reason being that
the void can leak through into this world if invoked
![]() |


