---
id: magic-circle-programming-languages/02-every-existing-system-solves-one-half-of
title: 'Magic circle programming languages: 2. Every existing system solves one half
  of the problem'
report: https://ai.hiina.space/reports/magic-circle-programming-languages.md
section: 2
version: 1
updated: '2026-10-27'
author: Hiina
---

Index of everything on this site: https://ai.hiina.space/index.md

# Magic circle programming languages: 2. Every existing system solves one half of the problem

- Section 2 of 13 of the report "Magic circle programming languages" by Hiina (v1, updated 2026-10-27)
- Report overview and contents: https://ai.hiina.space/reports/magic-circle-programming-languages.md
- Previous: https://ai.hiina.space/reports/magic-circle-programming-languages/01-summary.md
- Next: https://ai.hiina.space/reports/magic-circle-programming-languages/03-recognition-in-2026-geometry-is-cheap-topology.md

## 2. Every existing system solves one half of the problem

The prior art falls into families that each own a piece of the idea: notation without recognition, recognition without composition, diegetic programming without freehand input, and fiction with grammar but no machine. The table summarises the systems that matter most, sorted by how visual structure carries meaning.

| System | Input | What the visual structure means | Role of drawing quality | Source quality |
|---|---|---|---|---|
| Mystical (2025) | Generated from PostScript text | Rings = executable/data arrays, read CCW from 3:00; sigils = operators | None; output only | Primary README |
| wha-spell-simulator and kin (2026) | Freehand strokes on a canvas | One ring (open = prepared, closed = active), one element sigil, modifier signs by angle | Neatness sets duration (0.65 to 8.5 s); sigil size sets scale | Primary repo docs |
| VIPR (1990s) | Structured editor | Nested rings = sequence; sibling rings = alternatives; arrows = substitution | None | Secondary only |
| Rotary (2014) | ASCII text | Each closed ring of characters is a unit of control | None | Esolang wiki (secondary) |
| Piet (2001) | Bitmap | Hue/lightness change between colour blocks = opcode; block area = number | None; discrete cells | Esolang wiki (secondary) |
| Wierd (1997) | Text grid | Turn angle of a line = opcode | None | Esolang wiki (secondary) |
| Hex Casting (Minecraft) | Mouse snapped to hex lattice | Exact turn sequence = opcode key; slate track in spell circles = control flow | None; input is discretised | Primary source code |
| Psi (Minecraft) | 9x9 grid editor | Adjacency on parameter sides = data binding (dataflow DAG) | None | Primary source code |
| Noita wands | Slot list | Spell order = instruction stream with draw/call semantics | None | Fan wiki (secondary) |
| Magicka | Key presses | Element multiset with precedence and cancellation; Magicks are ordered sequences | None | Wikipedia, fan wiki (secondary) |
| SF6 motion inputs | Stick | Direction sequence within frame windows, with priority rules | Leniency windows | News report of community testing (secondary) |
| Arx Fatalis | Mouse gestures | Runes as morphemes (create/negate, improve/reduce) | Pass/fail | Wikipedia, retrospective (secondary) |
| War of Wizards (VR) | Controller drawing | Shape selects spell | Larger and more accurate = stronger | Store page (secondary) |
| Rithmatics (fiction) | Chalk | Line type = role; bindpoints = attachment geometry | Evenness, curvature, straightness = strength | Fan wiki (secondary) |
| Llull's Fourth Figure | Rotating paper discs | Disc rotation = letter combination | None | Stanford Encyclopedia |

### Mystical, VIPR and the ring notations

