Each one demonstrates a single mechanic.
A meaningless scatter of letters across five rows. Each character falls straight down in its own column; the bottom row assembles into a valid print statement. Prints 'wake up'.
nt w e "
r p
p a
i
" k u
print "wake up"
wake upCharacters strewn over five rows with no apparent order. Gravity drops each column independently and the floor becomes the program. Prints 'it falls into place'.
f s o a
int "it l n l
pr l p c
i e"
a t
print "it falls into place"
it falls into placePure noise until it lands. Every column settles to the bottom and the settled row parses as one print. Prints 'assembled from chaos'.
le o a
p " s b m ch
n d
ri t a r os
s em f "
print "assembled from chaos"
assembled from chaosco and de sit at opposite ends of one row. Matched wind fields push the two halves toward each other; they land adjacent and stack into 'code', which four @[] reads recover. Prints 'merged: code'.
co de >>>>>>> >>>>>>> <<<<<<< <<<<<<< >>>>>>> >>>>>>> <<<<<<< <<<<<<< ################################################### print "merged: " + @[3, 19] + @[3, 20] + @[3, 21] + @[3, 22]
code
###################################################
print "merged: " + @[3, 19] + @[3, 20] + @[3, 21] + @[3, 22]merged: codeFive letters drop onto a wall pierced by narrow gaps. The wall acts as a censor — only the letter aligned with a gap reaches the floor. @[] reads it back. Prints 'got through: L'.
H E L L O #### #### ############################# print "got through: " + @[2, 4]
H E L O
#### ####
L
#############################
print "got through: " + @[2, 4]got through: LFour letters fall onto a wall with a single gap. Only the one above the gap passes through to the floor below; the rest rest on the wall. @[] recovers the survivor. Prints 'fell through: B'.
A B C D #### ############## #################### print "fell through: " + @[3, 4]
A C D
#### ##############
B
####################
print "fell through: " + @[3, 4]fell through: BA piece crosses a wind field that pushes it right, drifts, then crosses a second field that pushes it back left. It settles at its original column. @[] reads it. Prints 'bounced back to: X'.
X
>> >>
<< <<
####################################
print "bounced back to: " + @[5, 8]
X
####################################
print "bounced back to: " + @[5, 8]bounced back to: XSeven letters on seven rows all fall into column 0 and pile into a stack. Earlier rows rest lowest, so reading the column bottom-up recovers 'Liminal'. Prints 'tower: Liminal'.
L i m i n a l ############################################################### print "tower: " + @[6,0] + @[5,0] + @[4,0] + @[3,0] + @[2,0] + @[1,0] + @[0,0]
l a n i m i L ############################################################### print "tower: " + @[6,0] + @[5,0] + @[4,0] + @[3,0] + @[2,0] + @[1,0] + @[0,0]
tower: LiminalFour letters drop onto an alternating wall of pegs. Some are caught on top; others slip between pegs and settle deeper. A read from column 0 recovers the letter that was blocked. Prints 'left of gap: A'.
A B C D # # # # # # ################### print "left of gap: " + @[1, 0]
A D # #B # C# # # ################### print "left of gap: " + @[1, 0]
left of gap: AA drifting piece marches sideways until a wall blocks its diagonal step; the drift is cancelled and it falls straight down. @[2, 23] reads where it landed. Prints 'X stopped at col X'.
<§drift=+5 §>X
#
##############################################
print "X stopped at col " + @[2, 23]
X #
##############################################
print "X stopped at col " + @[2, 23]X stopped at col XThree prints, no walls. Each row falls and stacks intact; the interpreter reads the grid bottom-up, so the earliest source row runs first. Prints 'one', 'two', 'three' in source order.
print "one" print "two" print "three"
print "three" print "two" print "one"
one
two
threeTwo legs as let-bindings on their own rows, a print above them. All three rows settle into one shared program; the print sees a and b defined below it. Prints '25'.
let a = 3 let b = 4 print (a*a)+(b*b)
print (a*a)+(b*b) let b = 4 let a = 3
25A let row binds a joined string; the print row above it reads that variable back. Two rows, one environment. Prints 'hello, world'.
let phrase = "hello, " + "world" print phrase
print phrase let phrase = "hello, " + "world"
hello, worldSix pieces scattered across six rows. They fall and stack into a single line that reads as one print statement. Prints 'helge@example.com'.
print
"helge"
+
"@"
+
"example.com"
#############################################
print "helge" + "@" + "example.com" #############################################
helge@example.comTwo @[r, c] references pluck letters straight out of the settled grid and concatenate them. The program reads its own surface. Prints 'hi'.
hi #### print @[0,0]+@[0,1]
hi #### print @[0,0]+@[0,1]
hiThree @[r, c] lookups read letters out of the grid and concatenate them into a word. Prints 'cat'.
cat #### print @[0,0]+@[0,1]+@[0,2]
cat #### print @[0,0]+@[0,1]+@[0,2]
catA single letter sits in the grid as data; @[0, 0] reads it back into a print. Prints 'echo:h'.
h #### print "echo:"+@[0,0]
h #### print "echo:"+@[0,0]
echo:hAn entire print line drifts three columns right and still parses as one statement; @[1, 16] reads the first character of the shifted line itself. Prints 'shifted by 3, first char = p'.
<§drift=+3 §>print "shifted by 3, first char = " + @[1, 16] ####################################################################
print "shifted by 3, first char = " + @[1, 16]
####################################################################shifted by 3, first char = p<§drift=+N§>{…} shifts only what's inside the braces. The 'hi' string slides right while the let scaffolding around it stays put; the line still parses and runs. Prints 'hi'.
let value = <§drift=+5 §>{"hi"}
print value
##################################
print value let value = "hi" ##################################
hiA one-row program. There is nowhere to fall. The baseline: the bottom of the grid is a small expression language. Prints 'hello, liminal'.
print "hello, liminal"
print "hello, liminal"
hello, liminalWidth times height — the smallest multi-step calculation, evaluated as the one settled row. Prints '15'.
print(5*3)
print(5*3)
15A negative drift carries a whole print line three columns left as it falls. It stays contiguous, so it still parses. Prints 'drift-left'.
<§drift=-3 §>print "drift-left"
print "drift-left"
drift-leftA strength-1 wind field nudges a falling print one column right before it lands. The shift closes the gap but the statement survives. Prints 'blown'.
print "blown" > >
print"blown"
blownCautionary demo: a +1 drift on a whole print row shears its operand off onto another row as the line falls. The remaining fragment no longer parses — it errors with 'expected expression'. Spatial code can break itself.
<§drift=+1 §>print "drift"
"drift"
printA wall catches a drifting piece and it stacks on top. Pure physics — watch it in the playground; it produces no output.
<§drift=+1 §>x
####
####################
x
####
####################A drifting piece descends past four staircase pegs, each just out of its path, so the drift survives every step. Animation only, no output.
<§drift=+2 §>X
#
#
#
#
##############################################################
#
#
#
X #
##############################################################Three letters on one row carry scoped drifts of -3, 0, and +3. They fan out as they fall and settle in three columns. Animation only, no output.
<§drift=-3 §>{a} <§drift=+0 §>{b} <§drift=+3 §>{c}
##############################################
a b ############################################## c
A row of dots all share a +1 drift and march together as they fall, landing on a diagonal. Animation only, no output.
<§drift=+1 §>. . . . . . . . . . . . . . . . . . . . . . . . ##################################################################################
. . . . . . . . . . . . . . . . . . . . . . . .
##################################################################################The playground loads any of these as a starting point. Edit them, change the walls, add drift, see what falls where.