GAAD — Pivotal Moments

P071 Milestone 25 Jul 2026

The pivotal day - a mockup became a platform direction between morning and midnight

Miles named it himself at 21:44, closing the day: 'we got there a pivotal day - not just a moment'. The shape of it: a session that began as Shell window tuning pivoted at his 'i want to discuss something with you' into the clean UX, the clean UX's HTML mockup became the live preview, the preview forced the genome question, and by evening the day had produced GLAS and its naming (D203), the genome format at nine versions, seven decisions (D202 through D208), the lineage ruling that unblocked the visual roadmap (D204), a complete measured fidelity case (D207), the clean platform IA (D208), two features, six quotes, and the first live drift caught by paperwork (T032). On the same day, at the other end of the platform, the About page was rebuilt from its generator, The Team got its own page and the thesis photograph joined About - three website publishes, 1_045 to 1_047.

Why it mattered

The seat split carried its first full day at load and the work was visibly better for it: the bench's reviews changed three decisions (D205, D206, D207), the Specification Owner's rulings changed the bench's architecture (the law moves to float64 Python), and every ruling passed through the Chief Architect on the wire. Two findings the day should be remembered by: drift needs neither two teams nor two years - one author and one week sufficed for the Hyperboloid divergence - and the conformance test improved a host before it was even built. The platform spent the day doing to itself what it does to designs: generations, selection, and a champion by evening.

D202D203D204D205D206D207D208

P070 Milestone 25 Jul 2026

The mockup started rendering the real thing - GAAD reaches the browser

A cleaner AFAL panel was being designed, and the panel was mocked in HTML first because HTML iterates in seconds where a Blender add-on takes minutes. Then the realisation that changed its status: the same page could render the ACTUAL AFAL forms, because the forms are radius and angle rules over an index chain and need no engine underneath them. A user-interface mockup became a working instrument. Miles's verdict, verbatim from the bench: 'wow this is another pivotal moment ... this html is so much better than i could have imagined and with the forms rotating so smoothly ... you have just given GAAD website a new emergent growth'. He said the web surface could grow into a tool in its own right rather than a preview of one.

Why it mattered

P054 named the browser as a possible endpoint on 9 July and argued the architecture was already shaped for it, the genome-to-phenotype split making the renderer an adapter. Nine days later the endpoint arrived early and from an unplanned direction - not as a port of the platform, but as a side effect of wanting a faster way to look at a panel. The forms drew, and they drew correctly: D197's growth law came through the port intact. Three consequences. The development loop gains a fast lane, where a form can be explored and judged on the web before it is committed to a slow Blender build. The reach argument in P054 stops being theoretical, since a browser is one click where a Blender install is not, and reach is what matters for a platform whose value is languages other people write. And the drift risk becomes real and dated: two copies of the growth laws now exist, one in JavaScript and one in Python, so the one-shared-definition question moves from architecture theory to the next thing that has to be decided. It also lands on the day the About page was found to have drifted from its own generator - the same disease, caught twice in one day, at two very different scales.

D197D144

P069 Milestone 23 Jul 2026

The Growth Generator returns, thirty two years on

Miles photographed pages from his 1994 MSc thesis Digital Evolutions - Fig 2.17, Fig 2.18 and the AutoLISP listing in the appendix - and asked for the Growth Generator to be rebuilt as its own section of the AFAL panel. The five rules were transcribed from the listing rather than remembered: stack, move, climb, rotate and grow, each one applied to the LAST block before a new one is made. Both of the thesis programmes were rebuilt, the six worked outputs of Fig 2.17 as buttons and the evolutionary run of Fig 2.18 as a seed. The first run in Blender drew 71 blocks from seed 1. The transcription had been simulated in plain Python before any Blender code existed, and it had predicted 71 blocks from seed 1. Miles: "and GG returns 32 years later". He had spent a month looking at GAAD, and said it was refreshing to look back at the earlier chapters of the thesis and at the Growth Generator.

Why it mattered

GAAD has described itself as a rebirth of the 1994 thesis since the first record was written. This is the first time the 1994 work has RUN. The Growth Generator and a 2026 phyllotaxis disc stood in the same Blender scene at the same moment, the AutoLISP and the golden angle on one grid, which is the founding claim demonstrated rather than asserted. The rebuild also settled what the original actually does, which memory had blurred: it accumulates, every block derived from the one before rather than from its index; rotation is a TOTAL sweep divided by the block count, exactly as the thesis text describes; and growth is ADDITIVE and may go negative, which is why the 1994 outputs are blades fanning out rather than the tapering spirals AFAL produces. Two of those three would have been got wrong from memory alone. The matching block count is the evidence that the thesis was read rather than approximated.

D188D196

P068 Languages 23 Jul 2026

AFAL turns to the singularity - the grid was never the point

Looking at a field of spiralling forms and wanting them to become the structural grid or panel system that defines a project, Miles ruled that AFAL should stop building worlds and start building one stage. His reasoning closed an argument the Specification Owner had got wrong minutes earlier: Claude had cautioned that breeding needs a population, so AFAL would need both a survey view and a studio view with a bridge between them. Miles's answer was that 144 stages was always an odd ball, GAAD already chooses any grid and one day nxn, and when AFAL connects to GAAD only one stage has to work. GAAD owns the population; AFAL owns the stage.

Why it mattered

It puts AFAL back in line with how PRAL and TWAL have always worked, and it removes the constraint that had been quietly shaping every form in the language: with 144 stages in view, each one's budget is a hundred and forty fourth of the machine, which is why AFAL's architecture has so far been cubes threaded on a line. One stage can carry a swappable module, real fidelity, and behaviours drawn from the nature research, so the explosion of possibilities comes from growth rather than from grid size. It also turns the T4 ceiling from a wall into a doorway: T5 is the connector, and a connector only ever answers for one stage, which is what the AFAL engine already is with the world wrapper taken off.

D196

P067 Languages 23 Jul 2026

One slider moves 144 stages - AFAL's whole-world mutation scrub

AFAL Studio v0.2.9 in Blender 5.1.2: the Whole World toggle turns Mutation Strength into a single scrub over all 144 stages at once. Each stage travels from its own banked baseline along its own seeded direction, so the world deviates as 144 individuals rather than one move repeated 144 times, and 0.00 returns every stage exactly to as-generated. It arrived through a chain of Miles's rulings in one morning: Mutation Strength was a dead dial with no update callback, so the gene sliders never moved when he dragged it; rebuilt as a live deviation from a stored baseline, the Mutate Selected button was deleted as redundant, then widened to the whole world. Miles: "works really well and to see each stage changing is powerful!"

Why it mattered

