Contemporary 3D generative models — diffusion-based mesh synthesis [1], neural radiance fields [2], and SDF-based shape generation [3] — produce geometrically high-quality outputs but share a fundamental limitation for production use: their outputs are static triangle meshes or volumetric fields that cannot be re-parameterised without destructive editing. In the context of Maps bridge geometry, this limitation is operationally critical: bridge assets must be editable, versioned, and regeneratable from updated polyline surveys without repeating the full generative inference cycle.

We propose a different generative target. Rather than mapping input geometry to output geometry, we train a network to map input geometry to an executable construction program. This program, expressed in a formal DSL, encodes the structural intent of the bridge as an ordered sequence of human-readable commands. A deterministic executor converts the program to a USD scene at runtime. The resulting system produces outputs that: (i) can be inspected and edited without specialised 3D tools; (ii) can be re-executed with modified parameters to produce geometry variants; (iii) can be version-controlled as text alongside other production assets.

This paper makes the following contributions: (1) a transformer encoder–decoder architecture adapted for the polyline-to-DSL mapping problem; (2) a context-free DSL grammar over 24 terminal tokens sufficient to describe the full structural variation in Maps bridge data; (3) a dual-loss training curriculum combining reconstruction fidelity and geometric efficiency objectives; (4) an analysis of the non-differentiable executor gap — the primary open problem for all executor-based program synthesis approaches to 3D geometry generation; (5) the architectural template that all subsequent thesis projects extend.

Procedural modelling systems — CityEngine [4], Houdini procedural networks, shape grammars [5] — define geometry through parameterised rule grammars, enabling scalable urban content production but requiring manual rule authoring per asset category. ProcGen3D [6] explores learning grammar rules from image data using autoregressive edge-token prediction with MCTS-guided sampling, but addresses 2D graph structures. PGN extends to 3D USD scene graphs with continuous parameter prediction and semantic attribute conditioning.

ShapeAssembly [7] generates part-based shape assembly programs via a language model trained on a curated DSL. CSGNet [8] recovers constructive solid geometry programs from 3D shapes using imitation learning. Our approach differs in three respects: (1) the input is structured geometric data with semantic attributes rather than a shape category label; (2) the output DSL targets direct execution in Houdini production pipelines; (3) the grammar explicitly encodes Maps USD boundary attributes as first-class tokens enabling conditional generation.

Sparse voxel representations (FVDB [9]) provide Houdini-native integration and city-scale memory efficiency but do not support differentiable supervision. SDF-based representations [10] provide smooth gradient fields for geometry learning but are prohibitively expensive at urban scene scale. We use USD mesh with graph neural network supervision for per-component geometric loss, reserving VDB for production storage. This evaluation confirmed VDB as the optimal production format (assessed in §2, USD pipeline research, same month).

Let P = {p₁,...,pₙ}, pᵢ∈ℝ³ be a polyline with n vertices, and B = {b₁,...,bₘ}∈{CLOSED, OPEN, SEAM}ᵐ its corresponding boundary attribute sequence. The goal is to learn a mapping f:(P,B)→T={t₁,...,tₗ} where T is a sequence of DSL tokens drawn from vocabulary V, such that exec(T) produces a geometrically valid USD bridge scene consistent with the structural intent encoded in (P,B).

The PolylineEncoder E_P applies a standard Transformer encoder [11] with sinusoidal positional encoding to P, producing contextualised vertex representations h₁,...,hₙ∈ℝ⁵¹². A [CLS] token aggregates these into context vector c_P∈ℝ⁵¹². The AttributeEncoder E_B applies a smaller 3-layer transformer to B, producing c_B∈ℝ⁵¹². Cross-attention fusion F combines both: z = F(c_P, c_B)∈ℝ⁵¹².

The DSL Decoder D_T is a causal transformer that generates T autoregressively. At step t it attends over the encoder output and previously generated tokens t₁,...,tₜ₋₁ via cross-attention and causal self-attention respectively, predicting the next token from vocabulary V. The PerformanceEvaluator G:z→(ĉ,r̂) is a 3-layer MLP predicting primitive count ĉ and rendering cost r̂.

Reconstruction loss is token cross-entropy:

Performance loss penalises geometric redundancy:

Total loss with curriculum weight:

