The Architecture

Five languages, one contract, one engine socket.

GAAD grows form inside an Architectural Language - a grammar of parts and rules. Five languages now exist. They all conform to one contract, GALF, and are driven through the platform by one engine-neutral socket: the Language Connector.

The stack

How the stack fits together

Read it top to bottom as a neutrality gradient. GALF names no engine. The languages are pure knowledge. The Connector names verbs, not vendors. Only the engine at the base knows it is Blender - and that engine is swappable.

Figure 1Two contracts · Five languages · One engine socket
The GAAD system architecture A vertical stack: GALF the engine-agnostic definition contract at the top, five architectural languages that conform to it, the Connector, the engine-neutral runtime contract, below them, and a swappable engine (Blender today, browser tomorrow) at the base. ENGINE-AGNOSTIC ENGINE-AWARE THE DEFINITION CONTRACT GALF GAAD ARCHITECTURAL LANGUAGE FRAMEWORK defines what a language IS - names no engine (s10). Every language conforms up to it. THE LANGUAGES - each conforms to GALF and carries a genome PRAL ACTIVE GRAL DORMANT FWAL DORMANT TWAL DORMANT MHAL DORMANT THE RUNTIME CONTRACT GAAD Language Connector eight verbs, never an engine (D146). describe · random_genome · build · mutate · breed · serialize · deserialize · validate THE SOCKET RenderAdapter: place_box · make_collection · clear THE ENGINE - swappable GAAD · Blender today · a browser or desktop application tomorrow

The seam is the point. Because the engine lives only in the bottom adapter, the same languages and the same records could one day run in a browser or another application entirely, instead of Blender - a change to the base of the stack, not the design above it.

The languages

Five architectural languages, one of them running

Each is an implementation that conforms to GALF. One, PRAL, is active in the platform today; the others are defined and awaiting the Connector. Status is shown honestly, straight from each language file.

PRAL

Primitives

Five geometric primitives, bred and combined. The language the GAAD Generator runs today, and where the 1994 engine lives on most directly.

Active · Runs today
GRAL

Garden Room

A language derived from a real garden room - designed, built and worked in daily. The test that GAAD's memory can hold a real building's design journey.

Built · Real project
FWAL

Fallingwater

The acid-test language: architectural composition and site response. Proved GALF can hold experiential, not just constructional, knowledge.

Acid test · Composition
TWAL

Tower

The smallest possible language - towers on a grid. Built to test one thing: whether GAAD can drive a language through world, stages and lineage.

Connector · Proof
MHAL

Manhattan

An urban-scale language: city, district, block, parcel, building. Density, massing and skyline as evolutionary material.

Design Language · At scale
The connector

Why a second contract exists

GALF - the definition

GALF says what a language IS: its terminology, hierarchy, relationships and resolution axis. By its own rule it names no renderer or engine - so it stays true whatever GAAD runs on. It cannot, therefore, own the runtime.

Connector - the runtime

The Language Connector is the socket GAAD uses to drive a language through Initial Generation, Breeding, the Navigator and Present Stage. It names verbs, never an engine - so it stays neutral by abstraction where GALF stays neutral by silence.

The shift that makes it work: a design stops being a random seed and becomes a genome - an explicit array of decisions. A seed cannot be bred; a genome can be mutated locally and recombined. Build is a pure function from genome to geometry, so a stage can always be replayed exactly as it was made.

Worked example

TWAL, from seed to skyline

TWAL is the smallest language - towers on a grid - built to prove the Connector. Here is the path every language will follow once connected.

Figure 2Seed → Genome → Phenotype
TWAL: seed to genome to phenotype A left to right flow. A seed rolls a genome - an explicit array of tower and landscape decisions. The pure build function turns the genome into geometry in a stage. Mutate and breed produce new child genomes, never editing the parent. Seed one number rolls GENOME - decisions, not pixels towers: [ {cell, footprint, height_class}, ... ] landscape: [ {cell, type} ] engine-free · serialisable (.CEL) build() pure PHENOTYPE - in a stage towers + landscape mutate / breed - new child genome, parent never edited (replay, never mutation)

The genome holds decisions - which cell, what footprint, which height class - not rendered pixels. Build computes the geometry; mutate and breed only ever produce a new child genome. The parent is never edited: replay, never mutation.

← Back to the platform