AFAL Language File

• Instance -> Spiral -> Rise -> Rotate -> Twist -> Taper ...and architectural form grows.
• Generate 3D architectural form as a deterministic function of a compact parameter set. Same parameters, same form. Parametric, not emergent.
• The current engine grows a spiral: instances placed along an index rule that climbs, rotates and twists, and tapers by compounding scale.

• Place an instance repeatedly along an index rule to build a growth form: a spiral of instances that climbs (rise), rotates and twists, and tapers (compounding growth).
• Every form must be reconstructable from its parameters - the form is the record of the operations that made it.

AFAL

Architectural Form, an AL (Architectural Language) on GALF. Named by Miles, 22 Jul 2026.

Form Language

GALF

GALF v0.008

prototype

unintegrated

GAAD's language for architectural form: 3D form built as a deterministic function of a compact parameter set - a growth spiral of instances that climbs, rotates, twists and tapers.

AFAL Spiral Species: a deterministic architectural aggregation formed by placing an instance repeatedly along an index rule. Its externally grounded core is upward progression with incremental rotation (the twisted-tower morphology, T1 sources 005-006); radius, local twist and compounding scale are AFAL's own extensions. Built twisted towers (Turning Torso, Cayan Tower) are precedents, not the whole reference; the natural 3D spiral (T1 source 004) is geometric inspiration, not a fitted model. The full six-parameter function is AFAL's own reference implementation - no consulted source carries the same formulation. Code-truth (v0.2.3): with non-zero rise the current path is a constant-radius circular helix, not a logarithmic spiral; 'Spiral' is the behaviour-family name, not the exact geometry.

Form Resolution (PROPOSED - AFAL's reading of GALF s17: how fully a form's growth structure is specified, from a single instance to a full arrayed and tapered spiral; not yet ratified).

AFAL is parametric, not emergent. Its phenotype is a deterministic function of a parameter vector - the same parameters always give the same form. Seeded stage selection and the mutate operator act outside the form function, so variety is chosen, not intrinsic. This is the line from ARAL, whose form arises from stochastic and compositional rules. Confirmed by T1 (pass 001): 'AFAL is emergent' is not supported by the current engine.

• AFAL, a Form Language on GALF. Role: 3D architectural form from a deterministic parametric growth rule.
• Distinct from ARAL: parametric build, not emergent surprise. Current behaviour is a growth spiral.

• Instance -> Spiral -> Stage -> World (12x12, 144 stages).
• One index rule places Count instances into a spiral; a stage holds one spiral; the world holds the grid of stages.

Six triples, all GALF v0.008 base types (assembles_into, uses, defines, controls). The v0.001 'reflects' declared type was removed with the mirror grammar - mirror is not implemented in the engine.

AFAL Studio v0.2.3, verified line-by-line against source by the Specification Owner, 22 Jul 2026.

Mode ranges are risk-reduced GENERATION ranges, not validated architectural safe domains. Manual UI edits allow the full hard domain. No end-scale or bounding warning exists in code.

AFAL_SHARED_ENGINE_v0_2 (implemented)

AFAL_SPIRAL_INSTANCE_GROWTH (proposed name; not written in code)

cube, size (2,2,2) (implemented)

• path_angle_i = i*(rotate+twist)
• position_i = (radius*cos(path_angle_i), radius*sin(path_angle_i), i*rise)
• orientation_i = (0, 0, i*rotate)
• uniform_scale_i = growth^i
• place cube i at position_i, rotation orientation_i, scale (uniform_scale_i x3)

• Instance 0 sits at (radius,0,0), rotation (0,0,0), scale (1,1,1).
• Radius constant, rise linear, scale exponential.
• Rotate and twist jointly set the path angle; only rotate sets local orientation.
• With non-zero rise the path is a constant-radius circular helix, not a logarithmic spiral.

Index-based instance placement via GeometryNodeInstanceOnPoints on a mesh line. Verified against AFAL Studio v0.2.3. No array, offset or mirror operations; mirror is not implemented.