It is the first thing AFAL has done that is GAAD-shaped rather than a Geometry Nodes engine that runs. Until now AFAL evolved one form at a time; a single slider now moves a whole population and the 12x12 grid reads as the 1994 genetic array rather than a tidy way to park 144 objects. It also closed a gap the language file had been carrying openly: mutation replay sat in section 16 as proposed, because the original mutation was unseeded, wrote over the stage in place and stored neither its deltas nor its seed, so no mutation could ever be reproduced. Banking a baseline and a stable seed per stage makes mutation deterministic in baseline, seed and strength, which is the same claim AFAL makes about form itself. The move mirrors ARAL's Mutation Scrub, now pointed at a parametric language instead of an emergent one.

D188D190

P066 Languages 22 Jul 2026

AFAL born and reaches T4 in a day - the first new language since ARAL

AFAL (Architectural Form) went from nothing to T4 Prototype runs in a single day: born from the ARAL split (D188), T1 research verified (D189), rules formalised and code-matched from the AFAL Studio v0.2.3 technical-truth pass (D190), promoted through the ladder to T4 (D191). A running Geometry Nodes engine building a 12x12/144 world of deterministic growth forms.

Why it mattered

AFAL occupies the space between traditional parametric modelling and AI-generated design: deterministic and parametric, form as a function of a parameter vector, distinct from ARAL's emergence. It asks not 'can you model this' but 'what growth behaviour could create this', which makes it a design-research instrument, not a geometry generator. As a defined GALF language it now has a stable identity from which future growth behaviours can evolve (F044) without changing what AFAL fundamentally is.

D188D189D190D191

P065 Platform 18 Jul 2026

The largest world GAAD has bred - 144 stages, the 1994 genetic array made whole

First 12x12 world bred live in Blender (addon v1_031, generator v1_002): 144 stages, 2,843 objects in PRAL and 3,744 in TWAL, in 1.8s. Miles proved it across languages and altitudes - the plan view reading as the multiplication table, a high perspective city, and a ground-level street at Generation 10 with the gold champion glowing among the towers.

Why it mattered

It is the three-dimensional realisation of the 1994 thesis genetic-array page at full scale, thirty-two years on - a grid of evolved phenotypes the thesis could only draw as circles on paper, now standing as a walkable city. The largest world the platform has ever bred, and the subject the film's Generate fly-past will fly.

D187

P064 Milestone 16 Jul 2026

Midtown East stands up - the first real block, measured not invented

The block bounded by E47 and E48 Streets between Lexington and Third Avenue was built in Blender from New York City's own open data: MapPLUTO for the tax lots, from the Department of City Planning, and Building Footprints for the outlines and their surveyed roof heights, from the Office of Technology and Innovation. Thirteen parcels, thirteen buildings, every one of them carrying a height the city had measured rather than a height GAAD had assumed, and a year of completion. Tallest 133 m, mean 51 m, built between 1910 and 2023. Nothing in the model was invented: every vertex is city survey data, the heights are height_roof - roof above the building's own ground, in feet - and where the city held no height the building was flagged and stubbed rather than guessed. Those figures are the block as first built, when membership was still decided by GAAD's calculated frame. The Upper West Side followed and broke that method the same evening: 216 parcels for a block the city says holds 90. Filtered to the city's own tax block 01211, it gives 90 lots and 47 buildings, all surveyed, spanning 1883 to 1982 - and its measured profile, tallest 33 m against a mean of 19, is the street wall the language file had already claimed for it in words.

Why it mattered

MHAL has always claimed that the 1811 grid persists while the parcels and buildings mutate on top of it. Until today that claim lived in a language file. It now stands in the viewport as thirteen buildings of one block, a hundred and thirteen years apart in age and eight times apart in height, on a grid drawn before any of them existed. The measured block also gives the invented one something to answer to: the prototype panel still reads buildings: massing only, heights assumed, and there is now a real distribution to test that against. The road there was a warning as much as a win. A file named building_footprints turned out to be a second copy of the MapPLUTO download, and because the study trusted the filename, every building silently became a ten metre stub - thirteen honest-looking slabs that were not buildings at all. It was caught only because the panel refused to report heights it did not have and printed the field names it actually found. Files are now identified by their own fields, never by their names. The same lesson as P063, one day later: the label is not the evidence.

D179D181D182

P063 Governance 15 Jul 2026

The 4.42 that was never there - the labels earn their keep in a single afternoon

Research returned from ChatGPT to fill FWAL's missing dimensions, and it was disciplined: no invented numbers, Priority A left honestly as Extractable and Unknown. On the strength of it Claude proposed correcting FWAL's cantilever from 4.57 m to 4.42 m, cited to Silman pages 90 and 91, and recommended it as a correction register entry. Miles asked one question: can you verify the six items from the web. The 4.42 collapsed. Three independent sources give 15 feet, which is 4.57. Fallingwater's own bibliography gives the article at pages 88-95, not 88-97. And the Silman PDF on fallingwater.org is a scan with no machine-readable text - so the page citations could not have been read from the article at all. The same day, a generated drawing sheet had printed a 1.07 m parapet (42 inches - a US guard-rail code height) where the real figure is 26 inches, and a file had arrived claiming a change it did not contain.

Why it mattered

Three plausible, specific, confidently-cited claims failed checking in one afternoon, and the only thing that stopped the wrong one entering the language file was a label: FWAL held 4.57 as Approximate rather than letting it harden, and Miles asked for verification rather than taking the seat's word. It also inverted the day's assumption about who needs checking - the failure was not in the research, which was honest, but in Claude's own recommendation built on top of it. The verification pass then found five real figures the research had missed, including the 12 ft bay module that moved FWAL from having measurements to having a grammar. Evidence discipline stopped being a principle and became a thing that paid, twice, in an afternoon.

D170D171

P062 Platform 14 Jul 2026

The scrub - a lineage moving under his hand, and 1994's Backtrack made interactive

Late in a long session, after the ARAL transport was rebuilt as a true tape, Miles dragged the Mutation Scrub slider and watched the evolution run backwards and forwards under his hand. His verdict, unprompted: the scrub is his favourite Rebirth feature built so far, with real potential for the platform. The design that made it work was his, not the AI's - offered a choice between a fixed recording (a real cassette) and a branching regenerate, he rejected both framings and supplied the rule that resolved them: a generation can only be shown if it has been generated, so playing at the end of the tape breeds, and playing over recorded tape replays.

Why it mattered

This is the 1994 Backtrack idea from the MSc thesis arriving as a live interaction rather than a described one - a stored lineage a designer can move along by hand. It also settles what F036 graduates into the platform: not the buttons but the playhead-over-stored-lineage model underneath, which is what the Navigator and Backtrack (F006) need. Worth noting the shape of the session that produced it: the same day Miles installed Claude Code to speed up the edit loop, rejected it as too slow for him, and then designed the platform's best interaction so far by talking it through.

D167, F036, F006

P061 Vision 14 Jul 2026

First real-time mutation run - evolution made visible

