Design Memory Platform

Features

35 feature requests
F035 built - in verification 12 Jul 2026

MSC 2.4 panel - ARAL's first Language Seed live in Blender

A second panel in the ARAL tab (aral_prototype_v1_002-v1_005) rebuilding thesis 2.4 from its seed source: 2.4A 3D Insertions (1:1:1 cube, nine placement grammars incl. the growth-spiral road and the printed three-step final algorithm) and 2.4B Growth Generator (2x1x1 primitive, six genes - number/stack/rotation/movement/scale/climb - with the six Fig 2.17 outputs as gene-exact one-click replay presets, plus the Fig 2.18 random-rules programme). Every run records a full plan; deterministic per seed. Rule semantics stated in print implemented as printed; scale taper, climb rise and clockwise sign flagged as rebirth interpretations (s18) awaiting Miles's eye. First emergent form banked as Q036 (mode 4, 452 cubes, seed 371401). v1_003 one-family-on-stage sweep; v1_004 dead-reference-safe materials; v1_005 default-Cube removal.

F034 in progress 11 Jul 2026

Gravity toggle - a world property that frees generated form from the ground plane

Since 1994 every generated form has stood on the ground. Gravity off lifts that rule - form composes freely in three dimensions, and GAAD steps beyond architecture. Gravity is a WORLD property (not a genome gene, not per-language): the Connector already passes world into random_genome, build and validate, so every language receives it without signature change. Replay obligation: the gravity state is recorded in the stage file alongside language/version fields (s7 family) so a stage always replays as made. Each language decides what gravity-off means for its rules (e.g. TWAL footprints-on-grid is a gravity-on rule). First home: ARAL, the art language born 11 Jul 2026 - gravity migrated there with the sphere when PRAL reset to its five 1994 primitives (languages do not mix). ON preserves stage-plane behaviour; OFF removes the stage and places objects around the world centre.

F033 in progress 10 Jul 2026

GAAD Language Connector - the runtime contract that lets any language run through world/stages/lineage

THE SOLUTION TO T021. GALF defines what an Architectural Language IS but, by its own neutrality rule, cannot own a runtime interface - so languages could be defined but not run through Initial Generation -> Breed -> Navigator/Backtrack -> Present Stage. The GAAD Language Connector is the second contract that closes this gap: GALF stays neutral by SILENCE (names no software), the Connector stays neutral by ABSTRACTION (names verbs, never a vendor). Engines are pluggable adapters behind the interface - Blender is one adapter; a browser renderer (P054, F032) is a peer. CORE SHIFT: seed -> genome. A seed cannot be bred (no locality, no recombination); the Connector makes the design an explicit GENOME - a gene array where each gene is one decision - and build() PURE, so replay is bit-exact (replay, never mutation). Interface verbs: describe, random_genome (the only RNG site), build, mutate, breed, serialize, deserialize, validate. STATE AT FILING: spec GAAD_Language_Connector_v0_001_TWAL.md + reference implementation twal_connector.py (engine-free, never imports bpy; MemoryAdapter proven), both RINGFENCED standalone with TWAL (D144 fence). Three three-seat decisions open at filing: (a) Connector as separate spec referencing GALF; (b) whether platform_status=active contractually requires a conforming Connector; (c) whether the serialize .CEL format is per-language or a shared platform envelope. T021 closes when a language runs through the platform loop via this contract. GRADUATION (when the fence lifts): spec -> Spec/, connector joins the Engine section, TWAL trio -> Languages/, TWAL_CHANGELOG -> releases record, D144 wording repaired to name TWAL/Connector explicitly. KEY DIAGRAM: Website/architecture.html Figure 1 ('CONTRACT - LANGUAGES - CONNECTOR - ENGINE') is the canonical picture of this feature - the four-layer stack (GALF names no engine; five languages conform up to GALF; the Connector names verbs, never a vendor; the Engine is the swappable base: Blender today, a browser/desktop renderer tomorrow). Its caption states the thesis: the seam is the point - swapping the engine changes the base of the stack, not the design above it. Figure 2 on the same page (TWAL, seed to genome to phenotype) is the worked example. UNWIRE REQUIREMENT (Miles, 10 Jul 2026): the Connector must be removable without harming the GAAD platform. Wiring is ADDITIVE-ONLY by design: (1) PRAL's native path is never modified - Connector languages take a parallel branch behind a CONNECTORS registry, so unwiring = deregistering (one dict entry), and with an empty registry the platform is exactly pre-Connector GAAD; (2) no core script may import a connector module at top level - imports live behind the registry lookup, so a missing/broken connector file cannot break addon registration or PRAL generation; (3) stage files made by a Connector language keep their genome payload even when unwired - existing lineages stay readable and honest (the stage reports its language as not-runnable rather than erroring); (4) Validate Scripts proves the unwired state: a step runs the PRAL loop with the registry emptied, so 'unwire is safe' is asserted, not assumed. This is the D144 fence philosophy carried into the platform: connection is a privilege the platform grants, not a dependency it acquires. DIAGRAM NEEDED (Miles, 10 Jul 2026): a new figure for the three-phase wiring plan - (1) stabilise the prototype, (2) Connector wrapper around it, (3) wire to the GAAD panel (unwireable). Shape agreed 10 Jul 2026 (Miles: likes the simplicity): three boxes - Prototype 'the sketchbook' -> sync -> Connector 'the fair copy' -> wire -> GAAD 'the gallery, never changes' - with a return arrow (back to the sketchbook, any time), the fence drawn as a dashed gate before GAAD, and the honesty rule as a strapline: 'A rule is not real until it is in both.' To be drawn in the website Figure style as architecture.html Figure 3.