• Each form is a deterministic function of its six genes (count, radius, rise, rotate, twist, growth). Same genes, same phenotype; the form carries no randomness.
• Placement, orientation and scale of instance i follow the s8 rule.
• Population: each Stage's genes are drawn from the mode ranges by a seeded generator, seed = 30000 + stage_number + mode_offset (Calm 0, Wild 1000, Extreme 2000). Reproducible, but the seed is implicit and hard-coded, not written as data.
• Mutation (afal.mutate_stage): additive per gene, every gene each time, deltas independent (no correlation), clamped to mode ranges (rise to +/-5). Strength 0.0-1.0, default 0.35. The generator is unseeded (Random(randint(1,99999999))), it overwrites the selected Stage in place, does not preserve the parent, and stores neither seed nor deltas - so a mutation is NOT replayable.

• count_span = max(1, int((count_max-count_min)*0.15*strength)); new_count = clamp(old + randint(-span,+span), mode)
• new_radius = clamp(old + U(-1,1)*radius_span*0.15*strength, mode)
• new_growth = clamp(old + U(-1,1)*growth_span*0.08*strength, mode)
• new_rotate = clamp(old + radians(U(-90,90)*strength), mode)
• new_rise = clamp(old + U(-0.25,0.25)*strength, -5, 5)
• new_twist = clamp(old + radians(U(-90,90)*strength), mode)

Implemented rules, verified against AFAL Studio v0.2.3. Invalid-combination handling is per-gene bounds only: no cross-gene, end-scale, bounding-box, self-intersection, legibility or architectural check; no mutation is rejected.

• Parametric systems can restrict exploration if the representation, topology or parameter structure is too narrow (T1 source 002).
• Real architectural use adds structural, floor-planning, facade and alignment problems AFAL does not resolve (T1 source 005).
• The six-parameter spiral sits in the twisted-tower family that digital tools made ubiquitous; without broader behaviours AFAL risks becoming a twisted-tower generator (T1 sources 005-006).
• Full reproducibility needs seed, sampling ranges, stage order and the mutation operation recorded, not just the six parameters (T1 still_unknown).
• Compounding is unguarded in code: end_scale = growth^(count-1) can escalate (Extreme reaches ~12x or near zero) with no warning, overlap check or envelope test (v0.2.3).

T1 research pass 001, delivered by the Architecture Reviewer seat, 22 Jul 2026. Verification bar (P063): real reading, not plausible citation. All six sources read at relevant-sections depth.