The Mutate xN button, built to explore an emergent clash Miles noticed under Harmony Rebirth, turned a hard-to-see moment into a watchable one. Running Mutate repeatedly at 0.1s gaps, Miles saw ARAL populations breed and resolve in real time - forms colliding and settling, the process itself visible rather than inferred from before/after states. It held even with Harmony Rebirth active, confirming the earlier 'clash' was emergent behaviour, not a fault. The moment closes a thirty-year loop: the 1994 thesis argued a designer plus cumulative selection could steer form; here that steering is finally watchable, live, in Blender. It came from following an oddity (the T024 non-bug) rather than dismissing it - the disobedience being the artwork again (Q036). The run also revealed the tape-deck transport as a genuine platform feature (F036).

Why it mattered

The thesis idea made watchable. For thirty years the argument was that a designer plus cumulative selection could steer form; this is the first time Miles could sit and watch that steering happen live, generation by generation, rather than inferring it from stills. It also shows the GAAD method working: an oddity followed honestly (a non-bug) became an explorer, which revealed emergence, which revealed a real platform feature (F036). Marks the point where ARAL stopped being a static generator and became a living evolutionary loop.

F035F036Q036Q038T024T026

P060 Vision 12 Jul 2026

ARAL's purpose found - reconnection, not imitation

A five-hour research session that began as a survey of ten computer artists (Latham, Mohr, Nake, Nees, Molnar, Reas, Davis, Lomas, Levin, Verostko) ended somewhere personal: the work Miles wanted ARAL to chase already existed in his own research history. The lineage runs unbroken - 1993, scaling and rotating a cube and discovering unexpected form; 1994, Digital Evolutions under Paul Coates (Computer Trees, Worm Trails, fractals, shape grammar, genetic algorithms); 2024, two Christmas weeks of Blender Python frame experiments, a cube subtracted from a cube so only the edges remain, animated into woven emergent structure; 2026, GAAD. ARAL will not be a catalogue of artists. It is a personal, curated experimental language of Language Seeds - selected artworks reduced to primitives, rules and parameters, then mutated and evolved as inherited process, never reproduction. Its reference case is Miles's own 1994 and 2024 work, the way FWAL's is Fallingwater - a first for GAAD, legitimate by total provenance. The session's foundational statement: Primitive, Transform, Repeat - and emergence begins. Banked in aral_research_journey_v0_002 (Spec/).

Why it mattered

ARAL's reference case is the Chief Architect's own thirty-year body of work - a first for GAAD, legitimate by total provenance. The language begins with reconnection, not imitation, and the Language Seed method (inherit the process, never reproduce the artwork) becomes ARAL's founding grammar.

D154

P059 GALF 11 Jul 2026

First three-seat GALF amendment - Honest Knowledge (s18) ratified

GALF grew from 17 to 18 sections. The Honest Knowledge principle - a language records not only what is known but how confidently and from where - was proposed by the Architecture Reviewer, proven in FWAL and MHAL, drafted as a formal proposal, and ratified by all three seats (Chief Architect, Specification Owner, Architecture Reviewer). The contract advanced through editions 0.006 (the amendment) and 0.007 (clarity), adopted as the baseline for all future Architectural Languages.

Why it mattered

GAAD's first contract change carried through the full D140 three-seat process end to end - the governance model working as designed. Honest Knowledge makes provenance and uncertainty first-class citizens of every GAAD language.

D152D140

P058 Platform 11 Jul 2026

FWAL v0.003 ratified - GALF describes architectural knowledge, not just geometry

FWAL v0.003 - the Falling Water Architectural Language, calibrated to Frank Lloyd Wright's Fallingwater - passed a full three-seat review and was ratified GALF v0.005 conformant. It carries no primitives and no geometry: its content is architectural knowledge - compression and release, prospect and refuge, site responsiveness, the ordered experience of approach and arrival. Where GRAL described a building and MHAL described urban structure, FWAL demonstrates GALF can describe the reasoning behind architecture itself. The Architecture Reviewer's verdict: the strongest Architectural Language produced in GAAD to date, with only enhancements, no corrections. This is the Living Library claim earning its first evidence.

Why it mattered

Broadens GALF's proven scope from geometry and hierarchy to design intent and knowledge - the case for GAAD as a Living Library of design languages rather than a set of generators. Ratified by all three D140 seats: Chief Architect (Miles Walker), Specification Owner (Claude), Architecture Reviewer (ChatGPT, APPROVED FOR GALF CONFORMANCE).

D140

P057 Platform 10 Jul 2026

TWAL is alive in GAAD - 24/24 Validate Scripts, full platform parity through the Connector

15:06, TWAL Development 0_021 stack (addon v0_101, generator v0_56, tree v0_20, connector v0.6): Validate Scripts with LANGUAGE=TWAL scores 24 steps, 0 failures - the same proving run PRAL passes. First Generation, three breeds, Backtrack arm/select/commit, breed from pivot into string 2, Navigator rebuild with discs and connector, all three Colour modes over 474 shared slots, replay, labels, Present Stage, Isolator. Miles's verdict: 'TWAL is alive in GAAD.' The morning's fail count ran 9 -> 6 -> 0 through five precise fixes: shared materials + stamps (T022 quick wins), the tree's .CEL branch, the arm's PRAL-shaped name regex (the ghost), and the double-offset containment bug.

Why it mattered

The GAAD Language Connector is no longer a proposal proven standalone (P055) or a first light (P056) - it is a language running the ENTIRE platform loop at parity with the native language, asserted by F030 rather than eyeballed. T021's gap is functionally closed. Every fix generalised the platform rather than special-casing TWAL: generation detection, materials, replay and the tree are now language-agnostic seams any future Connector language inherits free. Remaining on T022 before it closes: the Integrity checker (separate surface, ~42 fails), TWAL steps + language/GALF header in gaad_assert, then graduation records.

D144D146D147D148

P056 Platform 10 Jul 2026

TWAL runs through the GAAD platform - the Connector wiring works live

Same day as P055, Miles presses First Generation with LANGUAGE > TWAL on addon v0_100 / generator v0_51: nine TWAL skylines fill a 3x3 GAAD world (TWAL Development 0_014.blend). The first Architectural Language ever to run through the platform via the GAAD Language Connector - the gap T021 named ('languages can be defined but not run') closes on screen. PRAL was regenerated first on the same build, untouched - the do-no-harm guarantee proven before the new path ran.

Why it mattered

F033 phase 3 works at first light: panel radio to Connector to genome to skyline, with every stage file stamped TWAL and carrying its .CEL. What began this morning as three open three-seat decisions ended as a language breeding in the platform by afternoon. Remaining before T021 formally closes: Next Generation through the Connector proven live, the unwire test, and graduation records (fence lift, D144 repair, D031 revisit).

D144D146D147D148

P055 Platform 10 Jul 2026

First genome bred and built through the Connector in real Blender