D144D145
F032 parked 10 Jul 2026

Interactive two-minute demonstration page - one design, one click, the whole GAAD loop

PROPOSAL (Miles, 10 Jul 2026): the next website build is not another feature but a polished interactive demonstration. One page. One design. One click. The page shows: (1) a parent design; (2) four children appear; (3) the user selects one; (4) a new generation grows; (5) the Decision Tree updates; (6) the Design History updates; (7) replay of the complete journey. Success test: someone who has never seen GAAD understands it in under two minutes from this demonstration alone - memorable, complementing the existing site as its front-of-house proof. NOTES (Specification Owner): this is the browser dream (P054) made concrete and small - a renderer as a swappable adapter, running a genome->phenotype loop client-side. TWAL is the natural candidate language (smallest, genome-shaped, engine-free Connector already proven in twal_connector.py); a JS port of the Connector verbs (random_genome, build, mutate, breed, replay) would drive it. Steps 5-7 are the platform's own vocabulary on screen: Navigator (decision tree), lineage (design history), replay-never-mutation (the journey). Depends on the Connector three-seat decisions (T021) settling the genome and serialize form first. MEDIUM OPEN (Miles, 10 Jul 2026): the demonstration could equally be delivered as a video or a diagram rather than an interactive page - decide which medium is best when the feature is developed. The seven-step storyboard and the under-two-minutes test hold regardless of medium. PARKED: recorded so the idea is not lost; not scheduled. Sequencing suggestion: after TWAL graduation, as the flagship F031 deliverable.

D144
F031 parked 09 Jul 2026

Website + AI as the primary read interfaces (with searchable, live records)

INSIGHT (Miles, 09 Jul 2026): 'if i am looking for a record, I ask you or go to the website as it is easy to use.' In practice the two interfaces GAAD is actually read through are (a) the website and (b) asking an AI seat. The JSON source of truth, generators and bundle structure are PLUMBING that Miles does not touch by hand. This reframes priorities: the website is not a side publish artefact, it is the primary reading room, and the AI seat is the primary retrieval method - so both must be first-class and trustworthy. FEATURE CONSEQUENCES to build: 1. Website live data - records on the site should reflect live record data, not a snapshot frozen at publish time. If the website is the primary reader, a stale website is stale memory. (Supersedes the earlier 'live data on hold' note - this raises its priority.) 2. Website record search/filter - a search or filter box so 'find me the NASA thing' works ON THE SITE the way it works when asking the AI. The flat-table-with-category-filter pattern (audit/Records Hub) is the starting point; extend to free-text search across records. 3. Website always in the bundle - the reading room must travel with the project, never be orphaned as a separate zip (see the standing website-in-bundle rule). 4. AI retrieval must be disciplined - the primary 'ask Claude' path depends on the handover rules: search-first, do-not-parrot, verify-then-state (HANDOVER READ FIRST section). An AI that guesses instead of reading the records breaks the interface Miles relies on daily. Also captured this session and related: the daily audit log as a shareable blog post (one HTML page per day, native 4bim theme, deep-links into record HTMLs, opens with a records scoreboard). A website 'Daily' index page (daily.html) and publishing the daily series are the immediate follow-ons. PARKED: not started. Recorded so the strategic steer is not lost. Priority raised from 'on hold' to a recognised primary-interface concern.

D128D144D145
F030 adopted 12 Jul 2026

Validate Scripts: one button drives every command and validates against expected outcomes, watchably

