systemic-game-design-course/docs/research/baba-is-you.md

Baba Is You: source research for the systemic design course

Researched 2026-10-28. Every behavioral claim below cites a page that was actually retrieved during this session.

About quote fidelity. Fandom wiki quotes are verbatim from the MediaWiki wikitext. That text was pulled with api.php?action=parse&prop=wikitext, so template markup such as {{O|BABA|IS|YOU}} has been rendered by hand as BABA IS YOU. Esolangs quotes are verbatim from action=raw. baba-is-auto quotes are verbatim from raw.githubusercontent.com. Game Developer quotes came through a fetch tool that summarizes pages and caps quotes at about 125 characters. They are excerpts, so check them against the page before printing.

Authority caveat. The Baba Is You Wiki is an unofficial community wiki. Its Order of Operations page names internal Lua functions (domovement(), block(), ...), which suggests it was written from the game's shipped Lua scripts, but Hempuli did not author it. baba-is-auto is a fan simulator of a subset of the game, and its own docs say it diverges from the official game in several places.

---

Sources

1. baba-is-auto (utilForever): rule-language.md and repository structure

• URL: https://github.com/utilForever/baba-is-auto/blob/main/Documents/rule-language.md
• Raw: https://raw.githubusercontent.com/utilForever/baba-is-auto/main/Documents/rule-language.md (loaded, HTTP 200)
• Also loaded: the README (via github.com), ARCHITECTURE.md (raw), Includes/baba-is-auto/Rules/Rule.hpp (raw), and the repository tree via the GitHub API.
• Summary. A C++17 simulator of a subset of Baba Is You, with pybind11 Python bindings, a pygame GUI, an ImGui editor and reinforcement-learning environments. rule-language.md is a capability matrix (Implemented / Partial / Unsupported) measured against official version 481d. A rule is a triple of objects plus optional conditions. RuleManager stores and queries the active rules, and Game parses rules and runs movement and effects. Tests live in Tests/UnitTests/GameTests.cpp (C++) and Tests/PythonTests/test_*.py, and each matrix row links to the test that proves it.
• Structure: Includes/baba-is-auto/{Games,Rules,Enums,Agents}, Sources/baba-is-auto/..., Extensions/{BabaPython,BabaGUI,BabaEditor,BabaRL}, Resources/Maps, Tests/{UnitTests,PythonTests}, Documents/.
• Verbatim quotes:
  • "This page records the rule language implemented by the current simulator. The comparison baseline is Baba Is You version 481d"
  • "External references are comparison aids; repository code, focused tests, and maps define the simulator's behavior."
  • Rule representation (Rule.hpp): Rule(Object obj1, Object obj2, Object obj3, std::vector<RuleCondition> ruleConditions = {}); and std::tuple<Object, Object, Object> objects;
  • NOT row: "Partial | NOT LONELY and NOT before ON, NEAR, or FACING are parsed. Negated subjects, predicates, condition targets, repeated NOT, and nested forms are unsupported."
  • AND row: "Subjects and predicates expand into independent rule combinations. Condition targets and consecutive conditions may also be joined with AND. Verb chaining is not supported."
  • TEXT row: "As a subject it selects text instances, and all text is pushable without an explicit rule."
  • IS row: "performs snapshot-based noun transformations. Multiple noun predicates may produce multiple objects; an identity result protects the source."
  • FLOAT row: "Partial | Separates OPEN/SHUT interactions by float layer. It is not applied to the other overlap/effect properties." (This differs from the official game. See g.)
  • ARCHITECTURE.md: "Parse horizontal and vertical NOUN IS NOUN/PROPERTY rules from text tiles." / "Text tiles are movable blockers during movement checks, even when they do not have an explicit PUSH rule." / "Rules are rebuilt after every move, so moving text can immediately change the active rule set."
