Known gaps

Griff is young. Known gaps:

Griff is pre-alpha, and its installer (and the editor it installs) isn’t code-signed, so Windows SmartScreen warns about an unknown publisher the first time it runs (“More info”, then “Run anyway”). Installers and updates are for Windows only.
CI runs on Windows only, and Griff.Platform.Windows has no tests of its own: the player smoke test covers it end to end. The OpenGL renderer’s tests draw off the screen (with Mesa’s software OpenGL in CI), and whether the browser draws the same pixels, plays sound and keeps saves is checked by tools\web.ps1 -Compare and -Check, which CI doesn’t run (they need Chrome or Edge and publish the web player).
Modules are found only among Griff’s own module assemblies (those beside the editor, and those an export carries): a project can’t bring one of its own. Templates several modules share pictures from (the crate, the crypt’s hero and walls) keep those in Griff.Editing’s TemplateArt.
Network play isn’t available in a browser: a game built for the web says so (at export, and in the game when a scene set up for it starts or someone hosts or joins) and plays alone. Browsers have no UDP; it would need WebSockets or WebRTC and a relay server (a transport of its own, one more INetTransport the web player hands its games). Film grain is noise from each GPU’s sine, so it isn’t the same grains in a browser as on the desktop. A web build is about 30 MB before the host compresses it (about 10 MB as most send it, and GitHub Pages sends it that way, gzipped: it does not use Brotli files): .NET for WebAssembly isn’t trimmed, since scenes load by reflection and scripts are compiled against all of it. It runs Griff in an interpreter, so a step costs a few times what it does on the desktop (the Physics template’s biggest collapse 3 to 5 ms a step against about 1 ms); a warm-up before the game starts keeps the interpreter’s own work out of the game’s frames, at 0.3 to 0.5 s more loading (1 to 1.5 s in a game with bodies that turn). Compiling it ahead of time (AOT) would make steps as quick as the desktop’s but more than double the download and take minutes to publish (see the exporting guide).
Templates are found only in Griff itself: a project can’t add one of its own to New Project. A component saved by a newer version of it keeps the values it doesn’t know, but is written back at this version.
A saved game keeps scripts’ fields and the objects they hold, but not a coroutine under way, which a rewind keeps: a script starts its work again in OnLoaded, from its fields. A scene remembered as it was left (and so one a saved game remembers) keeps its components’ properties only: a script’s private fields there start as the script makes them as the player comes back. A saved game keeps its scene as it was, so an update that moves things in a scene doesn’t reach a game saved in it unless an ISaveUpgrader changes it. An Autosave saves in one slot (it doesn’t take turns between several), and its minutes start again in each scene.
Big scenes: an exported game holds about 128,000 BunnyMark bunnies at 60 fps (127,932 to 144,686 over 3 runs on a mid-range desktop PC, October 2026, each held with a 1% low of 60 fps; 76,283 to 78,666 on the same PC before the frame was built and the bunnies’ scripts run across the cores, about 69,000 with a frame built in two passes over the entities, 28,200 before that), and 100,000 at 60 fps with 1% lows at 60 fps and no garbage collections in ten seconds, the aim set for it, in 3 runs out of 3 (before: 30 fps, a 1% low of 30, in 3 out of 3). A frame of 100,000 takes 7.4 ms of the CPU (tools/bunnybench.cs): 1.6 ms of steps, 2.9 to build and 2.8 to draw with OpenGL, which is done on the game’s thread, as are what a frame’s chunks leave it (scripts’ drawables, what’s inside other entities) and copying every draw to its place once (about 0.6 ms at 100,000). On a computer with fewer cores the count is lower: with everything on one thread (--workers 1), 100,000 take 15 ms (4.6 ms of steps, 7.5 to build, 2.7 to draw; 18 ms before). Text whose words change (a score, the frame rate) makes no garbage: it’s laid out from glyphs already on an atlas page (before, it was drawn again with WPF, which made the odd collection in a long run). Playing in the editor keeps up with them now (see Rewind in big scenes): a Debug editor holds 5,000 bunnies at 60 fps with a 1% low of 60 and 1 garbage collection in ten seconds (before: 39 to 45 fps, a 1% low of 7, 69 to 81 collections), and 20,000 at 60 fps with a 1% low of 60 (before: 59 fps, a 1% low of 30), snapshotting them ten times a second (before, every two seconds), and with the frame built and the bunnies’ scripts run across the cores, 50,000 at 55 fps with a 1% low of 30 (before: 19.6 fps and a 1% low of 12; a rewind snapshot of 50,000, copied out on the game’s thread, still takes 6.6 ms there); a Release editor holds 20,000 at 60 fps with a 1% low of 60, and 50,000 at 59 fps with a 1% low of 60 (before: 58 fps, a 1% low of 30). Copying a snapshot out still happens on one step (it has to, to be one moment), so the biggest scenes are snapshotted less often to keep their frames on time: 50,000 bunnies about seven times a second in a Release editor and four in a Debug one, and just after rewinding a big scene, whose entities are all fresh, a little less often for a while.
Mouse look turns once a step, and the screen shows the game up to a step behind, so it trails the mouse by a step or two; so does what follows the mouse (a strategy game’s or Selection Controls’ drag box and a placing ghost, the contraptions tools’ line, something being dragged), which is drawn where the mouse was at the last step. A drop of rain wrapping round the view is drawn where it lands a step early (out of view).
Boxes and polygons stay upright unless their body Rotates. A polygon has at most 64 points, and one that a body moved the old way (one that doesn’t rotate) carries meets a hex map’s walls, as a turned box does, as the box round it. Slope tiles are 45 degrees only (a static polygon makes a slope at any angle), and circle bodies that don’t rotate slide rather than roll (tick Rotates and they do). A crate resting on another sinks into it by about a five-hundredth of a unit (overlaps are eased apart, not kicked), and a sleeping one still costs about two microseconds a step, checking it still has something under it.
A Chart spreads its X Labels evenly and lays its legend out in equal parts of its width, rather than measuring the words, so a long series name can run into the next; it says nothing about the point under the mouse, and its points are evenly spaced (a point a sample, not placed by a time of its own).
A tooltip shows for the mouse only (not for a button picked with the keyboard or a controller), and its box is as wide as its longest line would be in letters of an average width, so a narrow or wide font leaves it a little roomy or tight.
An Edge Pointer points across the main camera’s view only (not a viewport’s, so not one player’s half of a split screen), goes by its target’s position (not its sprite’s edge), and keeps to its Margin rather than moving clear of the HUD pinned along the edge.
Display settings: fullscreen is borderless at the screen’s own resolution (there’s no exclusive fullscreen, and the display’s mode is never changed), Window Size offers 16:9 sizes only, and the editor’s Game tab and a browser keep frames in step with the screen whatever VSync says.
Shadows are hard-edged, and come from colliders and tiles rather than sprites’ shapes.
A tilemap’s extra tilesets are numbered by their place in More Tilesets: taking one out, or putting one before another, renumbers the ones after it, and cells painted from them change tile. The Sprite Painter’s Paint button on a tilemap paints its first tileset (open the others from the Assets panel).
A tile drawn at a size its pixels don’t divide evenly can pick up a column of the pixels beside it in the tileset along an edge nothing covers (an isometric tile’s left and right corners): leave a tile’s outermost columns clear, as the Isometric template’s tileset does.
A tilemap’s layers are switched and added under the palette, but put in order, hidden and removed in the Hierarchy, and every layer of a map shares its tilesets and tile settings (an isometric map’s shape and Tile Height too, so a tileset’s tiles are all one height).
A Wall Rooms sees walls at cells’ middles: a wall collider thinner than a cell that misses every middle doesn’t split a room, and a room is joined only through cells’ sides (never diagonally). An entity is in the room its position’s cell is in, so something standing on a wall, or bigger than a cell, counts in one room at most. A polygon collider whose points change without moving its bounds isn’t seen until something else changes.
A turned or flipped one-way tile stays open from below (one-way tiles only ever face up), a quarter turn on an isometric or hex map turns the picture within its box (not the diamond or hexagon), and the Rectangle and Fill tools paint every cell turned the same way (the Line tool turns each cell to follow its line).
Isometric maps don’t cast shadows yet. On hex maps, dungeons are generated on square maps only, autotiles join on a square’s four sides (not a hexagon’s six), and hexagons only point up and down (no flat-topped hexagons in columns). On an isometric map, bodies meet other colliders as boxes (only the walls are diamonds), and a sword or other close-up attack swings to the side of the screen a grid mover faces (not along the diagonal; on a hex map, up or down for the four slanted ways). A row of standing tiles sorts among the sprites by its middle, so something wider than a cell (a two-cell sofa, a big monster) can be drawn wrongly against the tiles beside it.
A clip’s frames are one run of the sprite sheet in order (no skipping or repeating frames; a range written high to low, 3-0, plays backward), and a clip given its own speed or looping in the Clip Editor can only go back to the animation’s by editing Clips. Renaming a clip in the Clip Editor doesn’t rename it in scripts that play it by name (Play("Run")) or in the clip names movement components look for (Idle, Run, Jump…).
A Layout slides its children to new places only with Slide ticked (or a Reorderable one’s while a row is moved), easing each straight there (no stagger or overshoot), lines a list’s children up on its left (a row’s along its top), and measures a child by its own Button, Sprite, Layout or text only (not by its children’s, and text by a guess at its letters: set Cell Size for exact room). Its Clip cuts to an upright rectangle (the box round a turned layout), and only the mouse wheel scrolls it (and a row dragged near its end): no scroll bar, dragging the list itself or keys. A reorderable one’s rows move one at a time (no picking several), and keep their order in the save data only by their names.
Built-in juice changes only how things are drawn: a TweenPlayer’s scale, move, turn and fade and a Button’s pop leave the transform, collider and clickable area as they are, and don’t fade or move lights. A tween player plays one tween (several on an entity play together, not one after another). A Text counts only the numbers of an Output it shows (not a Counter’s own count, nor a number a script writes), and a camera kick is one push at a time (a new one replaces it).
A floating window holds panels tabbed together, not side by side, and the document tabs (Scene, Game, prefabs, scripts, the asset editors, the panels put among them) stay in the main window: a document can’t float, or sit beside another (one shows at a time). Panels are reordered within their own group, not among the documents.
The Scene view’s handles resize sprites, box and circle colliders, distances (light radii, ranges, sight), paths and polygons’ points only on the entity picked last (and only its first polygon collider’s points), even with several selected, and distances of 0 have no handle until they’re set in the Inspector. A mover’s start is where it’s placed (move the entity), and a patrol’s route is level, left and right.
The Profiler splits the game’s steps by script, step and system, and building the picture by what’s drawn, but drawing it only as a whole; an entity’s upkeep counts with the kind of thing it draws first (a sprite with text under its sprite); script code run from timers, coroutines, tweens and messages counts in the step that ran it. Garbage is counted on the game’s thread only (not the rewind snapshots settled in the background). It profiles the Game tab’s game only (not the other players’ windows of Play with Players, or an exported game), and drawing is timed as the CPU hands it to the graphics card, not the GPU’s own part.
Dragging rows in the Hierarchy moves one at a time, even with several selected.
A breakpoint, and a step, stops at the first statement on its line, once each time the code gets there (not again for a second statement on the same line, so Step Out lands on the line after the call rather than the rest of the calling line), and only in a game’s own frame: not in code the editor runs itself (the Inspector reading a property, a rewind snapshot), or a field’s starting value. Values can be looked at but not changed while the game stands there, and a property worked out in code (rather than stored) isn’t shown for a script’s own object, since showing it would run the game’s code.
Stopped where a script threw, the values in scope aren’t known for a line of an iterator’s that something other than a coroutine runs (a foreach over it) and no guard can stand around (a loop holding a yield return, say); a coroutine’s show its variables as they were.
The Inspector’s and Hierarchy’s filters match names only: not a field’s value, or the components an entity has. The color picker has no eyedropper for picking a color off the screen.
A table is renamed by renaming its file outside Griff (the Assets panel renames only prefabs): what names it by its old name (a Table Values component, another table’s formula) is then flagged in the Inspector or the Tables panel and said in Output as the game starts, not renamed. A row or column renamed in the Tables panel keeps answering to its old name instead.
Copied component values stay inside the editor until it closes (not on the system clipboard), and paste only onto the same kind of component. Components aren’t dragged to reorder them; use Move Up and Move Down.
Fields that name entities hold their names (a name several entities answer to, where a field needs one, is flagged): renaming an entity updates them in the open scene, but not in other scenes, prefabs or scripts. Fields naming prefabs, scenes, layers and messages aren’t renamed with them either (they’re flagged instead). Messages and layers in scripts are only found where they’re written out (Game.Send("Score"), On("Score", ...), Layer = "Bullet"), not built up in code, and a script listening by a name it builds can leave its message flagged. Items, flags and names in the save data in scripts are found the same way, where they’re written out (inventory.Add("Key"), Game.SetFlag("MetKing"), SaveData.Set("best", ...)), and a name a component builds from its own (a rhythm game’s best score for each song and difficulty) isn’t listed among the names in the save data. In a prefab’s tab, only fields naming something inside their own entity (an attack’s Hitbox) are flagged; the rest name things in whatever scene it’s placed in.
A copy placed inside another copy in a scene follows its own prefab (what the outer copy changes on it isn’t kept). Renaming or moving a prefab outside Griff (in Explorer) unlinks its copies, renaming one doesn’t rename it where it’s spawned by name (a Spawner’s Prefab, Game.Spawn), and only prefabs can be renamed or moved in Assets (not other files or folders). Children of a copy are matched to the prefab’s by name, so renaming one counts as taking it away and adding another (and renaming one in the prefab’s tab loses what copies changed on it). A prefab’s tab keeps no crash-recovery copy, as scenes do.
Grid crates are pushed, never pulled, and stop after one cell (no ice to slide across). Undo puts back only grid movers (not what was collected or destroyed, counters, switches or turns), levels are built from entities on a tilemap (there’s no reading Sokoban text levels in, and the Puzzle template’s menu remembers which levels are solved, not the fewest moves), and a network game has no undo. In a network game a player’s push moves the crate once the host hears of it, so their character steps into the crate’s cell a moment before the crate moves off. Grid enemies chase and patrol but don’t flee or wander at random, and grids are square, isometric or hex.
Fast-forward (a Game Speed’s Exact, Time.FastForward) does nothing in a network game. Sped up with longer steps instead (Time.Scale), grid movers take every cell a step covers, but a Spawner still spawns and a Shooter still fires at most once a step, so ones quicker than a step fall behind.
A scene simulation plays one scene: changing to another (a Game Over scene, or the next level) ends its run, so it starts from the gameplay scene rather than a title menu, and a strategy acts on game time (every Act Every seconds, or while a panel pauses the game), not on messages the game sends. Its steps cost what the game’s own do, with nothing drawn: a busy template scene plays 45,000 to 55,000 steps a second on each core, so sixty game days of one (864,000 steps at 60 a second) take a quarter of a minute a run, unless a coarser Step Rate stands in.
A grid mover walking somewhere waits for one standing still in its way (it doesn’t ask it to move over), and only two walkers waiting face to face give way to each other (not three in a ring); it plans round every other mover where it stands now, not where it’s going.
Conveyors lie on square (or isometric) cells, not a hex map’s, (no lanes on either side of a belt). Under cells and full loops that keep moving need a Spacing: with one item a cell, an under cell is a crossing and a closed loop with every cell full doesn’t move. A loop that has splitters in it counts all its cells as room when it decides whether a belt merging in may add an item. Solid belts stop grid movers, not bodies that move freely (a top-down player walks over them). In the Scene view a Conveyor’s belts are typed as rows (the Line tool paints tiles, not belts); in the game a Line Tool lays them by dragging. In a network game the host moves the items and the players’ machines see each one arrive in its cell, without the glide between.
A line dragged with the Line tool or a Line Tool turns at most one corner (drag again from its end for a second), runs along the grid’s rows and columns (made for square maps: on an isometric or hex map it follows them too, but its ghost is drawn as squares, not diamonds or hexagons). Lines join what’s already there only with Joins ticked (a Line Tool’s, or the Line Tiles’ for the Scene view), and only at their two ends: a line crossing another is laid over it, and a merge into a corner or an end keeps that cell’s piece (the Join Tile is for straight pieces). The drag is the player’s own machine’s, so in a network game a client’s script sends the host what Placed gives.
Match-3 gems are plain kinds: there are no special gems (stripes, bombs) or obstacles over the gems (ice, chains), every cell of the board’s rectangle is in play (blocks stand in for holes), gems only fall straight down (never sliding past a block’s corner), and swaps wait until the board is still. A won level doesn’t turn the moves left into points, and goals are a score and gems of a kind (not blocks to break or things to bring down). A rewind’s refills come from the board’s Seed afresh, so they can differ from the first time round. In a network game everyone shares one board. The Match-3 template’s menu remembers which levels are won, not their best scores.
A falling-block board has no holding a piece back for later, no T-spins or combo and back-to-back bonuses, no points for dropping a piece, and its turns step aside a cell or two rather than following any one game’s rules. Rows only clear when full (no garbage rows rising from below, no gravity pulling loose blocks down after a clear), and a game is one board: there’s no two-player versus. In a network game everyone moves the same piece.
Dungeons are rectangular rooms joined by straight corridors that turn once: no caves, doors, secret rooms or rooms of a theme (a treasury, a boss’s lair). Spawns come in the same numbers on every floor (the Roguelike template’s floors don’t get harder), monsters stand still until they notice the player (no wandering), and nothing remembers which cells the player has seen (no fog over the unexplored, or minimap).
Items with Item Uses are used by number key or script, not picked from a menu (an adventure’s Inventory Bar picks items to use on hotspots and each other, not to drink or throw, and there’s no using one with a gamepad outside an adventure), and they only heal, spawn a prefab or send a message: there’s no throwing, aiming or equipping. A bump attack always hits for its Damage (no misses, armor or critical hits).
Turns go team by team, not unit by unit: there’s no initiative order, and everyone on a team acts at once during its turn (on a grid, all its monsters step together). Only a Grid Chase or Grid Patrol passes by itself when it has nothing to do; a turret or a scripted monster with actions holds its team’s turn until it uses them or Computer Turn Time runs out. A team wiped out is beaten (its Defeat Message) but the game doesn’t end by itself: a panel opening on the message stops it, and there’s no other way to win (holding a spot, surviving a number of rounds) without a script.
Tactics units block each other, friend or foe (no walking through your own team), every unit has one way of attacking (no weapons or spells to choose between, no counterattacks, no hit chances or terrain that slows or shelters), and ranges reach over walls. The computer plays each unit on its own, a go at a time: it doesn’t plan moves together (surrounding a foe, shielding a hurt unit), retreat to heal, or think ahead to what you’ll do next. The camera doesn’t follow the cursor, so a battle has to fit on screen.
Flags (dialogue’s, a trigger’s Set Flag, and those a switch, door, spawner, panel or Show When needs) are on or off: there are no counters or numbers to add to (a counter that reaches a value, or scripts, keep those), a Needs Flag names one flag, or “not” one, or several joined by “or” (no “and”), and dialogue’s conditions are all-of (no “or”). Flags are kept on each machine (in a network game, each player has their own). A speaker has one portrait in the box (expressions change a visual novel character on the stage, not the box’s portrait). A visual novel stage’s characters stand, fade, slide and walk between positions, but don’t turn, scale, shake or jump on their own, and backgrounds change by cutting, fading or sliding (no wipes or iris); a dialogue box wraps lines by an average letter’s width, so a much narrower or wider font wraps early or runs over. The Dialogue Editor’s preview reads the lines top to bottom, whichever way the choices go and whatever the flags say. Choices are rows of the box’s text rather than buttons, and only the first nine have number keys.
A Grabber picks things up by their middle and carries them there, so a big thing held by a small cursor covers it. Several things on one drop target stack in its middle (a card game’s Hand and Play Zone lay their cards out instead), and a target that moves leaves what’s on it behind. In a network game a player’s drag goes through the host, so it trails their mouse by their connection, and only the host draws a held thing over everything.
Fighting games: a turned entity’s boxes are the upright box round them (as colliders are), and a hit is judged where the host sees things, without rewinding for lag. A fighter’s moves are pressed one button at a time (no two buttons together, as for a throw or a super, and nothing comes out on letting a button go), a move’s push comes once as it starts to hit, and a move doesn’t make anything of its own (a fireball flying off is a Spawner or a script its message starts). Fighters keep apart by their bodies bumping (there are no pushboxes), and there are no throws, counter-hits or juggle limits. The computer fighter plays by a few rules (closing in, attacking in range, guarding as an attack starts, jumping in, following a hit with a special) rather than reading frame data to punish what it blocks. Players at one computer have the left and right sides’ keys as they are (a player’s rebinding changes the whole keyboard’s).
Physics games: a Breakable with a polygon collider breaks into box-shaped pieces cut from the box round it (a round one into round pieces), and a hit’s strength is head-on (how fast the two came together, not how fast one was spinning). A slingshot’s dotted line doesn’t stop at what’s in its way, and in a network game the shot in the pouch on a player’s screen trails their pull by their connection (the bands and the line follow it at once). In a network game a player’s flips reach the table through the host, so they’re late by their connection.
Mixing genres: Focus hands over the input of everything that has a Controllable, but other keys keep working where they are (a panel’s Open On key, End Turn; Interact works a door, switch or dialogue only for what has the input, and behind a minigame no panel or button does). Something covered by two turn orders’ Within takes turns in the first. A strategy Commander’s camera is each machine’s own, so in a network game Focus on it works on the host’s screen only. Where every camera has a viewport, the first also fills the screen under the views. A viewport’s camera looking through someone’s eyes doesn’t hold the mouse. A paused group’s counters don’t count messages, its typewriters hold, and damage done to it while paused kills only once it goes on. Match-3 and falling-blocks boards draw square cells, so a board lined up with an isometric or hex map (its Lines Up With) takes that map’s shape but isn’t drawn on its cells; the boards made from the Entity menu line up only with square maps.
Card games: a card is played from a hand onto a play zone (or dropped on a discard pile); once played it stays there until the zone’s Discard, or its Discard After for a card that isn’t a creature (moving it on to another zone takes a script). A card’s buff lasts for good (there’s no buff for a turn only), and the computer weighs only what a card does as it’s played (not what a creature will do on later turns, nor what the player might do next). In a network game, whose hand is whose comes from the Multiplayer’s Teams (without them a hidden hand is hidden from everyone), and a card another player drags isn’t seen moving: it shows where it was dropped once the host has played it. A card’s text is wrapped by an average letter’s width, so a much narrower or wider font wraps early or runs over. A rewind brings back every card where it was, but shuffles after it come from the game’s random numbers afresh, so they can differ from the first time round.
Strategy games’ units only walk (no flying or water), and the fog of war is drawn in squares.
Selection Controls select with the mouse only (no gamepad cursor), only raise a right-click’s command for the game to carry out (no orders of their own, and nothing sent over the network), and a control group pressed twice moves the camera straight there rather than gliding.
An adventure’s walker walks on its feet, a point: draw the walk area where its feet can go (a little in from the walls). Its way is worked out when it sets off, round the holes where they are then, so a character who walks into its way afterwards is walked through; walkers don’t step round each other, and nothing but walk areas (not colliders or tiles) is in their way. Depth makes them smaller evenly from the bottom of a walk area to its top. What the walker says is drawn over its head in the built-in font; for portraits and a box, use a dialogue. Its items are used on a hotspot or put together two at a time (one of each, never three, and an item is never used on a character walking about without a hotspot), the inventory bar is a row (no window of pages), and item icons are drawn square unless they come from a hotspot’s sprite. The keys and a controller go from hotspot to hotspot in view in order left to right, not by pointing a cursor, and don’t walk the walker except to a hotspot. Rooms are scenes loaded afresh each time they’re entered: only what flags and saved inventories keep carries over between them (a hotspot’s Times Used counts from 0 again, and something a script moved is back where the scene has it).
The beat clock allows for the sound card’s own delay, worked out from its buffers, and for each player’s audio offset (speakers that add their own, measured by tapping along). It counts at one tempo the whole way through (no tempo changes within a piece), needs music playing to count, takes each loop of the music to be a whole number of beats. Spawners, shooters, movers and switches step to it, but other things that count seconds (timers, animations, particles, patrols) don’t yet.
Rhythm notes are taps and holds (no slides, flicks or rolls), drawn as plain bars in their lane’s color, and a song plays at its clock’s one tempo. In a network game each machine shows its own player’s lanes: the others’ are seen only as their scores.
Multiplayer connects directly: to play over the internet, the host forwards their port (7777 by default) on their router; there’s no matchmaking, relay or lobby server yet. Players’ own machines move their own characters, which suits friends better than strangers (pick Host movement where cheating matters), and shots are judged where the host sees things, without rewinding for lag. Rewinding in the editor works with one player, and a network game can’t hit-stop or slow down (it’s everyone’s).
Block worlds are side-on (Terraria style); in first person, digging works on the flat map’s walls. Water and lava don’t flow, and light from glowing blocks casts no shadows.
Outputs are read, not written: a wire drives a component’s actions, Power and Show, and the wiring parts’ own inputs (a lamp’s On, a display’s Value, a gate’s A and B, a light’s Brightness), but not any property of any component. An output read by a name (Amount:Gold) is listed in the Inspector with one example name, not every name it has.
A hinge’s limits go at most half a turn either way. A body inside another that turns (a child entity with a body of its own) goes its own way in the world rather than being carried along by it.
First-person games are drawn the classic way, from a flat map: walls are all one height, floors and ceilings are flat colors (no textures, stairs or rooms above rooms), and there’s no aiming up or down at things.