Miles, 07 Jul, end of the Backtrack build day: 'I find I am doing the same tasks over and over again' - a script that runs and tests ALL the commands, like the Integrity test but validating against EXPECTED OUTCOMES, with its own button under Reset GAAD Platform labelled GAAD, so he can watch it run and visually detect errors. Working name GAAD Quality Run; proposed name PROVING RUN (architectural register - a proving run proves the platform; pairs with 'proof shot'), Miles to settle. Design: the in-viewport sibling of the D135 headless smoke test - ONE shared assertion library, two runners: headless (blender --background, CI-style, exit code) and watchable (the GAAD button, stepping through the real operators with a visible pause per step and a running PASS/FAIL readout). Sequence v0.1: Reset -> First Generation -> assert lineage.json + s1_g01 -> breed x3 -> assert string extension + creation index -> Backtrack via Navigator -> assert replay, champion gold, current_position -> breed from pivot -> assert string 2 + pivot record -> Navigator -> assert discs tangent, no overlap, connectors on rims, red/gold state colours, label stamps -> flip Colour/Grey/Bauhaus -> assert material sync in both scenes -> isolate + labels -> assert visibility rules -> summary. Each step declares its expected outcome BEFORE running (D135 practice 1, mechanised). Builds on: Integrity Check (static), gaad_validate.py (records), D135 smoke test (headless). Every future feature must add its step to the Proving Run - the definition of done grows with the platform. NAME SETTLED (Miles, 07 Jul): VALIDATE SCRIPTS. Button under Reset GAAD Platform; the headless runner remains gaad_smoke_test.py. AMENDMENT (Miles, 07 Jul evening): Validate Scripts needs a PAUSE button. Design note for the build: implement as a Blender MODAL operator driving a step queue on a timer - pause/resume/step-once then fall out naturally, and the live PASS/FAIL readout stays visible while paused so an error can be inspected in the viewport mid-run. BUILD v0.1 (08 Jul 2026, addon v0.99.02): delivered as three pieces. gaad_assert.py - the ONE shared assertion library (storage checks proven in-sandbox against clean and deliberately broken data before delivery); gaad_smoke_test.py - the headless runner per Spec/GAAD_SmokeTest_v0_01 (drives the real generator/tree scripts, simulates the backtrack via a lineage current_position edit, exit code 0 = PASS); Validate Scripts button in the panel under Reset GAAD Platform - modal operator on a timer stepping the REAL operators with a visible pause per step, live PASS/FAIL readout, Pause/Resume and Stop. Awaiting Miles's in-viewport proving run. The gaad_tree_layout.py bpy-free extraction remains queued as the companion piece. PROVEN (08 Jul 2026, 15:21, P051): first clean run, 18 steps 0 failures, addon v0.99.11 / generator v0_49 / tree v0_18 / gaad_assert v0.1.4. Report header records timestamp + full script inventory; Pause/Step/Stop live while running. Open follow-ons: T019 platform sweep; the unselected-tip Navigator design question. v1_007 (12 Jul 2026): the proving run now tests the Isolator from the NAVIGATOR as well as the Generator (steps 'Isolator from Navigator' + 'Back to Navigator', after Navigator rebuild) - the 1994 Fig 3.11 Navigate->Isolate flow. Full run: 26 steps, 0 failures, verified with TWAL graduated and live.

D135D132D133
F029 adopted 07 Jul 2026

Circular Navigator stages: the 1994 evolutionary tree language returns

Navigator lineage stages are circular discs, proposed by Miles ('circles like 1994 - they look more genetic') and runtime-confirmed same day ('such a quick fix fable - love it'). Returns the Navigator to the 1994 evolutionary tree plates (thesis Figs 3.21 / 3.28 / 3.29 - specimens under glass, cells in a lineage). The World keeps square stages: square = plot/site, the unit of WORK; circle = cell/specimen, the unit of MEMORY - the geometry itself distinguishes the two scenes at a glance, and the scene boundary quietly teaches the Evolve/Backtrack distinction on every crossing. Aligns the live tool with the website hero's dots-on-a-path and Q024's atoms (atoms are round). Disc diameter = stage size, same thickness, F028 colours, engine stamps and pivot connectors unchanged; raw-mesh 48-segment disc, zero bpy.ops. Shipped in tree v0_11; the decision record is D134.

D134D132D028
F028 adopted 07 Jul 2026

Navigator state colours: red dead ends, gold current champion, tips hidden