• Also loaded (2026-10-29, for Module 8): Sources/baba-is-auto/Games/Game.cpp at commit 2305a3d (raw). Movement is two-phase. Game::CanMove (line 1756) checks the move recursively before anything changes: "// Check boundary" returns false off the map, then STOP, then whether the pushed objects can move. Game::ProcessMove (line 1865) and Game::ProcessPush (line 1910) then move the objects. PUSH, STOP, text and OPEN/SHUT are branches inside CanMove.
• Also loaded (2026-10-29, for Module 9): the same Game.cpp at commit 2305a3d (raw). Game::MovePlayer (line 495) is the whole turn as a fixed list of calls: ProcessPlayerMove(dir), ParseRules(), ProcessDirectionProperties(), ProcessMoveProperty(), ParseRules(), ProcessTransformations(), ParseRules(), then ProcessSink(), ProcessWeak(), ProcessHotMelt(), ProcessDefeat(), ProcessOpenShut(), then CheckPlayState() and a last ParseRules(). Each hazard function collects ids over the whole map and removes them after the scan. CheckPlayState (line 2160) sets PlayState::WON when a YOU instance stands on a tile with a WIN property, and PlayState::LOST when no YOU instance is found. None of the hazard functions checks FLOAT, consistent with its rule-language.md FLOAT row.
• Course use: a good example of how to represent rules as data and pin behavior with tests. Do not use it as an authority on official game semantics. It does not implement IS NOT for properties or nouns, it hard-codes text as pushable, and its FLOAT is partial.

2. Game Developer: "Designing Baba Is You's delightfully innovative rule-writing system"

• URL: https://www.gamedeveloper.com/design/designing-i-baba-is-you-i-s-delightfully-innovative-rule-writing-system (loaded via WebFetch)
• Summary. Written by John Harris, published May 8, 2019. Arvi "Hempuli" Teikari describes how rules are rebuilt: the game rebuilds only when text has changed, clears the old rules, detects candidate sentence starts, and resolves conflicts such as NOT at the end. He says stacked text was one of the hardest parts of development and explains why he used Lua on top of Multimedia Fusion 2 (MMF2).
• Quotes (excerpts returned by the fetch tool):
  • "The game only updates the rules if it needs to"
  • "The previous rules are removed entirely, and words that could potentially start rule sentences are detected on the level."
  • "Finally, once everything is (hopefully) set, the game goes through the final set of rules and adjusts them if needed."
  • "(For example, if the rule "Baba Is Not You" exists, "Baba Is You" is marked as being not valid.)"
  • "the stacking adds the need to go through all the possible permutations a rule could have"
  • "Lua allowed me to implement the game logic in ways MMF2's base "event system" couldn't have done without a lot of hassle"

3. Baba Is You Wiki: Order of Operations