Mystical is the most direct ancestor. Its main ring "starts at the rightmost (3:00) point and flow continues widdershins", rings are read from the outside in, executable arrays `{}` are circles with a star and the alchemical "work complete" marker, non-executable arrays `[]` drop the star and use a triangle marker, dictionaries are double-bordered polygons, `/name` is drawn in a triangle, and most of the author's examples build variable sigils by "letter collision" after Spare's chaos magick ([Mystical README](https://suberic.net/~dmm/projects/mystical/README.html)). It is a pretty-printer: a human transcribes the drawing back to PostScript, and the author questions whether a ring per brace scales past operator-heavy languages like Forth. One fork, `cogerk/mystical_ps`, describes itself as "a python interpreter for mystical", but its README still carries the "no interpreter" line and what it interprets is unverified ([cogerk fork](https://github.com/cogerk/mystical_ps)). When Mystical circulated, MetaFilter commenters independently asked for exactly the two missing pieces, a ring-based input method and image recognition back to code ([MetaFilter](https://www.metafilter.com/208819/Mystical) (secondary)).

**VIPR** (Citrin, Doherty and Zorn) is the one academically published language built on nested rings. The accessible descriptions agree that programs are "nested series of concentric rings", that "each step in a computation involves merging two rings in the presence of a state object", that an arrow means substitution (when execution reaches a ring with an outgoing arrow, that ring is replaced by the arrow's target, which gives loops, calls and returns from one mechanism), and that every function has a mandatory continuation parameter drawn as a small tangent circle ([Berkeley survey CSD-04-1368](https://www2.eecs.berkeley.edu/Pubs/TechRpts/2004/Archive/CSD-04-1368.pdf) (secondary); [Bremen lecture slides](https://www.informatik.uni-bremen.de/agbkb/lehre/ss04/VS/Material/vipr.sxi.pdf) (secondary); [Berger thesis](https://www.en.pms.ifi.lmu.de/publications/diplomarbeiten/Sacha.Berger/THESIS/HTML-view/part2.html) (secondary)). Sibling rings at one level are alternatives with no order among them. None of the original papers (VL'94, JVLC 1997 and 1998) could be retrieved, so the guard notation and data representation are unknown. **VIPR is the only rewriting-based ring language found, and Covenant below borrows its spirit.**

Other ring notations are thinner. Rotary arranges Brainfuck-like characters in closed ASCII rings, the instruction pointer runs clockwise from an `x`, and ring-pointer instructions choose which ring runs next ([Esolangs: Rotary](https://esolangs.org/wiki/Rotary) (secondary)). Circular Gallifreyan (Loren Sherman, 2011) writes English transliteration as word circles read counter-clockwise from the bottom, with sentences as enclosing circles and numbers as concentric rings where each line adds 1 and each circle adds 5 ([Sherman's guide](https://shermansplanet.com/gallifreyan/guide.pdf)); dozens of text-to-image generators exist but no image-to-text recogniser was found, probably because the same word can be legally drawn many ways. The Japanese Magical Circle Engine is a text language that emits circle drawings, not a recogniser ([Scrapbox villagepump](https://scrapbox.io/villagepump/%E9%AD%94%E6%B3%95%E9%99%A3%E8%A8%80%E8%AA%9E) (secondary)). Procedural magic-circle generators on GitHub (danielstern/MagicCircles, areinhold17/MagicCirclePreview) are decorative and do not encode data ([MagicCircles](https://github.com/danielstern/MagicCircles)). Circular machine-readable codes show the encoding side is solved for short keys: ShotCode reads bits by angle and distance from a bullseye and stores a 40-bit lookup number ([Wikipedia: ShotCode](https://en.wikipedia.org/wiki/ShotCode) (secondary)), and a third-party reverse-engineering of Spotify Codes reports 23 bars at 3 bits per data bar decoding to 45 bits (37 for a media key, 8 checksum), while noting only that a *patent* suggests a convolutional code and that it cannot explain the 60-to-45-bit step ([levelup blog](https://levelup.gitconnected.com/spotify-codes-and-how-they-work-664f4e4b8489) (secondary)).

### Graphical esolangs encode meaning in discrete geometry

The 2D esolangs supply design axes rather than a template, and all of them read exact cells, not noisy drawings. **Piet** keys its 17 commands on the *change* in hue and lightness between colour blocks, so a global colour shift preserves meaning, and pushes numbers as the codel count of the previous block, so size is a number ([Esolangs: Piet](https://esolangs.org/wiki/Piet) (secondary; the 2001 date is a wiki category tag)). **Wierd** (Pressey, Olmstead and Colagioia, 1997) is the closest in spirit to a drawn sigil: lines of non-whitespace where the turn angle selects the instruction ([Esolangs: Wierd](https://esolangs.org/wiki/Wierd) (secondary)). **Hexagony** (Martin Ender, 2015 per wiki tag) uses a hexagonal source with instruction pointers at the corners and corner exits that branch on the sign of memory ([Esolangs: Hexagony](https://esolangs.org/wiki/Hexagony) (secondary)). **Aheui** packs opcode, direction and operand into the three slots of a Hangul syllable, a working model of a composite rune ([Esolangs: Aheui](https://esolangs.org/wiki/Aheui) (secondary)). Funge-98's default of reflecting the instruction pointer on an unknown instruction is an elegant fail-safe for a misdrawn glyph ([Funge-98 spec](https://github.com/catseye/Funge-98/blob/master/doc/funge98.markdown)). Beyond esolangs, Bret Victor's Alligator Eggs shows a rewrite calculus played as a game with colour as binding ([Alligator Eggs](https://worrydream.com/AlligatorEggs)), and Tromp's lambda diagrams draw lambda terms as lines ([Tromp](https://tromp.github.io/cl/diagrams.html)).

### Hex Casting and Psi bracket diegetic programming

**Hex Casting** is a real stack machine dressed as magic, and its source code shows how little of its visual form carries meaning. A pattern is a start direction plus a list of relative turns on a hex lattice; the lookup key is the turn list alone, compared by exact hash, so rotation is free but stroke order and handedness are identity ([HexPattern.kt](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/api/casting/math/HexPattern.kt); [PatternRegistryManifest.java](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/common/casting/PatternRegistryManifest.java)). Drawn paths cannot reuse a lattice edge or backtrack. A deprecated (since 0.11.4) overload has a flag for checking alternate stroke orders that simply throws "NYI"; the live mechanism is the exact key plus per-world "Great Spells", whose accepted drawing is an Euler-path re-drawing scrambled from the world seed so the shape is public but the stroke order is secret ([ScrungledPatternsSave.java](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/server/ScrungledPatternsSave.java)). Length loosely tracks power: Greater Teleport is a 31-turn signature, Flay Mind 29, Ignite 8 ([HexActions.java](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/common/lib/hex/HexActions.java)). Only two families parse shape algorithmically: Numerical Reflection, a shift-and-add accumulator where forward adds 1, left adds 5, right adds 10, sharp left doubles and sharp right halves (the book admits "Irritatingly, there is no easy way to draw numbers"), and Bookkeeper's Gambit, where flat segments keep a stack item and dips drop it ([SpecialHandlerNumberLiteral.kt](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/common/casting/actions/math/SpecialHandlerNumberLiteral.kt)).

What Hex gets right is the theatre around execution. Mishaps are typed exceptions with colours and thematic penalties: Invalid Pattern is yellow and pushes Garbage, Not Enough Iotas pads with Garbage, Mathematical Error costs vigor, and the Garbage iota lets a broken spell limp on with poisoned data ([lang file](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/resources/assets/hexcasting/lang/en_us.flatten.json5)). Costs come out of amethyst "media", and you can overcast from your own health. In 0.11.x the source shows a default op budget of 100,000, a default spell-circle length of 1024, and a mishap when the stack is too large to serialise, all server-configurable ([HexConfig.java](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/api/mod/HexConfig.java); [CastingVM.kt](https://raw.githubusercontent.com/gamma-delta/HexMod/main/Common/src/main/java/at/petrak/hexcasting/api/casting/eval/vm/CastingVM.kt)); the often-quoted 1024-iota stack and 512 meta-eval limits come from a 2023 FAQ for 0.10.x ([forum FAQ](https://forum.petra-k.at/viewtopic.php?p=130) (secondary)). The current release is 0.11.4 for Minecraft 1.20.1, from late August 2026 ([CHANGELOG](https://raw.githubusercontent.com/gamma-delta/HexMod/main/CHANGELOG.md)). The community treats it as a language: a Conway's Game of Life spell circle that "uses no addon functionality", though its author recommends an addon or a permanently powered directrix to stop it freezing ([forum](https://forum.petra-k.at/viewtopic.php?p=401) (secondary)); a compiler *design* with closures, a Z combinator and call/cc via Iris' Gambit ([s5bug gist](https://gist.github.com/s5bug/5f453c9c159fb77bad9dff1a8954fb3b) (secondary)); HexParse, which compiles text to pattern iotas ([ModDex](https://moddex.gg/mod/hexparse) (secondary)); and HexDebug, a Debug Adapter Protocol server for stepping through hexes in VS Code ([Modrinth: HexDebug](https://modrinth.com/mod/hexdebug), the mod's own page). The VS Code extension's author refused to support importing hexes without drawing them ([forum](https://forum.petra-k.at/viewtopic.php?p=52) (secondary)), while HexParse does exactly that. **That split shows drawing being treated as an I/O bottleneck for big programs and as the point of the game for small ones**, a tension any circle language inherits.

**Psi** (Vazkii), which Hex cites as its inspiration, is the opposite case: layout carries the binding. Pieces on a 9x9 grid read their parameters from specific adjacent sides, connectors redirect, and the compiler walks back from side-effecting "tricks" to build a dependency-ordered action list, rejecting cycles with INFINITE_LOOP ([SpellCompiler.java](https://raw.githubusercontent.com/VazkiiMods/Psi/master/Xplat/src/main/java/vazkii/psi/common/spell/SpellCompiler.java)). Each piece evaluates at most once per cast (four Debug tricks print the same random number), tricks run row by row from the top and left to right within a row (the in-game book's summary page words this the other way round), and spell cost is computed at compile time from number constants ([Psi lang file](https://raw.githubusercontent.com/VazkiiMods/Psi/master/Xplat/src/main/resources/assets/psi/lang/en_us.json)). Psi's layout is semantic, but it looks like a circuit board. The other magic mods are recipe matching. Ars Nouveau's grammar is one Form first, Effects in order, and Augments modifying the glyph to their left ([ars.guide](https://ars.guide/book/getting_started/introduction_to_glyphs/)), with a third-party guide giving 10 glyphs per spell and summed mana costs ([minecraft-guides](https://www.minecraft-guides.com/mod/ars-nouveau/wiki/spell-builder/) (secondary)); Occultism rituals match a chalk layout exactly and report the specific error ([siriusmc guide](https://wiki.siriusmc.net/books/modpack-guides-and-tutorials/page/occultism-rituals-atm10) (secondary)).

### Noita, Magicka and fighting games supply evaluation models

**Noita's wand is a depth-first card interpreter.** The fan wiki's Expert Guide frames it as deck, hand and discard piles, where modifiers draw one card, multicasts draw several, each spell draws its children before its siblings, and spells never modify each other: they all mutate a shared "shot state", while each trigger opens a child shot state for its payload ([Expert Guide: Draw](https://noita.wiki.gg/wiki/Expert_Guide:_Draw) (secondary)). Greek-letter spells are calls with a recursion limit of 2 ("Tau, Tau, Spark Bolt" yields three Spark Bolts because the second Tau cannot call Tau) ([Calling and Recursion](https://noita.wiki.gg/wiki/Expert_Guide:_Calling_and_Recursion) (secondary)). Divide By spells copy the next spell and are explicitly *not* recursive, so that limit does not bound them; the wiki's 800-copy figure comes from Tau copying a 10x10x4x2 Divide chain, and it mentions an "iteration limit" whose value nobody here read ([Divide By](https://noita.wiki.gg/wiki/Divide_By) (secondary)). Trigger loops can run away and crash the game ([Trigger Loop](https://noita.wiki.gg/wiki/Trigger_Loop) (secondary)), and the community built a Wand Simulator that draws the evaluation tree because nobody can hold it in their head ([Wand Simulator](https://noita.wiki.gg/wiki/Tool:_Noita_Wand_Simulator) (secondary)). Those two facts, bounded resources and visible evaluation, recur in every design below.

**Magicka is a multiset grammar.** Up to five of eight base elements (plus steam and ice) are queued, element order does not change an ordinary spell, a precedence hierarchy (shields, projectiles, beams, steam, lightning, sprays) picks the spell type, and there is no mana bar ([Wikipedia: Magicka](https://en.wikipedia.org/wiki/Magicka) (secondary)). Opposing pairs (water and lightning, lightning and earth, life and arcane, cold and fire) cancel ([Magicka wiki: Elements](https://magicka.fandom.com/wiki/Elements) (secondary)). Magicks are the ordered exceptions, fixed sequences like Haste and Teleport, and only Portal accepts two orderings ([Magicka wiki: Magicks](https://magicka.fandom.com/wiki/Magicks_(Magicka_1)) (secondary)). The Arrowhead postmortem says elements were meant to "give meaning to each spell, and vary its efficiency" instead of draining a mana bar ([Game Developer](https://gamedeveloper.com/business/postmortem-arrowhead-game-studios-i-magicka-i-) (secondary)). Athanor below keeps the multiset and the oppositions but invents its own reaction table.

Fighting games are the precedent for accepting imprecise input deterministically. A hobbyist implementation write-up stores directions in a buffer, inserts neutral, flips for facing, and matches *backwards* from the button press with a per-step frame window and a strict or fuzzy flag ([critpoints.net](https://critpoints.net/2025/02/05/how-to-code-fighting-game-motion-inputs/) (secondary)). Community testing of Street Fighter 6 by Loic "WydD" Petit, reported by EventHubs, found an 11-frame quarter-circle buffer, half-circle windows widened from 8 to 12 frames and 360s from 25 to 32 compared with SF5, input polled three times per frame, and priority rules (Overdrive specials over everything, 360 over quarter-circle) that cause unintended moves when inputs share prefixes ([EventHubs](https://www.eventhubs.com/news/2023/jun/17/sf6-input-trouble-breakdown) (secondary; not Capcom data)). **Ambiguity resolution, not tolerance, becomes the dominant failure once many inputs share prefixes**, which argues for glyph sets with distinct primitives.

### Drawing-as-casting games mostly gate on shape and scale on size

Gesture-casting games mostly recognise a shape and then pass or fail it. Arx Fatalis runes "must be correctly drawn in order to successfully cast a spell" ([Wikipedia: Arx Fatalis](https://en.wikipedia.org/wiki/Arx_Fatalis) (secondary)); a retrospective describes them as morphemes, where a left-to-right line means "create" and its flip "negate", bottom-up means "improve" and its inversion "reduce", across about 20 runes and nearly 50 spells ([Super Jump](https://superjumpmagazine.com/arx-fatalis-magic-was-ahead-of-its-time-and-technology) (secondary)). That is the closest shipped example of compositional shape semantics. Okami's Celestial Brush drew recurring reviewer complaints about recognition ([Wikipedia: Okami](https://en.wikipedia.org/wiki/%C5%8Ckami) (secondary)), and Castlevania: Dawn of Sorrow's Magic Seals, a pattern of connected points on a circle copied within a time limit, drew complaints about stylus ergonomics and pacing ([Wikipedia: Dawn of Sorrow](https://en.wikipedia.org/wiki/Castlevania:_Dawn_of_Sorrow) (secondary)). The Magus Circle released on 24 September 2026 with the line "Even the most crudely drawn sigils still hold magic within" and options to slow or freeze time while drawing ([Steam](https://store.steampowered.com/app/2796640/The_Magus_Circle/) (store page, secondary)); nothing was verified about how accuracy affects spells.

A few games do scale effect by quality. **War of Wizards** (Arcane Miracle Entertainment, VR, released 21 September 2022) says on its store page, rechecked for this report: "The bigger and more accurate you draw them, the stronger they are!" and "their power is fully determined by how you draw them" ([Steam: War of Wizards](https://store.steampowered.com/app/2009460/War_of_Wizards/) (store page, secondary; it states the developer's claim, not measured behaviour, and does not describe the scorer)). Lost Magic (DS, 2006) rewards accurate drawing with more powerful spells according to Wikipedia ([Wikipedia: Lost Magic](https://en.wikipedia.org/wiki/Lost_Magic) (secondary)), or with critical hits according to a review ([Game Revolution](https://www.gamerevolution.com/review/37102-lostmagic-review) (secondary)); the sources disagree on mechanism. An itch.io prototype, Skill & Spell, grades precision into damage multipliers of x1, x1.25 and x1.5 ([devlog](https://totallynotdevs.itch.io/skill-and-spell/devlog/1676576/first-playable-prototype-drawing-runes-and-dueling-the-dummy)), and a mobile game scaled damage with circle size ([4Gamer](https://www.4gamer.net/games/335/G033541/) (secondary)). Against this sits Edward McNeill's IRONSTRIKE write-up: rune tracing in fast VR combat missed lines "by fractions of an inch", frustration did not drop with experience, and loosening it made flailing optimal, so the game switched to crossing line segments ([Game Developer](https://gamedeveloper.com/design/conjuring-a-gestural-spellcasting-system-for-vr)). Wizard of Wii (FDG 2011) found real recognition accuracy of 69 to 79% across two sessions, far below lab figures, and that players disliked similar-looking circular gestures ([Cheema and LaViola](https://www.eecs.ucf.edu/~jjl/pubs/p265-cheema.pdf)). **The pattern across shipped games is identity from shape, magnitude from size or accuracy, and precision graded rather than gated.**

### Fiction and history already wrote the grammars

Two fictional systems are close to specifications. In Sanderson's Rithmatics, a Line of Warding's strength depends on "its evenness and its curvature", larger circles are weaker, a typical Line of Warding "can take about 6 hits from a Line of Vigor", Forbiddance strength depends on straightness with thickness setting its height (about 10 hits, about four seconds to dismiss), Vigor is a sine wave that must complete two intervals, Making strength depends on "complexity and aesthetic beauty", and bindpoints (2 on an ellipse, 6 from an inscribed hexagon, 9 from a non-obtuse triangle) are where other structures attach ([Coppermind: Rithmatics](https://coppermind.net/wiki/Rithmatics) (secondary)). In Witch Hat Atelier, "a spell will only activate if its ring is complete", a gap lets a spell be prepared and finished later, the central sigil sets the element (earth, air, water, fire, light), signs around it set the form in radial or bilateral symmetry, a flipped sign produces the opposite effect, linking and nesting combine spells, and **size sets power while neatness sets durability**, two separate axes ([WHA Fandom: Magic](https://witch-hat-atelier.fandom.com/wiki/Magic) (secondary)). Fullmetal Alchemist's circle as a conduit with triangle runes ([FMA Fandom](https://fma.fandom.com/wiki/Alchemy) (secondary)) offers less grammar. Mahouka's CAD stores "digitalised magic circle blueprints" with fixed variables, and the target and strength are filled in later ([Mahouka Fandom](https://mahouka-koukou-no-rettousei.fandom.com/wiki/Magic_Sequence) (secondary)); reading that as a compile-time/run-time split with partial application is an analogy, not the source's claim. Ars Magica's five Techniques by ten Forms is the cleanest published verb-by-noun spell grammar ([Ars Magica Wiki](https://arsmagica.fandom.com/wiki/Hermetic_Arts) (secondary)).

Historical devices offer real machinery. Llull's alphabet is nine letters, B C D E F G H I K, and his Fourth Figure is three concentric circles that "must be rotated to form the different combinations", stepping BCB to CCB to BDB ([Stanford Encyclopedia: Llull](https://plato.stanford.edu/entries/llull/)). A German lecture handout gives 9^3 = 729 combinations for the Ars as a whole, not for one disc ([Bremen handout](https://www.compart.uni-bremen.de/content/4-teaching/0-summer-2019/2-theorie-und-geschichte-des-berechenbaren/3-material/berechenbar19-04lull.pdf) (secondary)), and the view of the Ars as "a precursor to computer science" is scholarly opinion reported by Wikipedia, not something the Stanford entry discusses ([Wikipedia: Ars Magna](https://en.wikipedia.org/wiki/Ars_Magna_(Ramon_Llull)) (secondary)). Kamea sigils are an encoding algorithm: map a name's letters to numbers, find them on a planetary magic square, and join cell centres with lines, with loops for repeats and a bar at the end; a practitioner notes these are, "as far as we know, first documented in Agrippa", who applies them inconsistently ([David Rankine](https://www.davidrankine.com/post/agrippa-and-the-magic-squares) (secondary)). Spare's method deduplicates the letters of a written desire ("IDESRTHNGOFMY") and merges them into a monogram ([sacred-texts TOPY page](https://sacred-texts.com/eso/topy/black3.htm) (secondary)); he rejected the medieval view of spirits as external beings ([Wikipedia: Sigil](https://en.wikipedia.org/wiki/Sigil) (secondary)). Puzzle games round this out: Baba Is You makes rules out of aligned tiles, The Witness teaches a drawn-path grammar without text, and Cultist Simulator makes combinations discoverable by experiment ([Wikipedia: Baba Is You](https://en.wikipedia.org/wiki/Baba_Is_You); [Wikipedia: The Witness](https://en.wikipedia.org/wiki/The_Witness_(2016_video_game)); [Wikipedia: Cultist Simulator](https://en.wikipedia.org/wiki/Cultist_Simulator) (all secondary)). Magic: The Gathering is Turing complete under forced play ([Churchill, Biderman and Herrick, FUN 2021](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.FUN.2021.9)).

### The 2026 Witch Hat Atelier recognisers are the nearest working pipeline

The closest thing to the full idea appeared in May 2026. **wha-spell-simulator** (ytnrvdf, MIT) "turns a freehand spell diagram into parser output, compiled spell behavior, and animated canvas effects", and it is self-described as "an experimental prototype" ([README](https://raw.githubusercontent.com/ytnrvdf/wha-spell-simulator/main/README.md)). I rechecked its docs for this report. Its GlyphAST records the ring's completeness, roundness and a "combined ring quality score" called neatness, plus global neatness, radial symmetry and instability, and it lists `unsupportedNestedRings` as "detected inner rings that are not compiled" ([glyph-ast.md](https://raw.githubusercontent.com/ytnrvdf/wha-spell-simulator/main/docs/glyph-ast.md)). Its SpellIR derives duration "mostly from glyph quality and neatness", clamped to 0.65 to 8.5 seconds, and rejects multiple rings or multiple sigils as invalid with no fallback to another element ([spell-ir.md](https://raw.githubusercontent.com/ytnrvdf/wha-spell-simulator/main/docs/spell-ir.md)). An earlier API read showed around 900 GitHub stars; I could not recheck that figure. Relatives include a Rust port running on a reMarkable 2 ([aetherquill](https://github.com/rajyyug1132/aetherquill)), a Unity version classifying stroke groups with a Teachable Machine model ([Pancu](https://github.com/Pancu/Witch-Hat-Atelier-Spell-Recognition-Unity)), and a template-based one that sums sign strokes as force vectors and emits misfire warnings ([YatoVoid](https://github.com/YatoVoid/witch-atelier)). All of them are fixed-vocabulary spell systems with strokes as input. None handles nesting, sequencing or control flow, none reads photographs, and none runs in VR. A VR spellcasting prototype that already recognises strokes and glyphs sits in that last niche.

---

Text licensed CC BY 4.0 (attribution: Hiina, ai.hiina.space). Source: https://github.com/hiinaspace/ai-hiina-space