Baba Is You: A Horror Game for Functional Programmers

Level 1: The Rulebook You Can Push

Imagine a board game where the rules are written on wooden blocks sitting right on the board — and you're allowed to shove them around. Push the words apart in "WALL IS STOP" and suddenly walls don't stop anyone. Rearrange "ROCK IS PUSH" into "ROCK IS WIN" and touching a rock wins the game. The person in this post spends their workday following very strict rules where nothing is ever allowed to change sneakily — so for fun, they play a game where everything changes, constantly, because you literally kick the rulebook around the floor. Calling that cute puzzle game a "horror game" is the joke: it's only scary if rule-breaking is your day job.

Level 2: The Words Are the Walls

Baba Is You is an award-winning indie puzzle game where the rules are physical objects. The phrase BABA IS YOU written in blocks on the floor is why you control Baba (the little white creature). Push those blocks apart and you instantly stop controlling anything; rearrange them into FLAG IS YOU and now you're the flag. WALL IS STOP is what makes walls solid — break the sentence and you walk through walls.

The programming vocabulary being parodied:

• Functional programming (FP) is a style where you avoid changing data in place; functions take inputs and return outputs, like math. Languages like Haskell enforce this strictly.
• Global state is data anything in a program can modify — convenient at first, then a debugging nightmare, because anything could have changed it.
• An assignment statement (x = 5) overwrites a variable's value. FP folks treat casual reassignment the way librarians treat book burning.
• Undefined behaviour means the rules don't say what happens next — the program (or game) may do anything, including things that make no sense.

If you've just learned why your bug took three hours to find because some distant function quietly modified a shared variable, congratulations: you've met the horror genre this tweet is describing.

Level 3: Side Effects as a Genre

The tweet's craft is in genre reclassification. Murat Kasimov — fox avatar, posting to an audience that clearly includes the Haskell crowd — describes "taking rest from functional programming" by playing "a horror game with global state, assignment statements and undefined behaviour." The screenshot reveals the monster: a serene pixel-art puzzle level with a white rabbit-creature, a crab, a flag, and innocent word blocks reading BABA IS YOU, WALL IS STOP, ROCK IS PUSH, and the stacked column where CRAB, FLAG, JELLY each get their IS — DEFEAT, WIN, PUSH.

The punchline lands because every phrase in the tweet is a precise FP curse word. Global state is the thing pure FP exists to abolish — shared mutable data that makes any function's behavior depend on what every other function did. Assignment statements (X IS Y) are the imperative original sin; the game's entire mechanic is walking around performing assignments with your body. Undefined behaviour is C-family trauma — the compiler's license to do anything when you break the rules — and in Baba, pushing the wrong block genuinely produces it: make yourself DEFEAT, or unmake YOU, and reality stops having an answer for what you are. The 162 likes are from people who've spent years writing pure code and recognize the bit: the relaxation activity is an unregulated mutation sandbox, the exact thing their day job's type system forbids. It's the programmer equivalent of a health inspector vacationing at a gas-station sushi counter — and loving it, because consequence-free rule-breaking is the fantasy purity culture never offers.

Level 4: Semantics Is Rewriting

What makes this joke unusually deep is that Baba Is You isn't just metaphorically a programming language — it's a playable term rewriting system with self-modifying operational semantics. Each horizontal or vertical sentence of word-blocks (BABA IS YOU, WALL IS STOP, ROCK IS PUSH) is an active rule in the level's rule base, re-evaluated every turn. Pushing a block doesn't change a value; it changes the interpreter. In programming-language terms, the game lets you edit the small-step semantics while the program is running — the kind of reflective tower that makes formal verification people break out in hives. There is no stable type system: the predicate YOU can migrate from Baba to a rock to a flag mid-level, which is roughly equivalent to reassigning this in a language where this determines whether you exist.

Functional programming's whole theoretical project — referential transparency, equational reasoning, the lambda calculus's confluence guarantees — depends on terms meaning the same thing everywhere, always. Haskell quarantines mutation inside IO and State monads precisely so the rest of the program stays a pure rewriting system where substitution is safe. Baba Is You is the adversarial inverse: a global, mutable rule store where any agent (you) can break confluence at any moment, and where deleting the sentence BABA IS YOU mid-level is the closest games have come to letting the player dereference their own null pointer. The community has even built logic gates and automata inside levels — unsurprising, since unrestricted rewriting systems hit Turing completeness almost by accident. The horror is mathematically certified.