where c* is the ground-truth primitive count for the training bridge, E=25 epochs. The linear curriculum ensures structural correctness is learned (low λ early) before efficiency is optimised (higher λ late).

The DSL is a context-free grammar G=(V,Σ,R,S) where V={BRIDGE_PROGRAM, STMT_LIST, STMT, BOUNDARY_CLAUSE, PARAM} are non-terminals, Σ is the 24-token terminal alphabet, R are production rules, and S=BRIDGE_START is the start symbol. The grammar is deliberately minimal — spanning pedestrian bridges (~250 primitives) to major infrastructure (~7,000 primitives) with 24 terminal types. BOUNDARY_TYPE tokens are first-class grammar elements, enabling the decoder to learn attribute-conditioned branching (IF_BOUNDARY CLOSED → generate railings) without explicit rule injection.

A key design decision was making CONTINUITY_SEAM a first-class boundary type rather than treating it as a modifier. This allows the network to learn that seam boundaries produce continuity joints with adjacent bridge segments — a structural relationship that would be opaque if encoded as a parameter value.

The training corpus consists of 15 polyline–bridge USD pairs from Maps production data, spanning four structural categories: pedestrian bridges (n=4), highway overpasses (n=4), curved interchanges (n=4), and major infrastructure (n=3). Polyline lengths range from 39 to 263 vertices; bridge primitive counts from 250 to 10,420. No public benchmark exists for this task; evaluation is loss-based and execution-validated given the dataset scale constraint.

Training converges stably over 25 epochs. DSL reconstruction loss falls from 0.500 (epoch 1) to 0.097 (epoch 25). Total loss falls from 0.950 to 0.473. Performance loss falls from 8.12 to 3.75, indicating progressively more compact program generation. A representative test case — medium-complexity curved bridge (ground truth: 462 primitives) — executes with correct deck curvature, CLOSED-boundary railings, and 6 evenly-spaced pillars. The execution status from the training log confirms: Execution: SUCCESS – 462 polygons.

Two systematic failure modes are identified. First, BRIDGE_END omission on long sequences (>8 tokens): the model occasionally fails to predict the end delimiter, causing parser failure. Addressed by appending a forced end token at inference. Second, SET_DETAIL_LEVEL parameter values occasionally fall outside the valid continuous range [0,1], producing geometrically degenerate deck widths. Corrected with a clamping post-processor at inference time.

Both failure modes are consistent with known pathologies in autoregressive sequence generation: end-of-sequence prediction difficulty and continuous parameter out-of-distribution extrapolation. Both are mechanical problems rather than fundamental architectural failures.

The central open problem is executor non-differentiability. Because exec(T) is a deterministic interpreter, no gradient signal flows from the 3D geometry back through the executor to the decoder. End-to-end training with a direct 3D geometry loss — the natural objective for this task — is therefore impossible with the current architecture. Two mitigation directions are under investigation: (1) approximating exec as differentiable via nvdiffrast [12] rendering supervision; (2) using a Vector DB of program–geometry pairs as retrieval-augmented similarity signal at the token level. Neither approach fully closes the gap.

15 training pairs is insufficient for robust generalisation to unseen bridge topologies. The model memorises training examples rather than learning truly generalisable structural principles. Data augmentation via procedural variation — randomised parameter perturbation with re-execution — would increase effective dataset size while maintaining geometric validity. This extension is planned but not yet implemented.

PGN demonstrates the viability of training a transformer seq2seq architecture to generate executable procedural programs for 3D geometry construction from structured geometric input with semantic attributes. The dual-loss curriculum effectively balances reconstruction fidelity and geometric efficiency, converging to DSL loss 0.097 over 25 epochs. The DSL approach produces outputs with properties unavailable in direct mesh generation paradigms: human readability, parametric editability, and version-controllability as text.

The non-differentiable executor and small dataset scale are the primary barriers to scaling. Both are tractable engineering problems. The architectural pattern established here — geometric input → latent → construction program → 3D output — is extended in all subsequent thesis work: SketchProc3D replaces polylines with sketch input; graph grammar research explores automatic grammar extraction; SculptNet extends to coarse-to-fine primitive assembly; building elevation reconstruction applies the pattern at city scale with street-view image input and a 6-plane mesh reconstruction executor.