• knowledge_status: prototype. platform_status: unintegrated.
• Readiness T4 Prototype runs. Climbed in order: T1 verified (D189), T2 rules formed and code-matched (D190), T3 Language agreed (Chief Architect's ruling on three-seat convergence, D191), T4 the standalone AFAL Studio v0.2.3 generates in Blender.
• T4 is the ceiling until AFAL has its own connector (T5) and runs through GAAD past the release gate (T6-T7). The prototype is standalone and unintegrated.

• AFAL validates per GALF: s3.1 section conformance (this file, all 18 sections present), identity axes on the mandatory vocabularies, and s6 triples against base union declared types.
• Runtime validation (F030 Validate Scripts) applies once the prototype is banked and integrated (T4 onward).

• AFAL preserves the operations that made each form: the six parameters, plus the seed, sampling ranges, stage order and any mutation, so a form is reconstructable, not just its geometry.
• The reasoning is the record. Design Memory, not baked mesh.

• v0.001, 22 Jul 2026: AFAL created, form split out of ARAL. D188.
• v0.002, 22 Jul 2026: T1 research ingested (pass 001, six sources). Grammar reconciled from the filed array/offset/mirror to the real AFAL Studio engine (index-based spiral: radius, rise, rotate, twist, compounding growth). reference_case grounded as the AFAL Spiral Species; Constraints and Implementation moved from unknown to present. Rung stays T2, now with T1 verified. D189.
• v0.003, 22 Jul 2026: rules formalised from the AFAL Technical Rules Package (technical-truth pass 001, anchored to AFAL Studio v0.2.3). Every claim verified against source before filing. s7/s8/s9 now carry the exact per-gene formulas, the whole growth rule, the seed and the mutation model; implemented filed as rule, proposed kept separate in s16. Several s18 unknowns resolved. D190.
• v0.004, 22 Jul 2026: readiness raised T2 -> T4 (D191). Name reaffirmed AFAL; the ALAL / 'Artificial Life' rename was considered and dropped. T4 is the ceiling pending a connector and GAAD integration.

• Prototype: AFAL Studio v0.2.3 (Architecture Reviewer seat), Blender 5.1 Geometry Nodes, 12x12/144 world, Calm/Wild/Extreme modes, materials, lights, cameras, native panel. Runs (T4-class evidence), sits ahead of the rung. Correctly written for 5.x. Hygiene: panel label still reads v0.2.2 while bl_info reads v0.2.3.
• IMPLEMENTED (filed as rule in s7-s9): the six genes and exact formulas; constant radius, linear rise, exponential uniform scale; combined rotate+twist path angle; rotate-only local orientation; seeded deterministic initial populations; additive independent in-place mutation; mode ranges, clamps and version declarations.
• PROPOSED (intended, NOT in code, not filed as rule): portable JSON source of truth; formal behaviour id/version; mutation replay and parent preservation; child Species and generation increments; cross-gene validity and count-aware growth bounds; warnings (end-scale, overlap, envelope); genuine path torsion, genuine local-axis twist, radial growth; version fields written at World creation.

• Form Resolution (PROPOSED): how fully a form's growth structure is specified, from a single instance to a full arrayed and tapered spiral.
• Not yet ratified across the three seats.

• AFAL is parametric - geometry depends explicitly on parameters (S001).
• A compact parameter vector validly describes a family of forms, not one object (S001).
• Deterministic computational growth is an established category, not inherently stochastic or emergent (S003).
• AFAL's design-exploration purpose is supported, and it is a computational method, not a style (S002).
• Repetition plus vertical progression plus incremental rotation is an established architectural operation (S005, corroborated S006).
• The natural 3D spiral as geometric inspiration is defensible without copying the object (S004).
• Exact per-gene formulas (v0.2.3): position i*(rotate+twist) on a radius circle at height i*rise; orientation (0,0,i*rotate); scale growth^i.
• Growth is exponential UNIFORM instance scale only (not radial, rise or path growth).
• Twist is an additional PATH-ANGLE increment only (not local-axis rotation, not torsion); its UI label is 'Spiral'.
• Rotate has two roles: path-angle contribution and local Z rotation.
• Population seeding: seed = 30000 + stage + mode_offset, reproducible but implicit and hard-coded.
• Mutation is additive, independent per gene, clamped, unseeded, in-place; the parent is not preserved and it is not replayable.

• 'AFAL reproduces natural spiral growth' - inspired, not fitted to shell/horn/plant data (S004).
• 'AFAL is emergent' - the phenotype is traceable to explicit parameters; seed and mutate act outside the form function.
• 'AFAL is an L-system' - lineage only; the engine does indexed placement, not symbolic rewriting (S003).
• 'The helix is itself an architectural language' - one morphology within a parametric language (S002).
• 'Twisted form is intrinsically innovative' - method is not style, and digital tools made the family ubiquitous (S002, S005-006).
• 'Nature follows one universal spiral rule' - curvature and torsion vary independently (S004).

• Whether the engine is one spiral behaviour or a general parametric-growth framework (Chief Architect's call).
• Safe parameter domains that stay legible as architecture.
• How AFAL evaluates architectural value (use, circulation, structure, enclosure, daylight, fabrication).
• Whether six dimensions give enough diversity to avoid a twisted-tower monoculture.
• The historical claim that twisted towers became a 2010s fad because Rhino/Grasshopper/Revit made them easy.
• A source-grounded taxonomy of AFAL's future growth behaviours beyond the spiral.

• The current path is a constant-radius circular helix, not a logarithmic spiral.
• Mutation overwrites the selected parent in place and cannot be replayed (seed and deltas are not stored).
• The initial Stage seed is implicit and hard-coded, not written as source-of-truth data.

• Portable JSON replay and a formal behaviour id/version.
• Parent preservation, child Species, generation increments, mutation replay.
• Cross-gene validity checks and count-aware growth bounds.
• Warnings for end-scale, Stage overlap and World-envelope exceedance.
• Genuine path torsion, genuine local-axis twist, radial growth.
• Version fields (Studio/engine/behaviour/schema/Blender/Python) written at World creation.