The Navigator's colour state language, designed by Miles's viewport markup and runtime-confirmed same day ('BINGO!'): every stage in the lineage array reads its fate at a glance. NEUTRAL GREY = history (a champion on the path); RED = dead end, each preserved string's last champion - the 1994 word made visible, where a line of work was honourably set aside; GOLD = the current champion, the active string's deepest decision, in the same CHAMPION_GOLD the Generator world uses (one colour, one meaning, both scenes - chosen over green for cross-scene consistency, green a one-line constant swap). Empty tip stages (bred but unjudged) are not rendered at all - no platform, no text; their data stays on disk untouched, and the red dead end becomes the string's true endpoint: its last DECISION. Rule of thumb: gold = newest string, that string's last decision - depth in the array is history, gold is recency; gold marks decisions, not transient backtrack position (a future white current_position ring can mark 'where am I now' - lineage.json already knows). Shipped in tree v0_10, carried into the circular discs of v0_11 (D134). Split out of F027 as its own feature at Miles's direction.

D134D133D132D042D028
F027 adopted 07 Jul 2026

Gold champion in the Navigator: see where each string finished, re-champion by selection

Miles, 07 Jul (during the F006 build, captured on hold pending his 0_123 storage-layer testing): in the Navigator view the gold champion is not visible today, yet it is a great visual clue to where a generative string last finished. Proposed: (1) the Navigator shows each string's latest champion in gold - the tip of every string readable at a glance across the lineage array; (2) clicking a stage in the Navigator to select a new champion turns that stage gold and returns to the World view with the same stage championed - the Navigator becomes not just the Track decision point (D133) but the re-championing surface. DESIGN NOTE to resolve when built: D133 agreed that selection never commits and only the button press does; this feature as described has the click turning gold and returning - reconcile whether the gold-turn is preview (commit still on the button) or whether re-championing in the Navigator is a deliberate exception to the selection-never-commits rule. Natural build companion to tree v0_8 (the multi-string Navigator, F024) since both touch the same render pass. Gold champion palette already shared via gaad_palette.py. OFF HOLD + REDESIGNED BY MARKUP (Miles, 07 Jul, after runtime-testing the array): (1) empty tip stages are NOT rendered at all - no platform, no text (their data stays on disk untouched); (2) each PRESERVED string's last champion stage is coloured RED - the dead end, the 1994 word made visible; (3) the ACTIVE string's last champion stage is GOLD (CHAMPION_GOLD, matching the Generator world's champion fill, D042 - chosen over green for one-colour-one-meaning across scenes; green remains a one-line constant swap, DEADEND_RED/CURRENT_GOLD in tree v0_10). Consequence accepted: the unjudged final grid of each string is no longer clickable in the Navigator - the red dead end is the string's last DECISION, the truer endpoint. Shipped in tree v0_10 (v0_9 was a withdrawn tip-label restyle; number retired). Re-champion-by-selection commit question from the original note: resolved in practice by D133 - the button commits, and the backtrack gold-turn on commit is live since addon v0_94. RUNTIME-CONFIRMED (Miles, 07 Jul, 'BINGO!'): tree v0_10 verified live - tips gone, two red dead ends on preserved strings, gold current champion on the active string's deepest decision. Confirmation screenshot banked at Website/episodes/ep4_lineage_array_dead_ends_red_champion_gold_07jul2026.png - candidate EP4 hero image alongside the P050 proof shot. Gold-vs-green settled by viewport: gold stands. SPLIT (Miles, 07 Jul): the colour state language (red dead ends / gold current champion / tips hidden) is now its own feature, F028. F027 remains the record of the original idea and the re-champion-by-selection interaction, resolved via D133.

D133D132D028
F026 adopted 05 Jul 2026

Architectural Language selector (PRAL / GRAL / MHAL)

LANGUAGE section at the top of the panel: a radio selecting the Architectural Language, with the Objects picker inside it (the language owns its objects, D098/D102). PRAL shows its five primitives; GRAL and MHAL are selectable but marked not yet built, gate MUTATION, and grey out First Generation (plus an operator guard). Locks at Gen 1 with the other world-shape choices. Reinstates the D099 selector that D113 parked, under the D123 naming. Built in addon v0_86 (property gaad_architectural_language).

D123D124D099D113
F025 adopted 05 Jul 2026

Stage Isolator render scene

Extend the existing Stage Isolator (F004, VIEW > Stage button) into a proper render scene: when a stage is isolated, present it as a focused render-ready view - clean background, framed camera, no grid or neighbour stages showing through, materials as chosen (Brand or Grey per D120). The Isolator today only hides other stages in the viewport; this feature makes the isolated stage a first-class output. Sits alongside T016 (Navigator materials + grids) - both are about scenes other than the Generator honouring the Colour choice and rendering cleanly. Miles's motivation: 'stage isolator render scene' - a way to present ONE selected design properly, ready to screenshot or share, without leaving the platform. Own session, own D### when built. BUILT 05 Jul 2026 (addon v0_84, carried in v0_85): a separate VIEW > Present Stage button renders the selected stage to a PNG in a new //Image folder - black studio world, key and fill sun rig, framed camera, other stages hidden from the render, materials as chosen (Brand or Grey). Kept as-is by Miles after test; future enhancements parked as T017.