Miles runs run_connector_in_blender.py v0.4 on his machine: a parent TWAL genome and a mutated child build side by side (parent at x=0, child at x=+200m), entirely through the Connector's pure path - random_genome, mutate, build via the BlenderAdapter. The report reads: parent valid True (32 towers), child valid True (30 towers), CEL round-trips True. Two skylines on screen; TWAL's first evolution, outside GAAD, with GAAD untouched.

Why it mattered

Phase 2 of F033 proven in the real engine, not just headless. Everything the wiring needs now demonstrably works: genome with the four design rules, rule-honest mutation via repair, pure build through a swappable adapter, and the D148 .CEL envelope round-tripping. The fence held throughout - the Connector was proven without a single GAAD file changing, which is the unwire guarantee shown in reverse. Only the wiring (phase 3) remains between TWAL and platform_status=active under D147.

D144D146D147D148

P054 Vision 09 Jul 2026

The browser dream - GAAD beyond Blender, renderer as a swappable adapter

Miles named a possible endpoint: 'Perhaps at some point we can ditch Blender and have GAAD in a browser with web access to ALs - this might be a dream. We only use say 5% of Blender, so perhaps a home-grown solution / desktop app could be the way to go in the future.' Raised while the neutrality of GALF (engine-free by s10) and the genome->phenotype connector design were fresh.

Why it mattered

Reframes GAAD's long-term shape and shows the architecture was already built for it. The genome->phenotype split (T021 connector) makes the renderer an ADAPTER: Blender is one adapter today, a three.js/WebGL or desktop renderer a peer adapter tomorrow, with the language files, records and GALF unchanged - a refactor of the bottom of the stack, not a rewrite. Three project-specific reasons it fits: open-source reach (a browser is one click vs a Blender install, and reach matters for a platform whose value is languages others write); licence untangle (Blender is GPL; a home-grown MIT/WebGL renderer removes Blender from the dependency graph entirely); and fidelity to 'decisions become data / the Design Memory Platform' (JSON memory replayable in any browser beats memory siloed in a .blend). Honest caution recorded: browser rendering of thousands of objects (instancing, culling, LOD) plus rebuilding the 5% of Blender actually used (viewport, selection, gizmos) is genuine work - so Blender stays the fast R&D harness now, and the browser move earns its keep as the feature set stabilises and public release nears. Design consequence: the connector interface should be specced so a non-Blender engine could satisfy it from day one, no Blender-shaped assumptions leaking into the port. Pre-public-release context: using Blender freely for development is fine; only the language files and GALF stay engine-free.

D144

P053 Design Language 09 Jul 2026

First coloured MHAL block with legend renders - GALF proven portable to a ringfenced standalone

The MHAL standalone (0_008) rendered its Manhattan block coloured by MHAL term - blue Building parcels rising off the charcoal Block, the gold Plot grid showing through, greens between the towers, street trees ringing the edge - with a standing 'MHAL objects' legend of coloured swatches beside it. Miles: 'This is looking great and I am pleased you have ownership of this now with a ringfence to GAAD (for now).'

Why it mattered

Two firsts in one shot. Visually, MHAL vocabulary now reads at a glance - each language term is its own colour, and Parcel is shown as its two realisations (Building / Landscape). Structurally, it demonstrates GALF as a portable contract: a Claude-owned standalone, ringfenced from the platform, still honours the language stamp, relationship triples, Scale axis and honest status - so GALF conformance is proven to hold outside GAAD, not just inside it. Provenance: uploaded 0_005c reworked to a bpy-free planner with cached-mesh fast geometry and a T006-safe clear, aligned to MHAL v0.003 / GALF v0.005, colour-by-term and legend added, versioned to 0_008. Recorded under D144.

D144

P052 Architecture 08 Jul 2026

The project changes direction - GRAL becomes the first GALF language

On agreeing GALF v0.003 across all three seats, Miles marked the shift: 'This feels like one of those moments where the project changes direction. GRAL is no longer just a prototype; it's the first Architectural Language built on the GALF contract. That simple decision gives GAAD a foundation for every language that follows.'

Why it mattered

GAAD stops being a platform with one built-in language and becomes a platform that hosts languages under a contract. Everything that follows - FWAL as acid test, MHAL's conformance, future languages - lands on the foundation set here. Same-day provenance: v0.002 concept, Specification Owner review with seven amendments stress-tested against real language files, Architecture Reviewer approval with four refinements, agreement, D140/D141 recorded.

D140D141

P051 Platform 08 Jul 2026

First clean proving run - Validate Scripts 18/18

15:21: Validate Scripts (F030) completed its first fully clean run - 18 steps, 0 failures - driving every real operator (Reset, First Generation, breeding, Backtrack arm/select/commit, breed from pivot, Navigator rebuild, three colour flips, Isolator) and validating each against its declared expected outcome. Miles: 'an object of beauty'.

Why it mattered

The definition of done now grows with the platform. On the way to clean, the proving run earned its keep three times: it caught the ghost-gold bug (Backtrack golding an invisible stale datablock, fixed v0.99.08), exposed T019 (stale lineage datablocks forcing .001 names), and surfaced the unselected-tip design question (a bred-but-unselected genome does not draw in the Navigator).

D135D133

P050 Milestone 07 Jul 2026

The genetic array reborn: multiple generative strings render in the Navigator, 32 years on

Runtime-confirmed by Miles at 14:12, Gen 15 on the panel, one build day after the thesis chapter reread: the Navigator (tree v0_8) draws the lineage array live - parallel vertical generative strings, rows aligned by generation depth, gold pivot connectors where strings branch, tips labelled honestly. The full Backtrack loop ran end to end for the first time: Backtrack in the Generator opened the Navigator (the Track decision point, D133); a stage selected there turned gold on commit and the world replayed that generation from its stage file with the historical champion gold (generator v0_47 - replay, never mutation, the 1994 contract); breeding from the backtracked position opened new strings with pivots recorded (D132). Miles's verdict, verbatim: 'WOW WOW WOW!'

Why it mattered