• URL: https://babaiswiki.fandom.com/wiki/Order_of_Operations
• Direct HTML fetch failed: WebFetch returned HTTP 402, and curl returned HTTP 403 for Order_of_Operations, Order_of_operations and Turn_order.
• WebFetch of web.archive.org is blocked for this tool. A snapshot exists (http://web.archive.org/web/20251213151454/https://babaiswiki.fandom.com/wiki/Order_of_Operations) and was downloaded with curl, but it was not used as the primary text.
• Loaded via the MediaWiki API: https://babaiswiki.fandom.com/api.php?action=parse&page=Order_of_Operations&prop=wikitext&format=json
• Summary. This is the authoritative-looking turn pipeline:
  1. domovement(): YOU, then MOVE/AUTO/CHILL, NUDGE, FEAR, SHIFT. Conditions are reparsed between movement stages. Collision reactions are resolved inside movement: OPEN/SHUT, WEAK/EAT, SWAP, PUSH/PULL, then STOP.
  2. Rule parsing.
  3. Transformations (REVERT, IS, WRITE).
  4. Rule parsing.
  5. moveblock(): FOLLOW, BACK, TELE, SHIFT.
  6. SELECT, then the stack limit.
  7. fallblock().
  8. Rule parsing.
  9. statusblock(): directions, TURN, FLOAT.
  10. fallblock() again.
  11. Rule parsing.
  12. levelblock().
  13. block(): SINK, BOOM, WEAK, HOT/MELT, DEFEAT, OPEN/SHUT overlap, EAT, MAKE, then BONUS/END/WIN, then out-of-bounds deletion and CRASH.
  14. Rule parsing.
• Verbatim quotes:
  • "Within a turn, most properties and verbs take place exactly once. Conditions process when the game checks for what objects have a rule, which is usually right before it uses it."
  • "domovement(). ... Note that it completely finishes moving for a particular move stage before checking which units are in the next, so conditions (e.g. IT ON BABA IS YOU AND MOVE) reparse in between."
  • "* (rule parsing)
    • REVERT and object transformations via IS and WRITE. While they are checked in the same step, REVERT takes priority over the others while '''X IS ALL''' takes the lowest priority. *(rule parsing)"
  • "block(). Deletion occurs after each step that removes objects, but all objects destroyed in the same step are destroyed simultaneously. ** DONE ** MORE ** PLAY ** HOLD ... ** SINK ** BOOM ** WEAK ** HOT MELT ** DEFEAT ** OPEN SHUT (collision check; movement check occurs on movement) ** EAT (collision check; movement check occurs on movement) ** MAKE ... ** BONUS, END, WIN (ran in this order; deletes from bonus don't occur until after) ** Delete out of bounds units ** CRASH * (rule parsing)"
  • "Movement check response properties: Before first parsing, the game checks for collisions after every movement step in the following order. * OPEN SHUT * WEAK EAT are checked simultaneously * SWAP * PUSH PULL are checked. * OPEN SHUT for pushed/pulled objects * WEAK EAT for pushed/pulled objects * Passive SWAP * STOP"
  • "HAS is checked after every standard destruction, no matter whether the destruction is checked on collision or overlap."

4. Esolangs wiki: Baba Is You

• URL: https://esolangs.org/wiki/Baba_Is_You (loaded via WebFetch, then raw via ?action=raw)
• Summary. Treats the game as a cellular automaton or esolang and gives a table of words. It contains no order of operations. The page is marked WIP.
• Verbatim quotes:
  • "Text is parsed when nearby other text objects from left to right and top to bottom, and multiple rules are able to cross and overlap if the parsing rules allow for a valid statement."
  • "The primary goal of a level is for any controllable object to exist on the same tile as any object that is defined as "WIN", which may also be itself."
  • PUSH: "Actors which move into the object will cause it to move in the direction that the actor entered from. If the object is unable to move, the actor will not perform its move."
  • STOP: "Like PUSH and PULL, actors that attempt to enter will be blocked."
  • OPEN and SHUT: "Any objects which are OPEN will destroy itself and any objects that are SHUT when moving into them, and vice versa."
  • SINK: "The object will destroy itself and any actors with it when it shares a space with an actor."
  • FLOAT: "Any actors which are BONUS, BOOM, DEFEAT, END, HOT, MELT, OPEN, SHUT, SHIFT, SINK, TELE, WEAK, WIN, or acting upon it through EAT will not affect the object, unless it itself is also FLOAT with it."
  • "If an object is to leave the bounds of the level, it is immediately destroyed." (The fandom Order of Operations page says out-of-bounds deletion happens at the end of block(), so "immediately" is loose.)

5. Baba Is You Wiki: property and word pages

All pages were loaded as wikitext via https://babaiswiki.fandom.com/api.php?action=parse&page=<NAME>&prop=wikitext&format=json&redirects=1. Direct HTML returns 402/403.

Page	Status	Key verbatim quote(s)
PUSH	loaded	"PUSH is a property that makes an object pushable by any moving object. PUSH also makes the object "solid" for collision checks like STOP does." / "TEXT IS PUSH as a base rule." / "If something tries to move into a PUSH object, it will try to move in the same direction to make room. ** This includes other PUSH objects. ** This ignores float levels. ** This movement is instant"
STOP	loaded	"STOP is a property that prevents most forms of movement from moving into the object." / "Some movement checks also override STOP to allow a movement, including EAT OPEN SHUT WEAK." / "FLOAT does not allow bypassing STOP."
OPEN	loaded	"If an OPEN object is on, or moved onto, a same-float SHUT object (or vice-versa), both are removed." / "The movement check applies to standard forms of movement, including FEAR AUTO CHILL FALL MOVE NUDGEDOWN PULL PUSH SHIFT YOU YOU2 3D." / "If the movement check succeeds in finding an "unlock", the normal obstruction of movement by STOP PUSH PULL does not apply. *** However, other obstructing objects may still prevent the movement, and this will also prevent the destruction from OPEN SHUT since no movement actually occurs." / "Destruction happens before the moving object actually moves onto the other object, therefore anything it HAS will spawn on the space the object was moving from." / "Only one SHUT object is destroyed per OPEN object (and vice versa), based on the first object in update order." / "If both the OPEN and SHUT objects are SAFE, the check fails. If only one is, the check succeeds and the appropriate object is destroyed."
SHUT	loaded	"If a SHUT object is on, or moved onto, a same-float OPEN object (or vice-versa), both are removed. As OPEN and SHUT are a pair, see OPEN for details."
PULL (loaded 2026-10-29, for Module 8)	loaded	"PULL is a Property that makes an object pullable by any moving object. PULL also makes the object "solid" for collision checks like STOP does." / "If something directly adjacent from a PULL object moves away from it, the PULL object will try to move in the same direction." / "If a PULL object is being PULLed by a PULL movement, it can move through solid objects (though will still PUSH things)." / "If LEVEL IS PULL, the overall level can be pulled at the border, rotating it internally but not visually." / "If the same PULL object is being PULLed in multiple ways in the same movement stage, the result is based on update order."
HOT	loaded	"HOT is a property that causes the object to destroy any same-float MELT objects it contacts." / "An object that is both HOT and MELT destroys itself."
MELT	loaded	"MELT is a property that causes the object to be destroyed if contacting any same-float object that is HOT." / "MELT obeys HAS and SAFE as expected."
SINK	loaded	"SINK is a property that causes an object to destroy all overlapping same-float objects along with itself when there is at least one overlapping object." / "A stack of two or more SINK objects will mutually SINK each other." / "SINKing order: Overlapping objects are destroyed (unless SAFE) in priority order, then the SINK object itself." / "SINK has no movement check, only an overlap check."
DEFEAT	loaded	"If a DEFEAT object intersects with or is a YOU (or YOU2 or 3D), the YOU object will be destroyed." / "If an object is both WIN and DEFEAT, then DEFEAT takes priority and the YOU object is destroyed." / "if a square contains both a WIN object and a separate DEFEAT object, then DEFEAT takes priority."
WIN	loaded	"WIN is a property that causes the level to be won if a same-float YOU YOU2 3D object overlaps the object." / "If an object is both WIN and YOU YOU2 3D, the level is won." / "WIN is checked very late in the process: any other removal of either object involved will occur first and prevent WIN from WINning."
WEAK (loaded 2026-10-29, for Module 9)	loaded	"WEAK is a property that makes an object be destroyed if it overlaps any same-float object or collides with any object." / "If a WEAK object overlaps any same-float object, it is destroyed. ** Multiple same-float WEAK objects overlapping each other are all destroyed. ** Destruction by WEAK happens after SINK BOOM, but before other overlap checks." / "If a WEAK object attempts to move into a solid object and fails (e.g. STOP PULL or blocked PUSH), regardless of float levels, it is destroyed." / "If an object attempts to move into a same-float WEAK solid object that is not PUSHable, the movement is not blocked."
FLOAT	loaded	"EAT and properties BONUS BOOM DEFEAT END HOLD HOT MELT OPEN SHUT SHIFT SINK TELE WEAK WIN require that the interacting objects are both FLOAT or both not FLOAT." / "FLOAT has no effect on collision-check properties such as STOP PUSH PULL SWAP, except OPEN SHUT." / "Whether an object is FLOATing or not updates once per turn, or at object creation (including transforms)."
Float levels	loaded	"It does not affect ON or collision checks from PULL PUSH STOP SWAP."
NOT	loaded	"When added after a verb it makes the corresponding rule not apply, overriding other instances of the rule it disables. ** ROCK IS NOT PUSH makes ROCK NOT PUSHable, even if ROCK IS PUSH exists elsewhere." / "ROCK IS NOT GRASS disables ROCK IS GRASS." / "X IS NOT X makes an object disappear, similarly to X IS EMPTY but with particles. ... As it negates X IS X, it enables other X IS Y rules, which can result in transformation in addition to the disappearance." / "NOT negates itself before negating anything else, so ROCK IS NOT NOT PUSH makes ROCK IS PUSH"
IS	loaded	"BABA IS NOT YOU prevents BABA from having the property YOU, overriding any BABA IS YOU rule." / "BABA IS BABA prevents BABA from transforming into any object, including those not in ALL. It does not affect transforming objects into BABA." / "BABA IS NOT KEKE prevents BABA from transforming into KEKE via a BABA IS KEKE rule." / "BABA IS NOT BABA causes BABA to vanish in a puff of logic." / "BABA IS KEKE AND ME turns all BABA into both KEKE and ME"
TEXT	loaded	"TEXT IS PUSH as a base rule." / "TEXT is not included in ALL, but is included in NOT ALL."
AND	loaded	"AND is an Operator that generally defines two or more rules at the same time; this is mechanically equivalent to each rule being defined individually" / table: "BABA AND KEKE IS PUSH AND STOP = BABA IS PUSH, BABA IS STOP, KEKE IS PUSH, KEKE IS STOP" / "Overlapping rules with AND in the overlapped part does not apply AND to the right/downward rule." / "If a rule is invalid due to circumstances, it does not prevent other chaining of AND rules."
Rule (requested as "Rules" and "Base_Rules", redirected)	loaded	"Rules read from left to right in a row, or from top to bottom in a column." / "The following rules are enabled by default, even though there isn't any text saying so. *TEXT IS PUSH *LEVEL IS STOP *CURSOR IS SELECT. These rules can still be detected by FEELING and MIMIC and negated by NOT and BROKEN. These rules are not listed in the pause menu." / "If more than one parsable object is stacked, the game will attempt to produce all possible rules." / "Rules parse when any parsable object changes position or is destroyed, or an object is transformed to text. Between parsings, active rules are simply stored."
YOU	loaded	"If a YOU object is on an object that is (or itself is) WIN at the end of the turn, the level will be won." / "Movement from YOU occurs before all other movement."
Noun (redirects to Category:Nouns)	loaded	"A noun can be used as a NOUN RULE PROPERTY statement e.g. BABA IS YOU to give it a property or as a NOUN IS NOUN statement eg. WALL IS WATER to turn an object into another object."
Advanced rulebook (requested as "Stacking" and "Duplicating")	loaded	"if you write A IS B and A IS C simultaneously in the same turn (or any similar construct like A IS B AND C), then you get both a B and a C for each A" / "Text can be stacked if TEXT IS NOT PUSH can be formed with another way to move text" / "While SINK will consume all objects simultaneously when it triggers, OPEN/SHUT being triggered as a reaction to movement will only consume one object."
"X IS X"	no standalone page found. Covered by the IS and NOT pages above.
Transformation, Transformations, Movement, Parsing, Nouns	do not exist (API: "The page you specified doesn't exist.")

6. GDC talk: "Reading the Rules of Baba Is You"

• URL: https://www.youtube.com/watch?v=Jf5O8S5GiOo
• Existence confirmed via YouTube oEmbed (https://www.youtube.com/oembed?url=...Jf5O8S5GiOo): "title":"Reading the Rules of Baba Is You","author_name":"GDC Festival of Gaming" (the GDC channel). WebFetch of the watch page also returned the title "Reading the Rules of Baba Is You."
• Speaker: WebSearch results (a Game Developer video post and gdconf.com news) describe it as Arvi Teikari's GDC 2020 Design-track talk about turning in-level objects into sentences the game logic can read, and about building with a non-programming tool plus Lua. The gdconf.com news page returned 404 when fetched directly, so the speaker attribution rests on search snippets and was not read on a page. The video itself was not watched, and no claim in this document relies on it.

---

Answers

a. Order of operations within a turn

Source: Order of Operations (wiki, §3). The sequence is as follows.

1. Movement (domovement()): YOU first, then MOVE/AUTO/CHILL, NUDGE*, FEAR, then SHIFT. Collision reactions are resolved on every movement step: OPEN/SHUT, WEAK/EAT, SWAP, PUSH/PULL, OPEN/SHUT and WEAK/EAT for pushed objects, passive SWAP, then STOP. Conditions are reparsed between movement stages.
2. Rule parsing.
3. Conversions: REVERT, X IS Y and WRITE ("REVERT takes priority ... X IS ALL takes the lowest priority").
4. Rule parsing.
5. Secondary movement (moveblock()): FOLLOW, BACK, TELE, SHIFT direction change. Then SELECT, then the 6-stack limit, then FALL.
6. Rule parsing.
7. Status block (statusblock()): direction properties, TURN, FLOAT. Then FALL again.
8. Rule parsing.
9. Level block (levelblock()).
10. Destruction and end-of-turn checks (block()): DONE, MORE, PLAY, HOLD, SINK, BOOM, WEAK, HOT/MELT, DEFEAT, OPEN/SHUT overlap, EAT, MAKE, HOLD, visuals, then BONUS, END, WIN, then out-of-bounds deletion, then CRASH. "Deletion occurs after each step that removes objects".
11. Rule parsing.

How many parses per turn? The page lists five "(rule parsing)" points, plus condition reparsing between movement stages. A full reparse only happens when text actually changed. The Rule page says: "Rules parse when any parsable object changes position or is destroyed, or an object is transformed to text. Between parsings, active rules are simply stored." The Game Developer interview agrees: "The game only updates the rules if it needs to." Course-safe wording: "the game reparses rules at up to five checkpoints per turn (whenever text has changed), including once right after movement and once right after conversion."

b. BABA IS YOU, BABA IS MELT, LAVA IS HOT: Baba steps onto lava while pushing MELT out of BABA IS MELT

Baba survives, provided no other active rule makes Baba MELT and the displaced MELT text does not complete another BABA ... MELT sentence.

The reasoning, step by step:

• HOT/MELT has no check during movement. Neither the HOT nor the MELT page is in "Checked on Collision", and the movement-check list contains only OPEN/SHUT, WEAK/EAT, SWAP, PUSH/PULL and STOP.
• HOT/MELT is resolved in block(), as an overlap check.
• Between movement and block(), the rules are reparsed: "(rule parsing)" right after domovement(), and again several more times.
• So when HOT/MELT runs, BABA IS MELT no longer exists. MELT is defined as "causes the object to be destroyed if contacting any same-float object that is HOT", which no longer applies to Baba.
• Also check FLOAT: Baba and lava must be on the same float level for HOT/MELT to apply at all.

Inference status: this follows directly from the documented order. The wiki gives no worked example of this exact scenario.

c. NOT and X IS X / X IS NOT X

• Rule cancellation. X IS NOT Y overrides X IS Y wherever it appears.
  • NOT page: "ROCK IS NOT PUSH makes ROCK NOT PUSHable, even if ROCK IS PUSH exists elsewhere" and "ROCK IS NOT GRASS disables ROCK IS GRASS."
  • IS page: "BABA IS NOT YOU ... overriding any BABA IS YOU rule."
  • Teikari: "if the rule "Baba Is Not You" exists, "Baba Is You" is marked as being not valid."
  • Double NOT cancels itself: "ROCK IS NOT NOT PUSH makes ROCK IS PUSH".
• X IS X blocks conversion out of X: "BABA IS BABA prevents BABA from transforming into any object... It does not affect transforming objects into BABA."
• X IS NOT X does not protect X:
  • It removes X: "makes an object disappear".
  • It negates X IS X: "As it negates X IS X, it enables other X IS Y rules, which can result in transformation in addition to the disappearance."
• X IS NOT Y blocks only the specific conversion X IS Y.
• When X IS NOT X removes X (reading, added 2026-10-29 for Module 9). No source read gives X IS NOT X its own place in the turn. The Order of Operations page lists "object transformations via IS" in the conversion step, and the NOT page ties the disappearance to the transformation it enables ("which can result in transformation in addition to the disappearance"). The course deletes X in its conversion step, with the conversions.

d. TEXT IS PUSH

• Yes, it is a built-in base rule. Rule page: "The following rules are enabled by default, even though there isn't any text saying so. TEXT IS PUSH, LEVEL IS STOP, CURSOR IS SELECT". The PUSH and TEXT pages say the same.
• Yes, it can be disabled. Rule page: base rules can be "negated by NOT and BROKEN". The Advanced rulebook relies on this: "Text can be stacked if TEXT IS NOT PUSH can be formed".
• Base rules "are not listed in the pause menu."
• Note: baba-is-auto instead hard-codes "all text is pushable without an explicit rule", so its behavior here is not authoritative.

e. Parsing

• Crossing sentences. Rules read "from left to right in a row, or from top to bottom in a column" (Rule page). "multiple rules are able to cross and overlap if the parsing rules allow for a valid statement" (Esolangs). So one IS can serve both a horizontal and a vertical sentence. baba-is-auto also parses "horizontal and vertical" rules.
• AND distributes over subjects and complements.
  • "BABA AND KEKE IS PUSH AND STOP" gives four rules (AND page), "mechanically equivalent to each rule being defined individually".
  • Mixed complements work: "BABA IS PUSH AND STOP AND KEKE" gives two properties and one conversion.
  • An invalid link does not break the chain.
  • Caveat: "Overlapping rules with AND in the overlapped part does not apply AND to the right/downward rule."
• Stacked text.
  • "If more than one parsable object is stacked, the game will attempt to produce all possible rules" (Rule page).
  • Teikari: "the stacking adds the need to go through all the possible permutations a rule could have".
  • A stacked noun in A IS B parses multiple times, which duplicates objects (Advanced rulebook).
  • Stacking text is hard by default, because TEXT IS PUSH is a base rule.

f. Push chains, STOP and OPEN/SHUT

• Push chain into STOP: nothing moves.

  • "If something tries to move into a PUSH object, it will try to move in the same direction to make room. This includes other PUSH objects" (PUSH page).
  • "If the object is unable to move, the actor will not perform its move" (Esolangs).
  • So if the front of the chain hits STOP, the whole chain and the YOU object stay put.

• OPEN/SHUT happens during movement, including for pushed objects.

  • The movement-check list includes "OPEN SHUT for pushed/pulled objects".
  • "If the movement check succeeds in finding an "unlock", the normal obstruction of movement by STOP PUSH PULL does not apply."
  • "Destruction happens before the moving object actually moves onto the other object".

• Example: Baba pushes an OPEN+PUSH key into a SHUT+STOP door.

  • Key and door are both removed during movement.
  • The key's push counts as unobstructed, so Baba's move succeeds and Baba moves one tile, onto the key's former tile. Baba does not reach the door's tile that turn. (This is an inference from the documented rules; the wiki does not spell out the pusher's final position.)
  • Anything the key HAS spawns on the key's former tile.
  • Only one SHUT is destroyed per OPEN in a movement check.
  • The interaction fails if the two are on different float levels, if both are SAFE, or if another obstructing object is on the door tile.
  • Reading, not stated (added 2026-10-29, Module 8). After an unlock, "the normal obstruction of movement by STOP PUSH PULL does not apply", yet "other obstructing objects may still prevent the movement". The OPEN page doesn't say whether a separate STOP (or PUSH) object on the door tile still obstructs. The course reads it as yes: only the unlocked partner stops obstructing, and any other STOP object blocks the move and cancels the destruction.

• The edge of the level (added 2026-10-29, for Module 8). No source read says in so many words that the edge blocks ordinary movement.

  • The Rule page lists LEVEL IS STOP among the base rules, and the PULL page says "If LEVEL IS PULL, the overall level can be pulled at the border". Together they suggest the border is where the LEVEL object's base STOP applies. This is an inference.
  • Esolangs says "If an object is to leave the bounds of the level, it is immediately destroyed", which concerns objects that do leave the bounds by other means.
  • baba-is-auto refuses a move off the map ("// Check boundary" in Game::CanMove), but it is not an authority.

• Several YOU objects in one move. No source read gives the order in which several YOU objects move, or what happens when one YOU object pushes another that is also PUSH.

g. FLOAT and hazards; what SINK destroys

• FLOAT gates hazards. HOT, MELT, SINK, DEFEAT, WIN, OPEN/SHUT, BOOM, WEAK, EAT and others "require that the interacting objects are both FLOAT or both not FLOAT" (FLOAT page).
• FLOAT does not gate collision. It does not affect STOP, PUSH, PULL or SWAP ("FLOAT does not allow bypassing STOP"). OPEN/SHUT is the exception.
• FLOAT status updates "once per turn, or at object creation". In the turn order, it updates in statusblock(), before block().
• SINK destroys "all overlapping same-float objects along with itself when there is at least one overlapping object."
  • This means any object, not just YOU: text and keys count too.
  • SAFE objects survive.
  • Two SINK objects destroy each other.
  • It is an overlap check only, with no movement check.

h. WIN

• The level is won when a same-float YOU/YOU2/3D overlaps a WIN object, checked "at the end of the turn" (YOU page) as the last step of block().
• An object that is both YOU and WIN wins: "If an object is both WIN and YOU YOU2 3D, the level is won."
• DEFEAT beats WIN. It applies whether DEFEAT is on the same object or on a separate object in the same square: "WIN is checked very late in the process: any other removal of either object involved will occur first and prevent WIN".
• Exceptions:
  • YOU AND DEFEAT AND WIN AND SAFE wins.
  • A HAS-respawned YOU can win in the same turn.
  • LEVEL IS WIN AND DEFEAT wins, because level rules are processed in rule order.

---

Draft claims that are WRONG or unverified

1. "Turn = Movement → Reparse → Conversion → Reparse → Hazard & Win." Directionally right but incomplete. Reword it.

   • The first four steps match the wiki.
   • Between the second reparse and hazards, there is a whole second movement phase (FOLLOW, BACK, TELE, SHIFT), then SELECT, FALL (twice), status updates (TURN, FLOAT, directions) and the level block, with up to three more reparses.
   • OPEN/SHUT, WEAK and EAT also fire during movement, not only in the hazard phase.
   • WIN is not a separate phase. It is the tail of the same block() pass, after SINK, BOOM, WEAK, HOT/MELT, DEFEAT, OPEN/SHUT, EAT and MAKE, and before out-of-bounds deletion.
   • There is one more reparse at the end.
   • It is acceptable as an explicitly labeled simplification for levels that use only basic words.

2. "Breaking BABA IS MELT during the move saves Baba standing on lava." Supported (true), with caveats.

   • HOT/MELT is an overlap check in block(), after the post-movement reparse.
   • Caveats: no other rule may make Baba MELT, the displaced text must not form a new MELT sentence, and HOT/MELT needs Baba and lava on the same float level.
   • This is inferred from the documented order. No source shows this exact scenario.

3. "X IS X or X IS NOT X locks X against conversion." Half wrong.

   • X IS X does block X from converting into anything (IS page).
   • X IS NOT X does the opposite. It deletes X ("makes an object disappear") and negates X IS X, so it "enables other X IS Y rules".
   • To block one specific conversion, use X IS NOT Y.

4. "Pushing an OPEN+PUSH key into a SHUT+STOP door destroys both and Baba steps onto the tile." First half true; second half wrong or misleading.

   • Both are destroyed during movement. The OPEN/SHUT movement check applies to pushed objects and overrides STOP/PUSH obstruction.
   • Baba moves one tile, into the key's former tile, not onto the door's tile. Destruction happens "before the moving object actually moves onto the other object".
   • The pusher's exact final position is inferred, not explicitly documented.
   • It also requires matching float levels, at most one of the pair being SAFE, and no other obstruction on the door tile.

5. "TEXT IS PUSH is an implicit engine rule." True.

   • It is listed as a base rule, "enabled by default, even though there isn't any text saying so", alongside LEVEL IS STOP and CURSOR IS SELECT.
   • It is a real rule, not hard-wired behavior: it can be negated with TEXT IS NOT PUSH (or BROKEN), detected by FEELING and MIMIC, and is hidden from the pause menu.
   • Do not cite baba-is-auto for this. It hard-codes text pushability.

Unverified / not sourced

• The GDC talk's speaker attribution (Teikari) comes only from search snippets. The gdconf.com page returned 404 and the video was not watched.
• The fandom wiki is community-written. Its Order of Operations page is detailed and cites internal function names, but it is not an official Hempuli document.
• Game Developer quotes are excerpts returned by a summarizing fetch tool. Check them against the page before publishing.