F004D120T016D122
F024 next 7 days 03 Jul 2026

Evolution Tree showing forward AND backtrack lineage

The Navigator today (gaad_tree_v0_6.py) shows the forward lineage - the world as it was evolved. When Backtrack (F006) ships, the same tree needs to show BOTH directions from any moment: what was bred forward from it AND what alternative branches were rewound from. Reads as a directed graph rather than a straight chain - a design's true genealogy. Scope: touches the tree renderer, the Records data model (branch links from Backtrack events), the Navigator report, and how the Generator restores a branched state when a designer clicks a node. Related to T016 (Navigator materials + grids) - would be sensible to fix both in one Navigator pass. Own session, own D### when built.

D110F006F022
F023 open 03 Jul 2026

Rectangular stages (Manhattan-style)

Add rectangular stage footprints as an option alongside the square presets (D120). Reference size: Manhattan avenue-to-avenue block at approximately 80 x 275 metres (roughly 260 x 900 feet). Rectangular stages introduce genuinely different urban DNA: long thin blocks generate a different feeling world from square ones. Scope: touches the generator (stage geometry, per-stage layout, object placement rules, label position), the Navigator (stage previews and layouts), the camera framing (aspect ratio and view-all behaviour), the panel spec (stage-size selector grows a rectangular option) and the D110 grammar (world-shape choice, locks with the square-size selector). Deserves its own session and its own D### when built. Miles: 'just add as new feature'.

D120D110
F022 in build 02 Jul 2026

Rapid Evolution - selection IS the breeding act

Proposed by Miles (open, no action today - his explicit call): in Rapid Evolution mode, picking any object on a stage breeds the next generation from it immediately - no separate Next Generation click. Pick and breed collapse into one gesture; with the fast geometry (D106) a rebuild lands well under a second, so generations run at the speed of clicking. Miles: '1994 could never do this.' His usage narrative, preserved as design input: click, click, click, click - pause (panel control) - click object, spin around, inspect - then resume - click, click - Navigator - explore. Design sketch agreed in discussion: a MODE, not a replacement (toggle; classic two-step remains available); guarded trigger (only variant/stage geometry counts - labels, camera, furniture ignored); busy-lock ignores clicks while a build runs; technically a msgbus subscription on the active object deferring the build to a timer tick, which keeps the T006 safe-state pattern intact inside an event callback. The trap named and accepted for design: every click becomes a commitment - a stray inspection click replaces the generation on stage (JSON records everything, but mid-flow disruption is real), which is why Backtrack (F006) is the natural companion. Mode naming settled at the direction level as Evolve / Explore (with Backtrack the third verb) - see D110/P047; Play/Pause rejected since GAAD never breeds without the user's click. BUILT v1 as 'Rapid Stage Select' 03 Jul 2026 (addon v0_79 + generator v0_40, D119): additive toggle under Next Generation, msgbus watcher firing the existing operator, viewpoint preserved between breeds. First test verdict gold (P048); robustness gap after Navigator/Reset open as T015.

D106D110D118D119
F021 open 02 Jul 2026

Panel usage logging - capture GAAD operator clicks

Proposed by Miles during 0_107 testing: log every GAAD panel operator click. Two values: (1) crash forensics - Blender's own crash log only records bpy.ops calls, and the v0_33/v0_66 changes made GAAD quieter in that log (silent mesh builds, fewer ops); a GAAD-side event log flushed to disk per click survives a crash and gives the exact operator sequence and timing leading up to it, which today's T006 diagnosis lacked; (2) usage feedback - click counts per operator over real use show which panel commands earn their place, giving evidence for future panel decisions (decisions-become-data applied to the panel itself). Sketch agreed in discussion: append-only JSONL at Logs/gaad_usage_log.jsonl (new root folder, deliberately survives Reset); per event: timestamp, operator id + label, scene, grid size, generation, object count, result, duration ms; implemented as one shared wrapper applied to all GAAD operators at registration (no per-operator churn, no panel/UI change, so no conflict with the frozen mock-up D100); local only; a later generator can render usage-stats HTML into the existing pipeline. Open question flagged: visibility - always-on with no UI (simplest) vs a SETTINGS toggle (honest, but a panel addition that touches the D100 freeze). Claude's lean: always-on now, toggle when the panel next unfreezes.