Thesis Fig 3.29 - the GAAD Genetic Array - exists again as a living, navigable 3D structure, 32 years after it was drawn, built in a single day of spec-first development (Lineage Spec v0.01 -> generator v0_46/v0_47 -> addon v0_92/v0_93/v0_94 -> tree v0_8, with T018 found and fixed by Miles's testing mid-day). Navigation and Tracking, the audit's 0-of-5 category and the Rebirth's biggest gap, is open. Backtrack was the classic-GAAD grammar verb the revival could not be faithful without (Q025); its storage is the load-bearing wall now in place (Q026); every stage an atom of the memory, preserved and replayed (Q024). The screenshot is Episode 4's proof shot. Remaining to close F006 fully: runtime polish from Miles's continued testing, F027 (Navigator gold champions / re-champion by selection, on hold), Forward Track, and the item-4 wrap-up (static check expectations, Rapid restore, validator lineage parity).

D132D133D030D110

P049 Milestone 06 Jul 2026

First public website built and the GAAD logo agreed

GAAD gets its first public-facing website and a settled logo in one session. The site (gaad_website.html, single self-contained file, responsive to mobile) tells the 1994-to-2026 story for digital science academics, students, BIM managers and the AEC industry: hero with an animated evolutionary lineage (the Draw Genetic Tree reborn as the site's signature), the History / Memory / Intelligence continuum, a mirrored 1994 vs 2026 story, the four-move platform (Generate / Evolve / Navigate / Record), live record counters, the three Architectural Languages with status pills (PRAL 'Rebirth - Classic GAAD', GRAL 'Built - Real Project', MHAL 'Design Language - GAAD at Scale'), three audience panels and a follow strip. The logo was settled through iteration: six data-generation alternatives were explored and rejected in favour of the original solid gold deltas, refined so the triangle bases sit exactly on the letter baseline at cap height; six underline lockups were then explored and option 03 chosen - a white rule with a centred gold node, trimmed to the exact width of the wordmark. Typography: Space Grotesk display, IBM Plex Sans body, IBM Plex Mono for record IDs so 'decisions become data' is visible in the type itself. UPDATE 06 Jul 2026 (same day): the site went LIVE. Miles deployed his first-ever website: 4bim.com/gaad serves the platform site with the full records browsable at /gaad/records/, a branded routing index at the 4bim.com root forwards visitors to /gaad/, and every record page's logo clicks back to the site. Deployment notes for the record: cPanel host, live path public_html/gaad, root router public_html/index.html; the host forbids a folder named 'temp' (test deployments should use another name). Q023 was logged the same day: three weeks of Rebirth surpassing three decades of dreams.

Why it mattered

GAAD steps from an internal build into a public identity. The agreed lockup (solid deltas, white rule, gold node) supersedes the gold-underline wording in the brand file, and the website becomes the brand's reference implementation. Remaining before publish: the real LinkedIn episodes URL and a genuine platform render for the story section.

D055

P048 Vision 03 Jul 2026

Rapid Stage Select works: selection becomes the breeding act

First live test of Rapid Stage Select (F022, addon v0_79): with the toggle on, clicking any object on a stage breeds the next generation from it immediately - Miles's click-click-click loop, running on the v0_39 generator at 0.3s per generation at 9x9 with ~6,000 objects. Miles's verdict on the day: the feature 'works v well and is super fast', and crucially it is 'not distracting - no looking away at the panel - it keeps the human engaged'. Pick and breed are one gesture; the eye never leaves the design. A robustness gap surfaced in the same session (rapid stopped firing after a Navigator visit or a platform reset - ticketed as T015), but the concept verdict was immediate: gold.

Why it mattered

This is the EVOLVE stance of the D110 grammar made real, and the moment the platform crossed from operating a tool to conducting an evolution. The 1994 thesis system rebuilt a generation slowly enough that selection and generation were necessarily separate acts; thirty-two years later the loop is faster than the click. Engagement - the human staying inside the design space rather than the interface - is the design payoff GAAD was rebuilt for.

D110D118D011

P047 Vision 02 Jul 2026

The platform finds its grammar: Evolve / Explore / Backtrack

In a single feedback session, one-click breeding (Rapid Evolution, F022), the pause-to-inspect rhythm, and Backtrack (F006) resolved into a three-verb grammar for the whole platform - Evolve, Explore, Backtrack: forward, still, back. Named by Miles ('Evolve / Explore / Backtrack (:-) (:-)') after his own usage narrative: click, click, click, click - pause - orbit, inspect - resume - click, click - Navigator - explore. The moment carries a thirty-two-year echo: with the fast geometry (D106) making generations build at the speed of clicking, Miles's verdict was that the 1994 system could never do this.

Why it mattered

The triad is the complete verb set of genetic design - nothing missing, nothing extra - and names something the 1994 thesis system never had: a stance toward the design space. It gives the panel its future organising principle (D110: the mode you are in at the top, everything arranged beneath), elevates Backtrack from convenience feature to core verb, and reframes selection itself: in Evolve, choosing IS breeding. It is the first time the platform's interaction model has been derived from observed working rhythm rather than designed from tool categories.

D110D106

P046 Vision 02 Jul 2026

GRAL is grounded in a real, completed, lived garden room project

Confirmed by Miles: GRAL (Garden Room) is grounded in a real, completed garden room project that Miles designed and constructed himself. It is built and in active use as a workspace for Miles and his wife. Every significant decision can be traced through design, construction and occupation - the project carries design intent, compromises, client feedback, neighbour discussions, construction experience, lived experience and post-occupancy reflection, evidence that extends well beyond geometry alone. Full source documentation (drawings, decisions, feedback) has not yet been logged into GAAD's records as structured data; this entry captures the confirmed narrative ahead of that detail arriving, so nothing rests only on chat history.

Why it mattered

This is what makes GRAL a genuine reference implementation rather than a demonstration model: every piece of knowledge it will encode has already been tested in the real world - designed, built, occupied and lived in - rather than assumed in theory. It raises the bar for what GRAL v0.01 needs to capture, and gives the project's success criteria (preserving architectural intent as geometry evolves, not just preserving geometry) a genuine, lived target rather than an abstract one.

P045 Governance 01 Jul 2026

The three-role model crystallises

The GAAD working team settled into three complementary roles: Miles Walker as Chief Architect ('Is this where GAAD should go?'), Claude as Specification Owner ('Is this internally consistent, technically correct and maintainable?'), and ChatGPT as Architecture Reviewer ('Does this strengthen the architecture, and what might it mean in the future?'). Captured as gaad_team_roles for the future governance section of the Charter.

Why it mattered

This names how GAAD is actually built - a human chief architect holding the vision, working with two AI collaborators in distinct but permeable roles. It establishes lightweight, evidence-driven governance with no formal boards: the discipline lives in the record-keeping, not in bureaucracy. None of the roles overlap completely, but all three contribute to every important decision.

D103

P044 Architecture 01 Jul 2026

The Design Language becomes GAAD's master architecture

Ownership of GAAD DL was handed to Claude, and the Design Language was established as the authoritative architectural model - a stable, JSON-defined data model that every Design Language (PAL, GRAL, MAL, HAL) inherits from, with the Blender Panel demoted to a view onto it. Issued as DL v0.03 for peer review, with GRAL set as the first reference implementation.

Why it mattered

This is the structural turning point that makes GAAD a platform rather than a single generator. Until now the panel and the design vocabulary were entangled; separating the Design Language (stable data model) from the Panel (view) and the Design Record (growing evidence) gives GAAD a clean three-part spine. It operationalises the platform-vs-language principle (D098) and the structured-knowledge direction (P043), and gives the deferred scoring work (D038) a defined home: Evaluation Criteria in the Language, Evaluation Results in the Record.

D102D098D038

P043 Direction 30 Jun 2026

Structured data capture becomes central to GAAD

GAAD will not begin by training an AI model. It will first capture structured design knowledge: generations, selections, rejected alternatives, reasons, parameters, context and outcomes. These records become language references for future learning.

Why it mattered

The intelligence of GAAD grows from accumulated design judgement, not from geometry alone. This reframes the Records system from project bookkeeping into the core substrate of GAAD's future intelligence: capturing not just what was built, but what was chosen, what was rejected, and why. It sets the sequence deliberately - structured knowledge first, learning later - and gives the deferred scoring work (D038) a clear foundation to build on.

D038

P042 Milestone 30 Jun 2026

The v1_0 panel spec and the leap to bundle 0_100

After many iterations and a critical architectural review, the GAAD panel was frozen as the v1_0 spec and built into the real addon (v0_63). To mark the significance, the bundle was advanced to GAAD Development 0_100, and a Technical Specification index was created to map the platform's technical truth across its existing records.

Why it mattered

This is the moment GAAD's interface stopped being a moving target. The seven-leaf Design Language contract is now a locked, generic foundation that any future Architectural Language (HAL, GRAL) plugs into without reshaping the panel. The jump to 0_100 deliberately separates the platform's mature phase from its rapid prototyping phase, and the Technical Specification gives the project a single map of record for the first time.

D100

P041 Philosophy 30 Jun 2026

The AL family: one grammar, many dialects

The naming of MAL (Manhattan Architectural Language), HAL (House Architectural Language) and GRAL (Garden Room Architectural Language) revealed that GAAD was never just about abstract primitives - it was building a grammar. Object Collection becomes the place where that grammar is selected: the same genetic engine, the same breeding logic, the same Records, expressed through different vocabularies of form. GAAD stops being a single design tool and becomes a platform for architectural languages.

Why it mattered

This reframes everything built so far as infrastructure rather than a finished product. The breeding engine, Records system, panel architecture, HUD and Layer 1 integrity check were all built generically enough to carry MAL, HAL and GRAL without rework - validating the architecture-first approach taken across the 0_44 to 0_51 releases. It also gives GAAD a long-term identity: not one design tool, but the platform underneath a family of them.

D098

P040 Architecture 29 Jun 2026

Lab and Studio: two faces of the same platform

The introduction of GAAD Studio alongside GAAD Lab crystallised a fundamental duality in the platform: Lab is where GAAD is built and tested; Studio is where GAAD is used as a design tool. One for the developer, one for the designer - both faces of the same platform, sharing the same engine underneath.

Why it mattered

This separation mirrors a principle found in mature creative tools - the distinction between author mode and audience mode. GAAD now has both. It also sets a precedent: Studio can evolve independently, showing only what a designer needs, while Lab remains the full development environment. The two panels reinforce that GAAD is no longer just a prototype - it is a platform with an intended audience beyond its creator.

D091

P039 Architecture 29 Jun 2026

The introduction of the Layer 1 static test harness

The introduction of a Layer 1 static test harness marks the first time GAAD can quality-check itself - validating bundle structure, addon integrity, panel labels, and HTML records in a single click, opening a branded test report directly from the GAAD Lab panel.

Why it mattered

GAAD now has a repeatable, automated quality gate. Every new bundle can be verified in seconds before use, catching regressions in structure, versioning, and UI labels. The test report itself follows GAAD brand style, making quality assurance a first-class part of the platform rather than a manual checklist.

P038 Philosophy 29 Jun 2026

The 0_44 Panel Architecture Release and the three-types-of-release principle

0_44 was declared a deliberate architecture release: no new algorithms or generation features, only better structure, terminology and information architecture (the GAAD Lab panel restructure, D090). It crystallised a working principle: every GAAD release should improve one of three things - capability (new features), architecture (better structure), or knowledge (better records, the Charter).

Why it mattered

Marks GAAD maturing from a feature-chasing prototype into a project that periodically stops to tidy its architecture, making the next wave of development easier. The three-types-of-release lens becomes a lightweight release-planning heuristic and a candidate Charter principle.

D090

P037 Milestone 28 Jun 2026

Panel redesign — Development Reports, Configuration, and 5×5 grid

The GAAD panel was redesigned in a single session: Records became Development Reports, the Reports section was removed, Design Evolution Report moved above Reset, scripts info became Configuration with a Last Full Release line, Allow Mutation became a quiet checkbox, grid labels were tidied, and a 5×5 grid (25 stages) was added. Release Notes were built as styled HTML and moved into Development Reports. The panel now has a clean hierarchy that separates actions (Generate, Reset, Explore) from reference material (Development Reports, Configuration).

Why it mattered

The panel has evolved from a prototype with scattered controls into a structured, professional interface. The reorganisation reflects the project's maturity — the distinction between what the user DOES (generate, explore, reset) and what the user READS (development reports, configuration) is now visually clear. Adding 5×5 pushes the grid to 25 stages — five times the 1994 capacity on a single screen.

D083D084D085D088

P036 Milestone 28 Jun 2026

4×4 grid populated — 16 stages breeding at Generation 5

The configurable Stage Size feature (D080, F011) was tested with a 4×4 grid — 16 stages breeding simultaneously, reaching Generation 5 successfully. Miles's reaction: 'I did not think this would be at all possible in 1994.' The original 1994 GAAD ran a 2×2 grid where each generation took approximately 5 minutes to compute. In Rebirth 2026, 16 stages populate in roughly 6 seconds — a 200× increase in throughput on a 4× larger grid.

Why it mattered

Demonstrates how far the platform has come from the 1994 thesis. The 2×2 Classic grid was the practical limit of 1994 hardware; seeing 16 stages evolve together in seconds is a concrete measure of what 32 years of computing progress delivers to the same genetic algorithm. Prompted the addition of a generation timer (D081) to formally record build times — closing the loop with the 1994 timer that clocked those 5-minute waits.

D080D081

P035 Milestone 27 Jun 2026

Mutation sliders go live — the user controls evolution in real time

Generator v0_26 wired the addon's Mutation panel sliders to the generator's mutation engine. All 9 tuning parameters (shape switch, width/depth, height, rotation drift, position X/Y, add/remove, min/max objects) are now read from scene properties at call time, with fallback to D077 defaults. The sliders are live at every generation, not just Gen 1. Each generation's JSON records the active mutation settings for full replay fidelity.

Why it mattered

This is the first time the user can directly control the genetic algorithm's behaviour from the UI — a core GAAD principle (decisions become data) made tangible. The mutation settings are no longer buried in code; they are visible, adjustable, and recorded.

D077

P034 Milestone 26 Jun 2026

First 1994 vs Rebirth feature audit — 19 of 41 original features covered

A full audit of the 1994 GAAD thesis features against Rebirth 2026 was conducted, prompted by concern about building new capabilities (stairs, buildings, garden rooms) on top of incomplete foundations. Of 41 original features across 7 categories: 19 are covered, 6 are partial, 16 are missing. The biggest gap is Navigation and Tracking (0 of 5 covered) — backtrack, forward track, right back, track decision point, and seed storage. These are the 4th dimension features that define GAAD as a design memory platform, not just a generator. Decision: consolidate the core 1994 feature set before expanding to new architectural generators. Priority order: seed storage (D030) → backtrack/forward track (F006) → global gene settings → isolate stage (F004) → orthogonal rotation (F005).

Why it mattered

Establishes a clear boundary: consolidate the 1994 core feature set before building new architectural generators. The audit document (gaad_1994_audit.md) is the reference.

D030D038D045D071

P033 Technical 25 Jun 2026

Double HUD traced to handler re-registration on addon reload

After installing updated addon versions, the HUD was drawing twice — two logos and two sets of text stacking on screen. Initially suspected to be two addon versions installed simultaneously, but the real cause was that Blender resets module-level variables (including _gaad_hud_handle) on addon reload without calling unregister(), so the 'if handle is None' guard failed and a second draw handler was registered on top of the still-active first one.

Why it mattered

Established the correct defensive pattern for Blender draw handlers: always call remove() before add(), never rely on a module-level variable surviving a reload. Also led to adding a non-GAAD scene guard so the HUD never appears in unrelated Blender files.

D064D066

P032 Vision 24 Jun 2026

GAAD becomes a brand - The Design Memory Platform

GAAD gained a complete, deliberate brand identity (folded in from the original chat; renumbered from its P026 to avoid clashing with this chat's P026 'reaching the limits of 1994'): the gold-delta logo, the Midnight/Gold/White core palette, the History->Memory->Intelligence timeline gradient, and the positioning as 'The Design Memory Platform'. Part of the moment is the principle that objects can be stripped of colour so attention falls on evolution and the decision, not decoration (logged as the open conflict D057).

Why it mattered

Marks GAAD crossing from a working tool into a positioned platform with a clear story: 'Where design history becomes design intelligence.' It reframes every future asset (logo, banner, Episode portraits, reports) and is to be rolled into the scripts in deliberate steps, always referring back to gaad_brand.md. Supersedes the green identity. Note the happy convergence with this chat's independent move to a gold champion (D042) and its render-ecosystem thinking (P031).

D055D056D057

P031 Vision 23 Jun 2026

GAAD as a render-ecosystem: one record substrate, many renderers (GAADBlender, GAADGraphviz, ...)

Building the Records-Tree in Graphviz made explicit that GAAD now has TWO renderers reading ONE set of records: GAADBlender renders 3D form, GAADGraphviz renders relationships in text and nodes. The naming shift - Blender as 'GAADBlender', one renderer among several rather than 'the project' - encodes the realisation. The data substrate is the constant; renderers are swappable and additive (P027). Once that is true, the question 'what else could read the records?' arises on its own, and a render-ecosystem appears rather than a single tool.

Why it mattered

Reframes the architecture of the whole project: GAAD is a clean record substrate (decisions, genomes, lineage, rationale) with multiple renderers that only READ it. The text/graph branch (GAADGraphviz) opens things 3D form cannot: (1) the architectural Genetic Array / tracking-tree (Fig 3.29) drawn properly with dead-ends and pivots - the natural home for backward/forward tracking UI (D045); (2) the genome shown as readable text beside its form - the recipe next to the cake (Fig 3.26/3.27); (3) generation diffs as narratable annotated edges; (4) the deepest one - a queryable graph of the design journey is exactly the substrate an AI could REASON over ('which mutations led to dead ends?'), turning the Episode-1 question 'could AI learn from the journey itself?' into something answerable. Likely the bridge from recording the journey to learning from it. Caution: this is a vision, not a sprint - the risk is sprawl (several half-built renderers); the protection is the same discipline as always - records stay the single source of truth, each renderer just reads them, so renderers become cheap to add. Captured as direction, to be built when chosen, not now (focus stays on GAADBlender).

D049D045D002

P030 Vision 23 Jun 2026

The loop closed - GAAD visualised itself

The Records-Tree rendered for the first time: 48 decisions as a vertical genetic spine, coloured by origin, with pivotal-moment blooms and gold supersedes-forks. For the first time the project's own evolutionary history was drawn by the project's own machinery - the same generate/select/record/replay idea, pointed at GAAD's development instead of architecture.

Why it mattered

The thesis-to-Rebirth arc reaches a self-referential milestone: 'decisions become data' is no longer a principle but a picture. P022 (this work is a GAAD tree), P027 (data-agnostic core) and P029 (records as a tree) become a single visible artefact. The 1994 Genetic Array (Fig 3.29) is realised on the project itself, and because it regenerates from the source of truth it is a permanently live infographic. Confirms the renderer-is-swappable thesis: Blender for 3D form, Graphviz for relationships, one data substrate.

D049D046D023

P029 Vision 23 Jun 2026

GAAD turned on itself - the project's own records as a live 3D/visual evolutionary tree

Proposed feeding GAAD's own development data (gaad_decisions.json, gaad_pivotal_moments.json, issues, terminology) into the evolution-tree machinery instead of architectural variants, to grow a branching tree where each node is a record - coloured by the category taxonomy, branching on related/supersedes links (e.g. D028->D042 as a pruned branch), Pivotal Moments as blooms, Issues as scars - that regenerates from the source of truth so it is never out of date: a 'live infographic', a self-portrait of the project drawn by the project. Raised the follow-on question of whether Blender is the right tool if nodes become text/cards rather than 3D forms, and whether an open-source node/graph/text tool would suit better.

Why it mattered

Closes the loop the project has circled since P022 ('this chat is a GAAD tree in text') and P027 (the core is data-agnostic): the same generate-select-record-replay engine, pointed at the project's OWN history, makes 'decisions become data' literally visible. Reframes the records folder as the real output and the tree as its portrait. Practically, it is largely reachable from the existing tree renderer (reads JSON, builds geometry, isolates scene, auto-frames) and is best unlocked by the shared geometry/diff module refactor - after which a 'Records Tree' (distinct from the Forward Evolution Tree) falls out cheaply. Also opens a genuine tool question: a text/node graph may be better served by a dedicated graph/diagram tool than by Blender.

D023D040D027

P028 Genome 23 Jun 2026

Primitives gain relational awareness - from isolated shapes to objects-in-context

Recognised that since Classic GAAD and Rebirth, a primitive has known only ITSELF - its shape and design parameters - with no awareness of what surrounds it. The step taken was to give objects relational knowledge of their stage neighbours: recording where objects on the same stage intersect (overlap in space). Framed deliberately as neutral 'object intersection' rather than 'clash', leaving open that an overlap may be intended (a future Boolean join).

Why it mattered

A shift in what a GAAD object IS: from an isolated form to a thing-in-context. It introduces the first notion of design quality intrinsic to the ARRANGEMENT, not just the silhouette - a different axis from the size metrics (area/volume/height). Intersection data is the natural feedstock for scoring (D038) and points toward genuinely architectural concerns (the BIM clash-detection problem named in the LinkedIn hook), while staying true to 'measure first, judge later'.

D043D038D015

P026 Vision 23 Jun 2026

Reaching the limits of the 1994 design - pressing forward with modern UX

With v0.19 the generator had faithfully reconstructed the 1994 thesis's world - typed genome, cumulative selection, replay, the genetic path - and the work hit the ceiling of what the original could offer visually. The look still read as 1994 (primary-saturated shapes, flat shading, the default grey void). The decision was taken to stop reconstructing and start pressing forward: give GAAD its own modern visual identity (desaturated palette with green reserved for the champion, an Eevee studio look with AO/soft shadows/bloom, a grounding plinth, a clearer title panel).

Why it mattered

Marks the hinge from faithful RECONSTRUCTION of the 1994 thesis to GAAD Rebirth as its own contemporary tool. The thesis is now the foundation that has been honoured and matched; from here the project advances beyond it rather than catching up to it - modern UX, and the road ahead (scoring, design memory, AI learning from design evolution) that the 1994 work could only point toward. 'We have reached the limits of 1994 and are pressing forward.'

D039D034D027

P025 Philosophy 22 Jun 2026

Reflection on development pace - why GAAD Rebirth has moved so fast

Stepped back to ask whether the rapid progress is typical. Concluded it is faster than usual, for concrete reasons: the 1994 thesis is a finished spec (little time lost to 'what are we building?'), the scope is a tight, well-bounded loop (generate, select, record, replay, report), and modern AI compresses what was weeks of 1994 scripting into minutes.

Why it mattered

A grounded read on the project's momentum, and a marker that the work so far has been the 'addition' phase - independent features that feel fast. The harder, slower stretches are still ahead: scoring (a design problem - deciding what 'good' means, P010), seed-based storage (D030, a cross-cutting architectural change), and scale (NxN worlds, performance). The disciplined decision/pivotal-moment record (now D001-D036, P001-P0xx) is itself an atypical strength: it let two weeks across two different AI tools merge into one continuous history without losing the thread.

D019D030D034

P024 Tooling 22 Jun 2026

GAAD becomes a smooth, usable tool - clean scenes and one-click workflow

With the add-on (P023) plus scene hygiene (D034) - data purging, an isolated tree scene, and auto-framed views - the generator and tree now switch cleanly with one-click buttons: the 3x3 world and the lineage each render correctly framed, with no manual Home/clip fixing and no data pile-up.

Why it mattered

GAAD crosses from 'working scripts' to a genuinely usable tool - fast to iterate, predictable, and pleasant to drive. Removing the friction (loading scripts, fixing the view, mounting data) is what makes longer evolutionary runs and, later, scoring and seed-based storage practical to actually use.

D034D033

P023 Tooling 22 Jun 2026

GAAD becomes a tool - the Blender add-on with its own interface

Bundled the generator, evolution tree and report into an installable Blender add-on with a 'GAAD' sidebar panel and one-click buttons (Next Generation, Build Tree, Write Report). It auto-detects the newest versioned script, so the workflow no longer means loading or pasting scripts each session.

Why it mattered

GAAD crosses from a set of loose scripts into an actual TOOL with its own interface inside Blender - a step closer to the original thesis's 'comprehensive graphical user interface'. Removes the friction that was slowing iteration, and makes GAAD something that can be handed to others, not just run by its author.

D033D031

P022 Vision 21 Jun 2026

GAAD beyond geometry - and this project as a GAAD lineage in text

Realised GAAD is fundamentally about recorded design lineage, with 3D geometry only the first medium; and that this very Claude project has been running as a GAAD tree in text - problem space, options, selected parents, decisions and pivotal moments as Design Memory. 'Doing GAAD to GAAD'.

Why it mattered

Generalises GAAD from an architectural form generator to a method for recording the design history of ANY industry (Architecture, BIM, Product, Urban, Education, AI). Reframes the long-term vision as a repository where humans and AI learn from HOW things were designed, not just what was designed - the gap the 1994 thesis identified ('How did the design come into existence?'), now reachable.

D016D027

P021 Scoring 21 Jun 2026

Summarised data opens the door to scoring generations

With the Evolution Summary deriving floor area, volume, shape mix and per-generation deltas from the replay data, it became clear these metrics are the raw material for scoring/fitness of generations - measuring designs, not just displaying them.

Why it mattered

Reframes GAAD's fitness model: in 1994 the user was the entire fitness function (visual selection). A derived score now runs ALONGSIDE human selection - GAAD measures and the designer still chooses. Because the score is computed from the recorded decisions and design data, scoring stays replayable and becomes data an AI could later learn the designer's preferences from. First concrete foothold on the Rebirth roadmap's 'decisions -> learning -> design intelligence' arc.

D025D016D023

P020 Visualisation 21 Jun 2026

Replay made physical - first Forward Evolution Tree reconstructed in 3D

The Forward Evolution Tree script (D015) ran successfully against a real 10-generation replay folder, reconstructing the selected-parent lineage as a vertical 3D column in Blender: nine stages, Gen 1 to Gen 9, each rebuilt from the recorded JSON with its chosen stage labelled, domes correctly uniform.

Why it mattered

The first time GAAD's recorded design history was not merely stored but reconstructed and walked through as navigable 3D form - the thesis 'genetic path' / replay concept (Figs 3.21/3.25/3.29) realised from saved decision data alone. Proves the decisions-as-data architecture round-trips: generate, select, record, and later rebuild the lineage from the records.

D023D016D005

P019 Philosophy 21 Jun 2026

Physical thesis recovered and title confirmed

The original 1994 thesis itself was located: cover confirms the title 'Digital Evolutions' by Miles Walker, with the back-cover abstract (Goldberg epigraph, Complexity from Simplicity, 3rd/4th-dimension exploration, Growth Generator, 'the penetration of one body with another').

Why it mattered

Pins the canonical thesis title and corroborates the project's origins from the primary artefact rather than from summary documents. Surfaced one open question: whether GAAD expands to 'Genetic' (as the thesis pages read) or 'Generic' (as the Rebirth summaries read).

D008

P018 Genome 21 Jun 2026

The thesis dome experiment reframed the dome fix

Reading Experiment 3.6A showed that the tall-spike-then-enveloping-dome trajectory was an intended, documented experimental result, not a bug. The original genome locked dome scaling to uniform XYZ; the Blender port's spindle was a port error.

Why it mattered

Changed the dome question from 'stop the bug' to 'restore the original genome', making the typed-genome rebuild (option a) the obvious path and superseding the earlier height-cap idea.

D017D018

P017 Vision 2026-06-week1