D100
F020 parked-for-v0.04 01 Jul 2026

Document the idea-to-standard specification lifecycle

State explicitly the lifecycle a GAAD specification follows: idea -> draft -> peer review -> reference implementation (validation) -> standard (v1.00). Make it a shared convention future specs follow. Peer-review recommendation 5.

D103
F019 parked-for-v0.04 01 Jul 2026

Shared GAAD Principles record cited by all specs

Create a standalone gaad_principles record (JSON + doc) holding the shared principles (Understand People Before Geometry; Decisions become data; Structured knowledge before learning; platform vs language) that every future GAAD specification references from one source. Peer-review recommendation 4.

D103
F018 parked-for-v0.04 01 Jul 2026

DL v0.04: Terminology section referencing gaad_terminology.json

Add a Terminology section to the DL spec that references the existing gaad_terminology.json record and adds only DL-specific terms, rather than duplicating vocabulary. Peer-review recommendation 3.

D103
F017 parked-for-v0.04 01 Jul 2026

DL v0.04: unknown-key validation as warning within a reserved namespace

Downgrade unknown-key validation from error to warning ONLY within a reserved namespace (e.g. x_ prefix or an 'experimental' block); unknown keys elsewhere remain an error. Allows controlled evolution without losing the no-silent-private-extensions guarantee. Owner refinement of peer-review recommendation 2.

D103
F016 parked-for-v0.04 01 Jul 2026

DL v0.04: required-but-empty human-centred sections

Change People/Place/Experience from optional to required keys that must be present but may be explicitly null with a stated reason (e.g. PAL: applicable=false, reason='abstract primitive language'). Reinforces 'Understand People Before Geometry' while keeping honest validation. Owner refinement of peer-review recommendation 1.

D103
F015 open 30 Jun 2026

Geometry nodes as the primitive method for parametric AL languages

Investigate geometry nodes as the object-creation method for HAL and GRAL primitives (and any future Architectural Language), as an alternative to the direct mesh construction the GAAD generator uses from v0_33 (D106: raw vertex/face data joined per variant; before v0_33 primitives were individual bpy.ops objects, with only the dome using bmesh). Evaluated for new languages only; not a retrofit of the existing five GAAD primitives. TRADITIONAL BLENDER MESH (direct mesh/bmesh data) - current GAAD/MAL approach (v0_33, D106). Pros: simple and proven, already working at 9 to 81 stages; since v0_33 primitives are joined into one mesh per variant so object count stays flat as worlds scale (D106); triangle count, vertex count and bounding box are read directly from the mesh with no extra evaluation step; easy to score after the fact by measuring the finished geometry; no Blender version compatibility risk, since mesh/bmesh APIs are stable across versions. Cons: mutation means modifying the mesh directly (move verts, scale, rebuild), which is more code per shape; each shape variant is effectively hand-built logic in the generator; there is no single source of 'the design's parameters' - height, width and similar values must be inferred back out of geometry after building it rather than read directly. GEOMETRY NODES - candidate approach for new languages. Pros: the object's defining parameters live as readable, mutable input sockets (height, footprint, roof pitch), so they are first-class data rather than inferred from a finished mesh; one node graph can express many variants (a single Garden Room graph can become small or large, flat or pitched roof) rather than needing a discrete primitive type per variant; mutation becomes read parameter, mutate value, re-evaluate, which is closer to genuine genetic breeding than mesh editing, and aligns with D038 scoring since parameters can be scored directly without reverse-engineering geometry. Cons: heavier to evaluate at scale - untested whether 81 stages of evaluated geo-node objects stays performant; triangle and vertex counts require evaluating the dependency graph (object.evaluated_get(depsgraph)) rather than reading raw mesh data directly, which is slightly more code and slightly slower per object; more fragile across Blender versions, since geometry node socket APIs have shifted noticeably between 3.x and 4.x releases; steeper authoring cost, since building the node graph itself is more work than writing a bmesh primitive function. Summary: geometry nodes wins on parameter legibility for D038 scoring (clean, directly readable inputs); traditional objects win on measurement simplicity (trivial triangle/vertex counts, no depsgraph evaluation needed). Both are scoreable under D038; they expose different things easily.

D106
F014 open 29 Jun 2026

Auto-isolate on Create Next Generation

When Create Next Generation is clicked, automatically set the view to Stage Isolator (isolate the selected/champion stage). Saves the user from manually clicking Stage Isolator after every generation advance. The user can still click Show Stages to return to the full grid view.

F013 open 29 Jun 2026

Stage Isolator red state indicator

When Stage Isolator is clicked and a stage is isolated, the button should turn red to indicate the active isolated state. When Show Stages is clicked to restore the full grid, the red is removed and the button returns to its normal appearance. Gives clear visual feedback that the view is currently filtered.

F012 open 29 Jun 2026

Perspective View - EXPLORE viewport preset

A new Perspective View button in the EXPLORE panel section, positioned below 3D View. Switches to a low-angle perspective viewport similar to a street-level or eye-level camera. Complements the existing 3D View (elevated perspective) and Plan View (top-down orthographic).

F011 adopted 28 Jun 2026

Stage Size — Configurable Grid Layout

A Stage Size selector in the Object Collection panel allowing the user to choose the grid layout before creating Generation 1. Three options: 2×2 Classic (4 stages), 3×3 Default (9 stages, the standard layout), and 4×4 Testing (16 stages). The generator builds the grid dynamically using a build_stage_grid(n) function. Each stage keeps the same physical size; only the grid footprint changes. Implemented in generator v0_28 and addon v0_49.

D080
F010 adopted 27 Jun 2026

Plan View & 3D View — EXPLORE viewport presets

Two new buttons in the EXPLORE panel section: '3D View' switches to a perspective view angled at 65° looking down at the stage grid; 'Plan View' switches to a top-down orthographic plan view of all stages. Plan View resolves the 1994 thesis '2D Development Zone' feature (audit row). Both use Blender's region_3d to set view_perspective, view_rotation, and view_distance, then call view_all to frame the grid. Added in addon v0_47.

D078
F009 in-progress 27 Jun 2026

Sidebar Panel Redesign — Group by Intent

Redesign the GAAD Rebirth N-panel, which grew bottom-up so every control carries equal visual weight and reference material dominates. Reorganise into intent groups: Object Collection (setup) > Generate > Explore > collapsible Reports / Records / About & Versions > a divided, guarded Reset. Emphasise the single primary action (Create First Generation on a fresh/reset world, Create Next Generation once Gen 1 exists). Demote reference sections into default-closed collapsible sub-panels, keeping the collapsing header. See D074 (naming), D075 (Type taxonomy / single-Type selection), D076 (mutation toggle wording). UPDATE (27 Jun): added a dedicated MUTATION section (its own home, future home of F008) holding the 'Allow Mutation to Other Types' toggle plus per-object and population mutation sliders (shape switch, width/depth, height, rotation drift, position X/Y, add/remove object, min/max objects) that expose the generator's tuning values (D077) as live scene properties. Mutation renders as a collapsible sub-panel, CLOSED by default, to keep the everyday panel short. GENERATE buttons ordered Create First Generation above Create Next Generation. UPDATE (27 Jun, Chat 6): Mutation sliders are now LIVE — generator v0_26 reads scene properties at call time via _mut() helper, falling back to D077 defaults. Each generation's JSON records the active mutation settings under generation.mutation_settings.

D074D075D076D077
F008 open 27 Jun 2026

Mutation Toggle — Switch Objects On/Off per Generation

A panel toggle to control whether objects (primitives) can be switched on or off during mutation across generations. When enabled, the mutation process can add or remove individual objects from a stage, not just change their properties. Gives the user control over whether each generation can gain or lose objects entirely, as opposed to just mutating existing ones.

F007 open 26 Jun 2026

Genetic Engineering — Inject New Cells

A forward search mechanism that allows the user to artificially accelerate the design toward a goal — called Genetic Engineering (GE) in the 1994 thesis (Fig 3.18, 3.19). Unlike natural mutation which follows the evolutionary path, GE introduces a break in the genetic tree by injecting new cells / a micro phenotype directly. Example from 1994: setting rotation to 10 degrees globally, then using GE to change this gene — the desired outcome can be achieved much faster. GE is an unnatural adjustment and an interference with the evolutionary process, but allows quite radical changes to the evolutionary path. In the algorithm (Fig 3.19), a genetic engineer decision point sits inside the genetic loop — if yes, inject new cells and engineer genes, then re-enter the loop. Severe GE may cause previously recognised features in past generations to be lost (break in genetic tree). This is a future capability once the core backtrack (F006) and seed storage (D030) are in place.

D030D038
F006 next 7 days 08 Jul 2026

Backtrack

Ability to step back or forward through the design lineage - a core feature of the original 1994 GAAD thesis (Fig 3.16, 3.17). In the 1994 algorithm, a Track decision point sits outside the main genetic loop. The user chooses forward or back: Forward track checks if a forward generation exists - if yes, go forward one generation; if no, WARNING: there is no generation forward of this one. Back track checks if a previous generation exists - if yes, go back one generation; if no, WARNING: this is the progenitor, nothing exists before this. Once repositioned, the user re-enters the genetic loop and can grow progeny from that point, creating a new branch. The full genetic path is recorded so pivot progenies are always reachable. The Design Evolution tree is the data structure that makes this possible. Implementing backtrack in Rebirth is a direct test of the revival against the original 1994 system. Depends on seed storage (D030) and is tracked under D045 (backward/forward tracking). ELEVATED 02 Jul 2026: Backtrack is promoted from convenience utility to one of the platform's three core verbs (Evolve / Explore / Backtrack, D110, P047). Rapid Evolution (F022) makes it much more valuable: fearless one-click breeding wants a one-click step-back as its safety net. Candidate companion for the same build when F022 is implemented. NEXT 7 DAYS (Miles, 03 Jul 2026): with EVOLVE shipped as Rapid Stage Select (F022, D119) and the click-click-click loop live at 0.3s per generation (T012 closed, D118), Backtrack is the natural companion - every click is a commitment and evolution needs an undo. Big topic: touches storage (D030 seed reconstruct), the Navigator (F024 fwd+back tree), the D110 grammar (Evolve / Explore / Backtrack) and lineage. Own session, own D### when built. THESIS AUDIT 07 Jul 2026 (Chapter 3 reread, Figs 3.14-3.29): Both Forward and Backward tracking are REPLAY functions - they restore macro phenotypes from genes already stored in the gene bank and never mutate, unlike Forward Search which varies the genes. This maps directly onto D030 (store the recipe, not the cake). Backtrack exists to escape the stated dead-end limitation of Forward Search alone (Fig 3.14): the user backtracks to a PIVOT PROGENY showing greater potential and a new genetic string branches from it (Fig 3.16). Only the current path is recorded as data; dead-end paths stay visible in the tree but are ignored. Unique file naming generation_visitcount_quadrant.CEL keeps revisits distinct (8_3 = 8th generation, 3rd visit; Fig 3.25's worked path alternates forward search and backtracks A-K, including a backtrack right to the progenitor and a fifth genetic string from there). A Right Back button jumps to the progenitor in one step. Genetic Engineering causes a recorded 'break in genetic tree' (Fig 3.18) - a boundary case the Rebirth lineage model must represent. The 4th-dimension framing: time between generations is GAAD's 4th dimension; the user moves forwards and backwards through the design evolution with all design decisions recorded. v0_99: the button self-labels in three states and arms red - 'Backtrack' (idle) -> 'Select Stage for Backtrack' (red, in Navigator) -> 'Backtrack to String {s} / Gen {g}' (red, disc selected) -> commit returns to the Generator as plain 'Backtrack' (D138).

D030D045D110D118D119D138
F005 adopted 26 Jun 2026

Orthogonal Rotation Only

Option to constrain primitive placement to orthogonal rotations only (0, 90, 180, 270 degrees). When enabled, primitives on each stage are placed at right-angle increments only, giving a cleaner, more architectural feel to the generated designs. Implemented in generator v0_24 and addon v0_43 as a toggle in the Object Collection panel.

F004 adopted 08 Jul 2026

Isolator (GAAD Isolator scene)

Panel command Isolator: shows the selected stage on its own in a dedicated GAAD Isolator scene, a peer of GAAD Generator and GAAD Navigator. The stage's objects are linked (not copied) into the Isolator scene so geometry and materials stay in sync with the Generator; the scene carries its own HUD (Isolator - Stage N). Switched from the panel top row alongside Generator and Navigator - one click, no toggle. Reworked from the original visibility-toggle isolate in addon v0_98 (D137); Generator-fed for now.

D079D137
F003 open 26 Jun 2026

generate_handover.py

A script that auto-writes HANDOVER.md from the JSON records at the end of each session. Covers current bundle version, open decisions, latest script versions, sensible next steps, and recent pivotal moments. Removes the need to manually update the handover note daily.

F002 open 26 Jun 2026

GAAD Logo in HTML Records

Update all HTML record pages to include the GAAD logo image (gaad_logo_white.png on dark pages). Currently all pages use the text "GAAD" as a logo placeholder. Needs doing across all six HTML files.

F001 open 26 Jun 2026

Auto Testing Environment

An automated way to test GAAD script changes without manually running through the full Blender workflow each time. Would allow rapid validation of generator, tree, and addon changes, catching regressions before they reach a bundle zip.