WorksComputer Science
Visual-to-Executable Procedural Reconstruction of Buildings
Abstract
Procedural modeling offers compact, editable, and reusable representations for architectural content, but building such models still depends heavily on manually authored grammars. We study image-based procedural building reconstruction from in-the-wild images, with the goal of recovering an executable procedural description that can be instantiated as an editable 3D building asset. Because a single image provides only partial and view-dependent evidence, we focus on recovering the dominant visible facade(s) and attach the recovered facade program to a simple mass model for building-level instantiation. Our method decomposes this task into two structured prediction stages. First, a Global Structure Layout Tree recovers facade-scale split-and-repeat organization through a fine-tuned layout model with render-guided visual-symbolic reflection. Second, a Component Parameterization schema maps representative facade tiles to structured procedural attributes for local architectural component synthesis. These two representations are then deterministically compiled into executable Computer Generated Architecture (CGA) programs, avoiding the brittleness of direct low-level program generation. Experiments show that the proposed framework handles both regular facades and challenging in-the-wild images, while maintaining high structural consistency, procedural executability, and fine-grained architectural detail. The recovered programs further enable controllable and reusable 3D building asset generation.
Introduction
Procedural modeling is a compelling paradigm for architectural content creation. Buildings are naturally composed of repeated elements, hierarchical subdivisions, and parameterized components, making procedural descriptions particularly well-suited to their structure [20, 12]. Compared with explicit geometry or purely neural representations [11, 7, 16], procedural descriptions are compact, editable, and reusable, making them attractive for scalable and controllable 3D building asset generation. Yet, constructing such models still largely depends on manually authored grammars and domain expertise, which severely limits their practical scalability.
In this paper, we study image-based procedural building reconstruction from an in-the-wild image. Our goal is to recover an executable and editable procedural description that can be instantiated as a 3D building asset. Since a single image provides only partial and view-dependent evidence, we focus on the dominant visible facade(s) and treat the recovered program as a procedural interface for controllable building asset generation, while unseen geometry is instantiated using simple procedural completion rules.1
Existing approaches only partially address this goal. Facade parsing methods recover semantic labels or dense structural cues, but do not produce editable or executable procedural programs. Classical inverse procedural modeling methods exploit architectural regularity, but typically assume rectified views, segmented layouts, or predefined grammar families. More recently, learning-based and LLM/VLM-based approaches suggest the possibility of image-to-program prediction, yet direct low-level program generation remains brittle because valid procedural programs are non-unique, tightly constrained by grammar validity, and hard to verify during prediction.
Our key observation is that the difficulty of this problem lies not only in generating code, but in bridging ambiguous visual evidence and execution-constrained procedural representations. The same building facade may admit multiple valid procedural decompositions with no single correct answer, while in-the-wild images further introduce perspective distortion, occlusion, and partial visibility, making it difficult to infer a clean orthogonal split-and-repeat scaffold directly from raw RGB evidence. We therefore avoid direct low-level image-to-code generation and instead cast the problem as verifiable image-to-structure and image-to-attributes prediction, followed by deterministic compilation into executable programs.
This formulation raises four coupled challenges. First, facade-scale organization is hierarchical and non-unique: the same facade may admit different split orders, repeat abstractions, or grouping strategies, making direct supervision on a single low-level program unstable. Second, in-the-wild images provide incomplete and view-distorted observations: perspective effects, occlusion, illumination variation, and partial visibility make it difficult to infer a clean orthogonal split-and-repeat scaffold from a non-rectified image. Third, local architectural elements such as windows, entrances, arches, sills, stairs, and hardware must be recovered as procedural parameters rather than merely detected as visual instances. Fourth, the recovered global scaffold and local components must be compositionally compatible and directly executable. A visually plausible output is insufficient if it violates grammar constraints or cannot be compiled.
To address these challenges, we propose a hierarchical neuro-symbolic framework with two structured intermediate representations. At the global level, we recover a Global Structure Layout Tree that captures facade-scale split-and-repeat organization and is iteratively refined through a render-guided visual-symbolic reflection process, making structural mismatches easier to identify and correct than direct symbolic comparison would allow. At the local level, we recover a Component Parameterization for representative repeated elements, mapping tile crops to structured attributes rather than raw procedural code. This design turns under-specified local geometry into a constrained and verifiable prediction problem.
The two levels are then assembled by deterministic compilers into executable CGA programs, producing a procedural building representation that is both editable and directly instantiable as a 3D asset. By separating global structural reasoning, local procedural grounding, and deterministic execution, our framework improves verifiability, robustness, and executability over direct low-level code generation.
Our contributions are threefold:
We formulate in-the-wild image-based procedural building reconstruction as a two-level neuro-symbolic prediction problem and introduce a representation bridge consisting of a Global Structure Layout Tree and a Component Parameterization schema.
We develop a render-guided visual feedback and symbolic repair mechanism for recovering global facade structure from incomplete and non-rectified observations.
We develop a component-level inverse parameterization and deterministic compilation pipeline that assembles the recovered structure and local components into executable CGA programs for procedural 3D building asset generation.
Related Work
Procedural and inverse procedural modeling for architecture. In architectural reconstruction, procedural models instantiate executable structured programs that encode geometry through editable and executable symbolic rules. Classical grammar-based systems, such as Instant Architecture and CGA shape grammar, demonstrate the effectiveness of rule-based representations for buildings and urban scenes [20, 12]. Inverse procedural modeling studies the reverse problem of recovering procedural structures and parameters from observations. The single-image building modeling system of Nishida et al. [2018] is closely related to our overall goal, as it recovers building mass, facade grammar, and window/door grammars from an image with a user-provided silhouette. Facade-level methods recover procedural facade definitions from rectified or segmented structures [13, 9, 17, 21], with FaçAID [15] learning a transformer-based mapping from segmented facades to procedural definitions. In our framework, such facade layout analysis corresponds mainly to the global structure recovery stage; we further ground repeated local tiles into procedural parameterization and assemble both levels into executable CGA programs from in-the-wild RGB images.
Visual program synthesis and neuro-symbolic reconstruction. More broadly, our task is related to visual program synthesis, where executable symbolic programs are inferred from visual observations. Early inverse-graphics systems such as SPIRAL [3] show that programs executed by a graphics engine can serve as structured image representations. Recent neuro-symbolic and program-based methods further extend this idea to 3D shape structures, CAD command sequences, and architectural abstractions, using domain-specific languages or program tokens as compact output spaces [6, 22, 5]. Language-model-based inverse graphics methods such as IG-LLM [10] also suggest that structured scene code can be predicted from visual embeddings. These works show the benefit of moving visual reconstruction into executable program spaces, but direct full-program generation remains brittle when the output is non-unique, low-resource, and constrained by executability. Our method instantiates this direction for procedural facade reconstruction by predicting structured hierarchical neuro-symbolic representations that can be deterministically compiled into CGA programs.
Iterative visual reasoning and symbolic repair. Recent multimodal systems increasingly use intermediate visual evidence, tool invocation, or render-and-inspect loops to improve structured prediction. ICoT [4] shows that inserting visual intermediates can strengthen fine-grained visual grounding beyond text-only rationales, while agentic systems such as GeoVista [19] integrate visual tools into multi-turn reasoning loops. Most closely related to our work, VIGA [23] performs inverse graphics through a code-render-inspect loop, where rendered outputs provide visual evidence for subsequent symbolic edits. Our reflection stage adopts this principle for facade layout repair: the current Global Structure Layout Tree is rendered into a schematic layout, compared with RGB–mask evidence, and revised as CGA-compatible YAML under architectural priors.
Method
Overview and problem formulation. Given an in-the-wild building image, our goal is to recover an executable procedural facade representation for building asset generation. Since a single image provides only partial and view-dependent evidence of a building, we focus on recovering procedural facade descriptions for the dominant visible facade(s), which can then be attached to the corresponding faces of a simple mass model to instantiate an editable procedural building asset.
This formulation separates facade recovery from mass instantiation. The recoverable content from the image is the procedural structure and component configuration of visible facade regions, while the building asset is obtained by assigning the recovered facade programs to the corresponding sides of a default rectangular mass model. For unobserved sides, we use procedural completion rules or reuse recovered facade rules for visualization and downstream editing.
Following a coarse-to-fine architectural modeling strategy, we adopt a hierarchical two-level formulation. The first level recovers a facade-scale symbolic layout that captures the dominant organization of the facade and identifies representative tile regions. The second level takes these representative tiles as input and estimates tile-specific procedural parameters for component synthesis. The final executable program is obtained by deterministic assembly: the recovered structure layout is compiled into a global procedural scaffold, and the predicted tile-level codes are translated into executable component rules and inserted into the corresponding layout positions.
This decomposition is motivated by the ambiguity of direct image-to-code generation. Instead of asking a model to predict low-level procedural code in a single step, we cast the task as two more verifiable prediction problems: image-to-structure prediction and image-to-component-attributes prediction. By constraining neural prediction to structured intermediate representations and reserving executability for deterministic compilation, the framework provides a more stable bridge between image observations and procedural building modeling.

Figure 1. Overview of our hierarchical neuro-symbolic framework. The method decomposes facade reconstruction into a first level for symbolic layout recovery and a second level for tile procedural synthesis. The final CGA program is obtained by deterministic assembly of the global scaffold and the compiled tile components.

Figure 2. Overview of global structure layout recovery via visual-symbolic reflection. A fine-tuned Qwen-VL-7B model first induces an initial symbolic draft , including a tile set and a structure layout tree. The draft is then iteratively refined through a reflection loop driven by rendered schematics and RGB–mask overlay evidence, producing the final global structure layout output.
Global building structure reasoning. The goal of this stage is to recover a Global Structure Layout Tree from the input image. is a rooted 2D hierarchy over the dominant facade plane. Here, the layout refers to a facade structural arrangement of floors and openings and other repeated tiles. It uses split and repeat operators to organize the layout, with parameters such as span, spacing, and axis direction specifying the normalized positions and extents of tile regions. This representation provides the global scaffold for downstream CGA generation. Detailed schema definitions are provided in Appendix B.1.
Given an input image , we first localize the dominant facade support, extract the most relevant facade crop , and use SAM3 [1] to generate its corresponding mask for downstream recovery. The global structure recovery module is instantiated with a fine-tuned Qwen-VL-7B model used in two instruction modes: layout induction and visual-symbolic reflection. The model is trained through a two-stage supervised fine-tuning procedure: initial layout induction followed by joint induction and refinement training. Detailed training data construction and refinement trajectory generation are provided in Appendix D.
In the induction mode, the model constructs an initial symbolic draft of the using a bottom-up, tile-first strategy,
The resulting draft usually captures a plausible facade topology, but its spatial parameters and local boundaries may still be coarsely aligned with the image evidence.
To refine the draft, we introduce a render-guided visual feedback and symbolic repair mechanism implemented through an iterative reflection loop. Since the same facade may admit multiple valid YAML descriptions, direct comparison in the symbolic space is unreliable. We therefore render the current symbolic draft into a schematic layout and use the facade image together with segmentation-derived evidence as a weak visual reference for iterative symbolic revision. Specifically, we construct an overlay evidence map
which combines the facade crop with its corresponding SAM3 mask. At iteration , the current symbolic draft is rendered into a schematic layout image
where is a deterministic renderer and denotes the rendered visualization of the current layout draft. Here, corresponds to the initial layout draft before reflection. In the reflection mode, the same fine-tuned Qwen-VL-7B model receives and rewrites the current YAML draft into a revised symbolic program. This render-and-compare design makes the mismatch between the current layout and the visual evidence easier to identify and correct.
The reflection process is guided by soft architectural priors on structural regularity, semantic plausibility, and grammar validity, so that the recovered layout remains visually plausible and compilable. The loop terminates when sufficient agreement is reached or when a small fixed iteration budget is exhausted; in our implementation, we use . The final output of this stage consists of a refined and a representative tile set derived from its leaf-level structure. The tree serves as the facade-scale scaffold for downstream procedural synthesis, while the tile set provides the local supports for tile-level procedural parameterization.
Component-Level Inverse Parameterization. After obtaining the global hierarchical tree of the building, we recover procedural descriptions for architectural components at the tile level. Each unique component is represented as a unified YAML-based set of procedural attributes. Instead of predicting raw CGA grammar, the model infers a constrained component-level parameterization defined by explicit architectural attributes (e.g., arch presence, row/column counts, and structural elements), which are sufficient for component synthesis. Detailed schema definitions are provided in Appendix § 8.§ 2. This representation serves as a spatial anchor for prediction, reducing ambiguity in component position and scale, while remaining CGA-compatible and casting under-specified local geometry as a structured parameterization problem.
Given , we treat its leaf nodes as structural placeholders. The leaf-level layout provides a facade-scale estimate of component positions, while SAM3-derived local masks provide pixel-level evidence about component extents. By combining these two cues, we obtain representative tile supports for component parameterization.
Each grounded tile crop is encoded by a dual-stream visual backbone: a CLIP stream provides high-level semantic and stylistic cues, while a DINOv3 stream captures localized structural and geometric details. The fused visual features are projected into a shared decoder space and combined with language tokens for autoregressive generation of the component parameterization. A detailed architecture visualization is provided in Appendix § 10.§ 1.
Deterministic procedural assembly and instantiation. We adopt a CGA-style procedural construction paradigm following classical shape-grammar-based building modeling [[20, 12, 13]], where production rules progressively refine building scopes from coarse facade regions to repeated tiles and local architectural details. In our implementation, the custom-designed compiler translates the global structure layout tree into a CGA-compatible facade scaffold, and converts each component parameterization into a reusable component rule.
After compilation, the recovered facade program can be attached to a building mass model to instantiate an editable 3D building asset in a procedural modeling engine. When multiple facades are visible in the input image, each recovered facade program can be assigned to the corresponding side of the mass model. For unobserved sides, we use simple procedural completion rules or reuse the recovered facade grammar for visualization and downstream editing. A simplified CGA-style pseudo-code example of this deterministic compilation and instantiation process is provided in Appendix § 8.§ 3.
Experiments
Experimental Results
End-to-end Result Showcase. We first present representative end-to-end reconstruction results of the full framework. Given an in-the-wild building image, our method recovers a global structure layout scaffold and synthesizes tile-level procedural components, which are then deterministically assembled into an executable CGA program. The resulting representation can be rendered as a reconstructed procedural facade and further instantiated as a simple editable 3D building asset.
Figure 3 shows representative examples, including the input image, facade structure layout, and final procedural reconstruction. These results illustrate the overall goal of our framework: recovering not only a visually aligned facade layout, but also an executable procedural representation with reusable local architectural components. Additional end-to-end results and local details are provided in Appendix § 7.

Figure 3. End-to-end procedural reconstruction examples. Each row shows two examples, each showing the input facade image, recovered layout, and final instantiated building asset. For their detailed outputs, please refer to Figure 7 and 8 in Appendix § 7.
Effectiveness of Global Structure Reasoning. We evaluate whether the proposed global structure reasoning can recover a meaningful facade-scale structural scaffold from RGB images. The evaluation covers both regular facades, where layout structures are relatively clear, and challenging in-the-wild facades, where occlusion, perspective distortion, and incomplete evidence make structural recovery more difficult.
We further evaluate global structure recovery on challenging examples from eTRIMS and real-world imagery. These images include perspective distortion, partial occlusion, nonuniform spacing, and incomplete visual evidence. Since accurate procedural ground-truth layouts are generally unavailable for such cases, we focus on whether the recovered layouts preserve the dominant facade organization and remain procedurally meaningful. Additional challenging cases are provided in Figure 4. Extended reflection-iteration results are reported in Table 6 of Appendix § 9.

Figure 4. Challenging facade reconstruction examples. Representative examples from eTRIMS and in-the-wild images with corresponding recovered global structure layouts.
| Model | Acc (Win)↑ | Acc (Floor)↑ | Acc (Door)↑ | TRC↓ | Exec. Succ.↑ |
| Initial Layout | 0.61 | 0.83 | 0.69 | 4.32 | 0.98 |
| Iteration 1 | 0.77 | 0.85 | 0.78 | 2.01 | 0.98 |
| Iteration 2 | 0.80 | 0.86 | 0.81 | 1.47 | 0.99 |
| Iteration 3 | 0.80 | 0.87 | 0.80 | 1.46 | 0.99 |
| Iteration 4 | 0.78 | 0.87 | 0.79 | 1.48 | 0.99 |
Table 6. Effect of increasing the number of visual-symbolic reflection iterations.
Effectiveness of Component Parameterization. We evaluate component parameterization using attribute-level accuracy on real-world tile crops from CMP Tyleček [2013] and eTRIMS Korč and Förstner [2009], as well as procedurally rendered synthetic tiles. Real-world evaluation uses 107 held-out crops, with training and test partitions separated by building identity. Data construction is described in Appendix § 10, with the real-tile split and leakage checks detailed in Appendix § 10.§ 2.
For geometric attributes, we report exact-match accuracy over discrete presets of normalized values. Attribute discretization and metric definitions, together with continuous-error evaluation on synthetic test tiles, are detailed in Appendix § 11.§ 2. A separate comparison of synthetic-only and synthetic-plus-real training on the same held-out real test set is reported in Appendix § 11.§ 3.
Table 1 shows that the model achieves strong attribute-level accuracy on both synthetic and real-world tile sets, with a moderate gap between the two settings. W and E denote window-like and entrance-like
| Data | W-Arch | W-Sill | W-Row/Col | E-Stair | E-Handle |
| Real-world | 0.98 | 0.92 | 0.89 | 0.95 | 0.96 |
| Synthetic | 0.99 | 0.96 | 0.92 | 0.98 | 0.97 |
Table 1. Accuracy of representative component (tile) attributes on real-world and synthetic datasets. W and E denote window-like and entrance-like components. Full per-attribute results are provided in Appendix § 11.
tiles, respectively. These results indicate that the component parameterization predictor can recover key local procedural attributes from real image evidence while benefiting from the controllability and coverage of synthetic supervision. Detailed per-attribute results are provided in Appendix § 11.
Bonus Feature: Editability. One major advantage of our method lies in its ability to produce 3D results with separable structures, enabling seamless integration into game engines and facilitating user-driven post-editing. Figure 5 shows two examples of user edits on our reconstructions at both the facade and tile levels. The modification on the global facade layout enables changes to the overall structure of the instantiated 3D building (see Figure 5(a)). In contrast, editing the parameters of local tiles enables updates to all corresponding repeated components in the final building (see Figure 5(b)). This demonstrates that our output is not merely a static mesh or image, but an executable and editable procedural representation that supports both global structural control and local component-level manipulation.

Figure 5. Controllability and editability of the recovered procedural building representation. Top: editing the recovered facade layout leads to a corresponding change in the instantiated 3D building result, demonstrating global structural controllability. Bottom: editing a representative reconstructed tile produces updated repeated components in the final 3D building result, demonstrating local component-level editability. Together, these examples show that the recovered procedural representation supports both facade-scale structural editing and local repeated-component editing.
Comparison
We conduct comparison studies at two levels: global structure recovery and Component Parameterization.
For global facade-structure recovery, we compare our recovered global facade structures with representative examples reported in FaçAID. Since FaçAID assumes segmented facade input, while our method starts from RGB facade images, and since no public implementation or unified executable evaluation protocol is available, we treat this comparison as a qualitative layout-level reference rather than a direct benchmark under identical inputs. Figure 6 shows a representative comparison, and additional visual comparisons are provided in Appendix § 12.§ 1.

Figure 6. Representative comparison with FaçAID. From left to right are the input facade image, the layout result reported by FaçAID, and our recovered global facade structure.
To further complement this qualitative comparison, we conduct a small user preference study. Participants are shown the input facade image and two anonymized layout results, one from FaçAID and one from our method, and are asked which result better matches the facade structure. Table 2 reports the percentage of preferences for FaçAID, ours, and tie, where tie indicates that the two results are judged comparable or hard to distinguish. The study involved 15 participants and 180 randomized blinded comparisons. Participant information, the evaluation protocol, full instructions, vote counts, and exploratory statistical results are provided in Appendix § 13.
| Methods: | FaçAID | Ours | Tie |
| Vote Proportion: | 30% | 59% | 11% |
Table 2. User preference study comparing FaçAID and our method in terms of facade reconstruction fidelity. Participants selected their preferred result, and we report the percentage of votes. ‘Tie’ indicates the proportion of cases where both results were judged to be of comparable quality.
Next, we evaluate the role of the Component Parameterization by comparing three component-level generation strategies: direct low-level code generation, direct component parameterization prediction, and our fine-tuned predictor. Execution success is reported for all methods, while attribute-level accuracy is reported only for methods that explicitly predict structured tile attributes. Representative qualitative examples are provided in Appendix § 12.§ 2.
Table 3 reports execution success and representative attribute accuracy on objective tile-level properties. Compared with the stronger Gemini 3.1 Pro Preview baseline, direct middle-code generation substantially improves executability over direct code generation, indicating that structured intermediate representations reduce the ambiguity of procedural program generation. Our task-specific predictor further improves execution reliability and fine-grained architectural attribute recovery.
| Method | Exec. Succ. | Arch Acc. | Row/Col Acc. | Sill Acc. | Stair Acc. | Handle Acc. |
| Direct Code (Gemini 3.1 Pro Preview) | 0.68 | N/A | N/A | N/A | N/A | N/A |
| Direct Middle Code (Gemini 3.1 Pro Preview) | 0.95 | 0.94 | 0.88 | 0.88 | 0.96 | 0.91 |
| Ours | 0.98 | 0.99 | 0.90 | 0.93 | 0.96 | 0.96 |
Table 3. Comparison of tile-level procedural generation strategies. Attribute accuracy is reported only for methods that explicitly predict tile-level structured attributes.
| Method | Exec. Succ. | TRC |
| Direct LLM (Gemini 3.1 Pro Preview) | 0.94 | 1.83 |
| Ours | 0.98 | 1.47 |
Table 4. Comparison with direct end-to-end LLM/VLM generation.
Lastly, we compare our full framework with a direct generation baseline, where a general LLM/VLM is prompted to generate the entire CGA program from the input facade image in a single pass. We evaluate this comparison from both the layout and executable-code levels using Tree Repair Cost (TRC) and execution success rate. For the direct generation baseline, the layout tree used for TRC evaluation is recovered from the generated CGA program. TRC is computed on the layout structure and measures the expert-validated structural repair cost under a fixed editing protocol. Specifically, annotators edit the predicted layout tree through predefined atomic operations until its rendered schematic expresses the dominant facade organization. Each insertion, deletion, or modification of a structural node counts as one edit. Therefore, TRC reflects the amount of manual structural correction required by a prediction, rather than a global optimum over all possible tree representations. The detailed annotation interface and repair protocol are provided in Appendix § 14.
Table 4 reports execution success and symbolic repair cost, and representative qualitative examples are provided in Appendix § 12.§ 2.
Ablation
We first evaluate the effect of visual-symbolic reflection on global facade-structure recovery. Starting from the initial symbolic draft, the model iteratively revises the layout using rendered feedback and segmentation-derived visual evidence. In addition to TRC and execution success rate, we report count-based structural accuracy: floor accuracy is computed at the facade level, while window and door count accuracy are computed at the floor level by comparing the predicted and target element counts.
| Model | Win Cnt. Acc. | Floor Cnt. Acc. | Door Cnt. Acc. | TRC | Exec. Succ. |
| Initial Layout | 0.61 | 0.83 | 0.69 | 4.32 | 0.98 |
| Iteration 1 | 0.77 | 0.85 | 0.78 | 2.01 | 0.98 |
| Iteration 2 | 0.80 | 0.86 | 0.81 | 1.47 | 0.99 |
Table 5. Ablation of visual-symbolic reflection on structure layout recovery.
Table 5 reports the main reflection results up to the default setting , showing that reflection improves count-level structural consistency and reduces TRC while maintaining high global structure recovery compatibility. Most of the improvement is obtained within the first two iterations, after which the gains become marginal. We therefore use in the main experiments. Additional qualitative examples and an extended analysis with more reflection iterations are provided in Appendix § 9.
We further ablate the visual stream by comparing CLIP-only, DINOv3-only, and CLIP+DINOv3 encoders using grouped semantic-presence and structural attributes for window-like and entrance-like tiles. The combined encoder achieves the best overall structural accuracy, with full grouped results provided in Appendix § 11.§ 1.
Limitations and Discussion
Our framework targets approximately planar visible facades, while unseen geometry is completed for asset instantiation rather than reconstructed from image evidence. The current component schema supports simple parametric window arches, but not entrance arches or complex decorative assemblies. Severe perspective distortion and occlusion may still affect layout recovery.
Our experiments cover the considered facade sources and include building-disjoint real-tile evaluation, but controlled city-disjoint and style-disjoint evaluation remains future work. More expressive massing and component representations, together with additional geometric evidence, could extend the framework to more complex architecture.
Conclusion
We presented a hierarchical neuro-symbolic framework for visual-to-executable procedural reconstruction of buildings from in-the-wild images. The key idea is to bridge visual facade understanding and procedural generation through structured intermediate representations: a global structure layout tree captures facade-scale organization, while component parameterizations describe local architectural elements. Together with render-guided visual-symbolic reflection and deterministic CGA compilation, this design avoids direct low-level code generation and produces editable, executable procedural facade programs.
Experiments show that the proposed representation-aligned formulation recovers meaningful facade structures on both regular and challenging in-the-wild images, improves procedural executability over direct LLM/VLM generation baselines, and preserves fine-grained component details through tile-level parameter prediction. These results suggest that structured intermediate representations provide a practical path toward robust image-based procedural building reconstruction.
Acknowledgments
This work was supported in part by the Guangdong Major Project of Basic and Applied Basic Research (Grant No. 2023B0303000016) and the Shenzhen Science and Technology Program (Grant No. CJGJZD20240729141906008).
More Reconstruction Results
Figure 7 and 8 provide additional end-to-end reconstruction results. Each example shows the input building facade image together with the final procedural reconstruction produced by our framework. These results complement the main-paper examples and further demonstrate the ability of the proposed method to combine global structure layout recovery and component-level procedural parameterization into a unified executable facade representation.

Figure 7. Additional end-to-end procedural reconstruction results - 1. Each example shows the input building image and the final procedural reconstruction generated by our full framework.
Detailed Representation Schemas
This section provides additional details of the hierarchical two-level representation used in our framework. Figure 9 illustrates the global structure layout schema for split-and-repeat facade organization and the component-level parameterization schemas for representative window and entrance components.

Figure 9. Detailed dual-tier symbolic representation. The left panel shows the grammar used to describe facade-scale organization. The right panels show representative component parameterization for window-like and entrance-like components.
Global structure layout schema.
The global structure level representation describes the dominant facade plane as a hierarchical split-and-repeat layout. Each region is represented by a symbolic node with a normalized spatial domain and a node type, such as split, repeat, or leaf. Split nodes partition a parent region into ordered child regions, while repeat nodes describe repeated tile instances along a selected axis. Leaf nodes serve as placeholders for representative tiles, which are later grounded and replaced by compiled component rules.
Component parameterization schema.
The component representation abstracts each unique tile into a structured set of procedural attributes rather than raw CGA code. For window-like tiles, the schema includes local grid structure, frame configuration, arch and sill attributes, depth-related properties, and appearance parameters. For entrance-like tiles, the schema includes door structure, frame configuration, stairs, hardware, and appearance attributes. These attributes are designed to be directly translatable into CGA component rules by the deterministic compiler.
CGA-style Procedural Compilation Example
Listing 1 gives a simplified CGA-style pseudo-code example of our deterministic compilation process. The facade is first subdivided along the vertical axis into floor-level regions, repeated floors are expanded into horizontal tile slots, and each leaf tile invokes a parameterized component generator such as Window or Entrance. The compiled component rules are then scaled to their corresponding leaf scopes and assembled on the facade scaffold. Finally, the assembled facade is attached to a simple building mass model to produce an editable and executable procedural 3D building.
Listing 1: A simplified CGA-style pseudo-code example illustrating how global layout and component parameters are compiled into procedural facade rules.
0: building -> comp(f) {
front : facade
| back : Wall
| left : facade
| right : facade
}
1: facade -> Subdiv(Y, ground_h, lr, top_h) {
ground_floor | Repeat(Y, floor_h) { typical_floor } | top
}
2: typical_floor -> Repeat(X, tile_w) {
window_slot
}

Figure 8. Additional end-to-end procedural reconstruction results - 2. Each example shows the input building image and the final procedural reconstruction generated by our full framework.
3: ground_floor -> Subdiv(X, 1r, door_w, 1r) {
wall | entrance_slot | wall
}
4: window_slot -> Window(
rows=2, cols=3, frame=true, arch=false, sill=true
)
5: entrance_slot -> Entrance(
door_type=double, stairs=true, handle=true
)
Additional Visual-Symbolic Reflection Examples
We further analyze the effect of increasing the number of visual-symbolic reflection iterations. This study examines whether more reflection steps consistently improve the recovered global structure layout. As shown in Table 6, most of the improvement is obtained within the first two iterations: count-level structural accuracy improves substantially and TRC decreases sharply compared with the initial layout. Further iterations bring only marginal changes and may introduce small fluctuations in local element counts. Therefore, we use a small fixed reflection budget in the main experiments.
Figure 10 provides qualitative examples of the reflection process. The examples illustrate how the initial symbolic draft is iteratively refined through rendered layout feedback and RGB–mask overlay evidence.

Figure 10. Updated examples under the process of visual-symbolic reflection loop. The examples show how the initial global structure layout draft is refined over reflection iterations using rendered schematic feedback and RGB–mask overlay evidence.
Training and Implementation Details
Qwen-VL-7B fine-tuning. We fine-tune a Qwen-VL-7B model for global structure layout recovery using both real and synthetic facade data. Each training example pairs a facade image and segmentation-derived evidence with a normalized orthogonal layout tree represented in YAML. For real data, we use in-the-wild facade crops without explicit perspective rectification and manually annotate their layouts. For synthetic data, we augment the training inputs by rendering procedurally generated facades from different viewpoints, pairing each rendered image with its corresponding layout derived from the procedural rules. These pairs provide supervision for mapping view-dependent image evidence to canonical facade structures.
To account for the non-uniqueness of procedural layout representations, we annotate each real facade with at least two valid layout strategies when possible. These alternative YAML layouts may differ in grouping, split order, or repeat abstraction, while still describing the same dominant facade organization. This design avoids forcing the model to imitate a single arbitrary tree representation and better reflects the multi-solution nature of procedural facade modeling. The fine-tuned Qwen-VL-7B model is used in two instruction modes during inference: initial layout induction and visual-symbolic reflection.
Two-stage supervised fine-tuning. We first fine-tune the model on layout-induction examples to establish the image-to-layout mapping. Starting from this checkpoint, we jointly fine-tune it on induction and refinement examples distinguished by task-specific instructions. The resulting checkpoint is shared by the two instruction modes at inference time.
Visual-symbolic refinement training. To train the refinement capability, we further construct supervised repair trajectories based on valid facade layouts. Given an accepted layout representation , we generate intermediate corrupted states by applying schema-valid perturbations at different levels.
Starting from an accepted layout , we first perturb normalized spans and spacing to obtain , and then perturb topology and discrete counts to obtain . Thus, data corruption follows , whereas supervised repair follows the reverse direction:
During refinement training, we supervise the VLM on successive steps of the coarse-to-fine repair trajectory. Each example uses the facade image, segmentation-derived evidence, the current YAML layout, and a schematic rendered from that layout as input, with the next repaired layout as the prediction target.
For synthetic data, refinement trajectories are automatically generated using schema-valid and renderable perturbations. For real facade images, we manually construct repair trajectories by first correcting structural/count errors and then refining spatial parameters. When multiple valid decompositions exist, alternative executable layouts are also included as valid examples rather than forcing the model toward a single tree serialization.
Training configuration. We fine-tune the layout model using LoRA and AdamW, with a learning rate of , weight decay of 0.1, and . Training uses BF16 precision, a per-device batch size of 2, 8 gradient-accumulation steps, a maximum sequence length of 2048, and 5 epochs per training run. We use a LoRA rank of 64, a scaling parameter of 16, and dropout of 0.05. Gradient checkpointing and DeepSpeed ZeRO-2 are enabled.
Tile-level predictor training data. We construct synthetic and real tile datasets for component parameterization. Each sample pairs a component crop with structured procedural attributes under the schema in Appendix § 8.§ 2. Data construction and the building-disjoint real-tile split are detailed in Appendix § 10.§ 2.
Component Parameterization Architecture
Figure 11 shows the detailed architecture of the component parameterization predictor. Representative tile crops are encoded by the dual-stream CLIP and DINOv3 backbone, fused into a shared decoder space, and decoded into component parameterization for deterministic procedural compilation.

Figure 11. Our component parameterization architecture. Representative tile crops are encoded by a dual-stream visual backbone and decoded into tile-specific YAML middle code, which is then deterministically compiled into executable CGA snippets.
Tile Dataset Construction and Splits
Synthetic tile construction. Synthetic tiles are rendered using parameterized procedural generators for common window-like and entrance-like components. The generators vary grid structure, frames, window arches, sills, stairs, hardware, and appearance attributes. Each rendered image is paired with the corresponding component-parameterization annotation derived from the generator parameters. The original continuous CGA parameters are also available for evaluating geometric attributes on synthetic tiles. Both synthetic and real annotations follow the schema in Appendix B.2.
Real tile collection and annotation. Real window and entrance crops are collected from the CMP Facade Database Tyleček [2013] and eTRIMS Korč and Förstner [2009] and manually annotated with structured component attributes. Before extracting crops, we group all images of the same building, including multiple viewpoints, repeated captures, and overlapping images. We then segment window and entrance instances from the images in each building group and extract their component crops.
Redundancy removal and building-level partitioning. Within each building group, we extract DINOv2 features for the component crops and remove highly similar crops using a cosine-similarity threshold of 0.85. This removes redundant instances, such as nearly identical windows from the same facade or duplicate observations of the same opening. DINOv2 is used here for dataset redundancy checks, whereas the component predictor uses CLIP and DINOv3.
The train/test partition is constructed at the building-group level. Building groups are randomly assigned until the retained crop counts are approximately balanced between the two partitions. All viewpoints, facades, and component crops from one building remain in the same partition. Highly similar cross-split pairs are additionally inspected to remove duplicated image content or same-building overlap. Table 7 summarizes the resulting 207 crops from 67 building groups: 100 training crops and 107 test crops.
| Split | Tiles | Building groups | Avg. tiles/group |
| Training | 100 | 31 | 3.23 |
| Test | 107 | 36 | 2.97 |
| Total | 207 | 67 | 3.09 |
Table 7. Building-disjoint partition of the real tile dataset collected from CMP and eTRIMS. The 207 crops comprise both training and test data.
Additional Tile-Level Quantitative Results
This section provides additional quantitative results for the tile-level procedural synthesis module, including full per-attribute results, visual encoder ablations, metric definitions, and the synthetic-only versus synthetic-plus-real training comparison.
Mixed-domain model evaluated on synthetic and real tiles. Tables 8 and 9 evaluate the mixed-domain-trained component predictor on synthetic and real-world test tiles. They characterize the difference between the two evaluation domains. The separate training-data comparison is reported in Appendix E.3.
Full visual encoder ablation.
Table 10 and Table 11 report the full per-attribute accuracy of different visual encoders. We compare CLIP-only, DINOv3-only, and the combined CLIP+DINOv3 encoder. CLIP-only performs well on semantic presence attributes, while DINOv3 improves several structural attributes. The combined encoder achieves the most stable overall performance.
Attribute Discretization and Evaluation
Normalized geometric presets. Geometric dimensions are normalized by the corresponding tile width or height and represented as attribute-specific preset categories. The recorded preprocessing procedure uses training-set quantiles to determine category boundaries. Attribute accuracy is evaluated by exact match against the annotated preset labels, while synthetic continuous-error evaluation compares preset-decoded values with the original CGA parameters.
| Group | Attribute | Synthetic Acc. | Real-world Acc. | Gap |
| Arch structure | Arch style | 0.96 | 0.93 | 0.03 |
| Arch height class | 0.92 | 0.87 | 0.05 | |
| Categorical | Arch | 0.99 | 0.98 | 0.01 |
| Top sill | 0.96 | 0.92 | 0.04 | |
| Bottom sill | 0.95 | 0.93 | 0.02 | |
| Frame attributes | Outer frame thickness | 0.89 | 0.86 | 0.03 |
| Transom width | 0.91 | 0.91 | 0.00 | |
| Mullion width | 0.90 | 0.88 | 0.02 | |
| Row | 0.94 | 0.95 | -0.01 | |
| Row ratio | 0.91 | 0.87 | 0.04 | |
| Columns per row | 0.89 | 0.84 | 0.05 | |
| Column ratio per row | 0.85 | 0.82 | 0.03 | |
| Sill structure | Top sill height | 0.93 | 0.88 | 0.05 |
| Top sill protrusion | 0.95 | 0.91 | 0.04 | |
| Bottom sill height | 0.94 | 0.90 | 0.04 | |
| Bottom sill protrusion | 0.95 | 0.87 | 0.08 |
Table 8. Full attribute-level accuracy on window-like tiles.
| Group | Attribute | Synthetic Acc. | Real-world Acc. | Gap |
| Entrance frame | Frame style | 0.97 | 0.93 | 0.04 |
| Frame head height | 0.92 | 0.89 | 0.03 | |
| Frame side width | 0.93 | 0.90 | 0.03 | |
| Entrance structure | Door type | 0.97 | 0.92 | 0.05 |
| Door asymmetric ratio | 0.91 | 0.86 | 0.05 | |
| Door style | 0.88 | 0.88 | 0.00 | |
| Grid rows | 0.87 | 0.85 | 0.02 | |
| Grid columns | 0.85 | 0.87 | -0.02 | |
| Hardware | Has hardware | 0.98 | 0.96 | 0.02 |
| Hardware type | 0.97 | 0.96 | 0.01 | |
| Hardware side | 0.92 | 0.87 | 0.05 | |
| Stairs | Has stairs | 0.98 | 0.94 | 0.04 |
| Stair height | 0.88 | 0.86 | 0.02 | |
| Stair count | 0.90 | 0.86 | 0.04 |
Table 9. Full attribute-level accuracy on entrance-like tiles.
Exact-match accuracy. Let denote the evaluation tiles with valid ground-truth labels for attribute . Its exact-match accuracy is
where and are the annotated and predicted attribute values or preset categories. The same exact-match definition applies to categorical presence/type attributes and discrete counts. Presence attributes, such as Has stairs, are evaluated on all relevant tiles with valid labels, whereas dependent attributes, such as Stair height, are evaluated only where the corresponding structure is present in the ground truth and their labels are valid.
| Model | Has Arch | Arch Style | Arch Height | Has Sill | Sill Height | Sill Protrusion | Frame Thick. | Grid Num. | Grid Ratio |
| CLIP-only | 0.99 | 0.90 | 0.81 | 0.91 | 0.72 | 0.68 | 0.65 | 0.75 | 0.72 |
| DINOv3-only | 0.98 | 0.93 | 0.88 | 0.90 | 0.89 | 0.89 | 0.86 | 0.88 | 0.85 |
| CLIP+DINOv3 | 0.99 | 0.94 | 0.90 | 0.93 | 0.92 | 0.92 | 0.88 | 0.90 | 0.87 |
Table 10. Full per-attribute encoder ablation on window-like tiles.
| Model | Has Stairs | Stair Height | Stair Count | Has Hardware | Hardware Type | Hardware Side | Frame Style | Frame Size | Door Type | Door Asym. Ratio | Door Style | Grid |
| CLIP-only | 0.95 | 0.74 | 0.71 | 0.95 | 0.94 | 0.80 | 0.93 | 0.82 | 0.86 | 0.78 | 0.86 | 0.77 |
| DINOv3-only | 0.93 | 0.83 | 0.85 | 0.93 | 0.91 | 0.84 | 0.89 | 0.88 | 0.90 | 0.85 | 0.87 | 0.84 |
| CLIP+DINOv3 | 0.96 | 0.87 | 0.88 | 0.96 | 0.96 | 0.88 | 0.95 | 0.90 | 0.94 | 0.88 | 0.88 | 0.86 |
Table 11. Full per-attribute encoder ablation on entrance-like tiles.
Continuous error on synthetic test tiles. For synthetic samples, the original continuous CGA parameters are available. We therefore also compare the normalized continuous target with the representative value of the predicted preset. For the synthetic samples with a valid continuous target for attribute ,
This measures the continuous error of the preset-decoded prediction, rather than the output of a continuous regression model. The error is dimensionless in normalized tile coordinates, not meters. Table 12 reports the results.
| Attribute group | Exact Acc. | MAE |
| Window frame geometry | 0.900 | 0.026 |
| Window grid ratios | 0.880 | 0.031 |
| Window sill geometry | 0.943 | 0.016 |
| Entrance geometry | 0.910 | 0.024 |
Table 12. Synthetic-test preset accuracy and normalized continuous error. The representative value of the predicted preset is compared with the normalized continuous CGA parameter.
Synthetic-Only versus Synthetic-Plus-Real Training
We compare a component predictor trained with synthetic data only against one trained with the same synthetic data augmented by the real training partition. Both are evaluated on the same held-out set of 107 real tiles from 36 building groups (Appendix § 10.§ 2). Only the synthetic-plus-real setting uses the 100 real training crops. This experiment tests the effect of adding real-domain supervision, separately from evaluating a mixed-domain-trained model on two test domains.
The representative attribute scores improve with real training crops: W-Arch increases from 0.91 to 0.98, W-Row/Col from 0.82 to 0.89, W-Sill from 0.83 to 0.92, E-Stair from 0.89 to 0.95, and E-Handle from 0.89 to 0.96. These results support synthetic-to-real transfer and the benefit of real-domain calibration on the evaluated building-disjoint test partition.
Additional Qualitative Results
Additional Global Structure Layout Recovery Results
Regular CMP facades. Figure 12 presents additional global structure layout recovery results on regular facade examples from CMP. For these cases, the provided annotations are remapped into our visualization scheme and used as structural references for layout-level comparison. These additional examples further demonstrate that the proposed global structure recovery stage can infer stable floor-wise and bay-wise facade organization from RGB images.

Figure 12. Additional global structure layout recovery results on regular CMP facades. Each example shows the input facade image, the remapped structural reference, and the recovered global structure layout.
Challenging facades. Figure 4 shows additional results on challenging facade images from eTRIMS and in-the-wild examples. These cases include perspective distortion, partial occlusion, nonuniform spacing, and incomplete visual evidence. The results provide further qualitative evidence that the reflection-based layout recovery stage can recover structurally meaningful facade layouts under difficult visual conditions.
| Training data | Overall macro↑ | W-Arch↑ | W-Row/Col↑ | W-Sill↑ | E-Stair↑ | E-Handle↑ |
| Synthetic only | 0.868 | 0.91 | 0.82 | 0.83 | 0.89 | 0.89 |
| Synthetic + real | 0.940 | 0.98 | 0.89 | 0.92 | 0.95 | 0.96 |
Table 13. Training-data comparison on the same held-out real test partition. W and E denote window-like and entrance-like components. Overall macro is the arithmetic mean of the five reported grouped metrics.
Additional comparison with FaçAID. Figure 13 provides additional qualitative comparisons with representative examples reported in FaçAID. Since FaçAID assumes segmented facade input and no unified executable evaluation protocol is available, these comparisons are intended as qualitative layout-level references. Each example compares the input image, the FaçAID result, and our recovered layout.

Figure 13. Additional qualitative comparison with FaçAID. Each example shows the input facade image, the corresponding FaçAID result, and our recovered layout.
Additional Comparison Results
Our method adopts a progressive reasoning workflow that infers appropriate facade structures through a dynamic reflection loop. To further illustrate its advantages, Figure 14 provides additional qualitative comparisons against direct LLM/VLM baselines. The left panel compares facade-level direct end-to-end generation with our full framework, while the right panel compares tile-level procedural generation strategies, including our fine-tuned predictor, direct low-level code generation, and direct middle-code prediction. These examples complement the quantitative comparisons in the main paper.

Figure 14. Additional qualitative comparisons between our progressive reasoning workflow and direct LLM/VLM outputs. (a) Facade-level comparison between our full framework and direct end-to-end CGA generation by a general LLM/VLM [2]. From left to right are the input facade image, our result, and the direct LLM/VLM result. (b) Tile-level comparison among our fine-tuned tile-level predictor, direct low-level code generation, and direct middle-code prediction. From left to right are the input tile crop, our result, the direct low-level code generation result, and the direct middle-code result.
Additional Editable Tile-Level Results
To further illustrate the interpretability and editability of the proposed component parameterization, we provide additional tile-level examples for representative window-like and entrance-like components.
These examples show that the recovered structured tile descriptions can be translated into editable procedural assets while preserving the main local architectural properties.
Window-like tiles. Figure 15 shows additional editable reconstruction examples for window-like tiles. These examples cover variations in arch presence, grid subdivision, sill configuration, and frame structure.

Figure 15. Editable tile-level results. Top: representative window-like tiles. Bottom: representative entrance-like tiles. For each example, we show the input crop and the corresponding procedural reconstruction generated from the predicted tile-level representation.
Entrance-like tiles. Figure 15 presents additional editable reconstruction examples for entrance-like tiles. The examples include different doorway layouts, stair configurations, frame structures, and hardware-related details.
User Study Protocol
We conduct a user preference study to compare our recovered facade layouts with FaçAID. The study is designed as a supplementary perceptual evaluation rather than a replacement for quantitative structural evaluation.
Participants
The study involved 15 participants, including 5 participants with architecture-related backgrounds and 10 participants without architecture training. The participants consisted of 8 males and 7 females.
Evaluation Protocol
Each participant evaluated all 12 paired facade examples. For each trial, participants were shown: (1) the input facade image and (2) two anonymized layout reconstruction results.
The two methods were randomly assigned to the left or right position for each trial, and method identities were hidden. Participants were asked to select the layout that better preserves the dominant facade structure.
The instruction provided to participants was:
Given the input facade and two candidate layout reconstructions, select the result that better preserves the dominant facade structure, including floor organization, window and entrance placement, major facade regions, and repetition patterns. Ignore color and rendering style. Select “Tie” if the two results are comparably faithful or if no reliable preference can be made.
Preference Results
The study produced 106 votes for our method, 54 for FaçAID, and 20 ties, corresponding to 58.9%, 30.0%, and 11.1%, respectively. Among the 160 non-tie judgments, our method received 66.3% of the votes. Under an independent-vote binomial model, the non-tie preference proportion has a nominal exact 95% confidence interval of [58.4%, 73.5%] (Clopper–Pearson), with a two-sided against . These unadjusted statistics do not account for participant- or example-level dependence and are reported only as exploratory evidence. We interpret these descriptive results as supplementary perceptual evidence on the 12 evaluated examples, rather than a comprehensive benchmark against FaçAID.
TRC Evaluation Protocol
Tree Repair Cost (TRC) measures the expert-validated structural repair cost under a fixed editing protocol. It is designed to evaluate how much manual structural correction is required for a predicted layout tree. TRC is evaluated by expert annotators who are separate from the participants in the FaçAID preference study.
For each evaluation example, we manually construct one valid reference layout and render it into a schematic representation. The reference schematic serves as a visual structural target; the predicted tree is not required to match the reference tree in split order, grouping strategy, or serialization.
We develop an annotation interface containing: (1) the input facade image, (2) the rendered reference schematic, (3) the predicted layout tree and its rendered schematic, and (4) editing operations for modifying the predicted tree.
The annotator edits only the predicted layout tree until its rendered schematic expresses the same dominant facade organization as the accepted reference. If the predicted tree already produces an acceptable reconstruction, its TRC is zero.
One atomic edit is defined as:
inserting one structural node;
deleting one structural node;
modifying one existing node, including operator type, split axis, repeat count, span, or related attributes.
When several attributes of the same node are corrected together, they are counted as one node modification.
All annotators receive the same operation definitions and representative examples. Each sample is independently evaluated, and the lowest validated repair count is retained as its TRC.
Therefore, TRC should be interpreted as the lowest expert-validated repair cost under the fixed protocol, rather than a guaranteed global minimum over all possible procedural decompositions. We do not report a formal inter-annotator agreement statistic and interpret TRC as an expert-assisted structural diagnostic.
NeurIPS Paper Checklist
Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
Answer: [Yes]
Justification: The abstract and introduction state that the method focuses on dominant visible facade reconstruction and editable building asset instantiation, rather than full reconstruction of unseen geometry. The method, experiments, and conclusion are aligned with this scope.
Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification: The paper discusses the scope and assumptions of the method, including its focus on the dominant visible facade, the orthogonal assumption, and the use of a simple mass model for editable building asset instantiation. The conclusion and method sections also clarify that the recovered visible-facade program is the primary output, rather than a full reconstruction of unseen building geometry.
Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?
Answer: [N/A]
Justification: The paper does not present theoretical results, theorems, or formal proofs. The contribution is an empirical and methodological framework for visual-to-executable procedural reconstruction.
Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
Justification: The paper describes the model components, the global structure recovery and component parameterization pipeline, the deterministic CGA compilation process, the evaluation metrics, and the datasets used for macro-structure recovery and tile-level evaluation. Additional training and implementation details, representation schemas, and extended quantitative results are provided in the appendix.
Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?
Answer: [No]
Justification: The paper does not release code, model checkpoints, or newly constructed training data at submission time. However, the main method, representation schemas, deterministic compilation process, evaluation metrics, and training/implementation details are described in the main paper and appendix to support reproducibility.
Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer) necessary to understand the results?
Answer: [Yes]
Justification: The main paper describes the evaluation settings, datasets, baselines, and metrics used for global structure recovery, component parameterization, direct generation comparison, and ablation studies. Additional training and implementation details, including data construction and model usage, are provided in the appendix.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [No]
Justification: Appendix G reports an exploratory vote-level binomial analysis with its independence assumption and limitations. We do not report participant- or example-adjusted uncertainty estimates, or repeated-run uncertainty estimates for the other quantitative experiments.
8. Experiments compute resources
Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Answer: [No]
Justification: The paper reports the model architecture, training settings, evaluation protocol, and deterministic compilation pipeline. Detailed hardware specifications, runtime measurements, and total computational costs are not reported.
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines?
Answer: [Yes]
Justification: The research uses architectural images and procedural modeling techniques and does not involve sensitive personal data, biometric identification, surveillance, or high-risk decision-making. We preserve submission anonymity and follow the NeurIPS Code of Ethics throughout the study.
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification: The paper discusses the intended use of the method for editable architectural and urban modeling. Potential positive impacts include reducing the cost of procedural building asset creation, while potential negative impacts include over-reliance on automatically reconstructed building geometry in applications that require accurate measurements or safety-critical decisions.
11. Safeguards
Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pre-trained language models, image generators, or scraped datasets)?
Answer: [No]
Justification: The paper does not release a high-risk pretrained model, image generator, or scraped dataset. The method focuses on procedural reconstruction of building facades and is not intended for surveillance, biometric identification, or safety-critical decision-making.
12. Licenses for existing assets
Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Answer: [Yes]
Justification: The paper cites the existing datasets, models, and related methods used for evaluation and comparison, including facade datasets, prior procedural modeling methods, and LLM/VLM baselines. We use these assets for research evaluation and follow their intended academic use.
13. New assets Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [No]
Justification: The paper constructs synthetic and real training examples for layout recovery and component parameterization, but these assets are not released at submission time. The paper and appendix document the data construction procedure, representation schemas, and annotation format to support understanding and future reproducibility.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?
Answer: [No]
Justification: Appendix G provides participant information, the evaluation protocol, and the full instructions given to participants. Interface screenshots and compensation details are not reported. The study is used as supplementary perceptual evidence.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [No]
Justification: The paper includes a small user preference study involving anonymized visual comparisons, but it does not report IRB approval or equivalent review. The study does not collect sensitive personal information and is not used for high-risk decision-making.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology, scientific rigor, or originality of the research, declaration is not required.
Answer: [Yes]
Justification: The core method uses a fine-tuned vision-language model for global structure layout induction and visual-symbolic reflection, and also compares against LLM/VLM direct generation baselines. These uses are described in the method, experiments, and appendix.
References
- [1]Nicolas Carion, Laura Gustafson, Yuan-Ting Hu, Shoubhik Debnath, Ronghang Hu, Didac Surís, Chaitanya Ryali, Kalyan Vasudev Alwala, Haitham Khedr, Andrew Huang, Jie Lei, Tengyu Ma, Baishan Guo, Arpit Kalla, Markus Marks, Joseph Greer, Meng Wang, Peize Sun, Roman Rädle, Triantafyllos Afoυras, Effrosyni Mavroudi, Katherine Xu, Tsung-Han Wu, Yu Zhou, Liliane Monneri, Rishi Hazra, Shuangrui Ding, Sagar Vaze, François Porcher, Feng Li, Siyuan Li, Aishwarya Kamath, Ho Kei Cheng, Piotr Dollár, Nikhila Ravi, Kate Saenko, Pengchuan Zhang, and Christoph Feichtenhofer. Sam 3: Segment anything with concepts. arXiv preprint arXiv:2511.16719, 2025.arxiv.org/abs/2511.16719
- [2]Google DeepMind. Gemini 3.1 pro: A smarter model for your most complex tasks. https://deepmind.google/models/model-cards/gemini-3-1-pro/, 2026. Accessed: 2026-02.
- [3]Yaroslav Ganin, Tejas Kulkarni, Igor Babuschkin, S. M. Ali Eslami, and Oriol Vinyals. Synthesizing programs for images using reinforced adversarial learning. In Proceedings of the International Conference on Machine Learning, pages 1666–1675, 2018.arxiv.org/abs/1804.01118
- [4]Jun Gao, Yongqi Li, Ziqiang Cao, and Wenjie Li. Interleaved-modal chain-of-thought. arXiv preprint arXiv:2411.19488, 2024.arxiv.org/abs/2411.19488
- [5]Qirui Huang, Runze Zhang, Kangjun Liu, Minglun Gong, Hao Zhang, and Hui Huang. Arcpro: Architectural programs for structured 3d abstraction of sparse points. arXiv preprint arXiv:2503.02745, 2025.arxiv.org/abs/2503.02745
- [6]R. Kenny Jones, Theresa Barton, Xianghao Xu, Kai Wang, Ellen Jiang, Paul Guerrero, Niloy J. Mitra, and Daniel Ritchie. Shapeassembly: Learning to generate programs for 3d shape structure synthesis. ACM Transactions on Graphics, 39(6), 2020. doi: 10.1145/3414685.3417812.DOI
- [7]Bernhard Kerbl, Georgios Kopanas, Thomas Leimkühler, and George Drettakis. 3d gaussian splatting for real-time radiance field rendering. ACM Transactions on Graphics, 42(4):139:1–139:14, 2023.arxiv.org/abs/2308.04079
- [9]Panagiotis Koutsourakis, Loïc Simon, Olivier Teboul, Georgios Tziritas, and Nikos Paragios. Single view reconstruction using shape grammars for urban environments. In Proceedings of the IEEE International Conference on Computer Vision, pages 1795–1802, 2009. doi: 10.1109/ICCV.2009.5459400.DOI
- [10]Peter Kulits, Haiwen Feng, Weiyang Liu, Victoria Abrevaya, and Michael J. Black. Re-thinking inverse graphics with large language models. arXiv preprint arXiv:2404.15228, 2024.arxiv.org/abs/2404.15228
- [11]Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. Communications of the ACM, 65(1):99–106, 2021.arxiv.org/abs/2003.08934
- [12]Pascal Müller, Peter Wonka, Simon Haegler, Andreas Ulmer, and Luc Van Gool. Procedural modeling of buildings. ACM Transactions on Graphics, 25(3):614–623, 2006. doi: 10.1145/1141911.1141931.DOI
- [13]Pascal Müller, Gang Zeng, Peter Wonka, and Luc Van Gool. Image-based procedural modeling of facades. ACM Transactions on Graphics, 26(3):85, 2007. doi: 10.1145/1257808.1276484.
- [15]Aleksander Plocharski, Jan Swidzinski, Joanna Porter-Sobieraj, and Przemyslaw Musialski. Façade: A transformer model for neuro-symbolic facade reconstruction. In SIGGRAPH Asia 2024 Conference Papers. ACM, 2024. doi: 10.1145/3680528.3687657.DOI
- [16]Ben Poole, Ajay Jain, Jonathan T. Barron, and Ben Mildenhall. Dreamfusion: Text-to-3d using 2d diffusion. In International Conference on Learning Representations, 2023.arxiv.org/abs/2209.14988
- [17]Olivier Teboul, Iasonas Kokkinos, Loïc Simon, Panagiotis Koutsourakis, and Nikos Paragios. Shape grammar parsing via reinforcement learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2273–2280, 2011. doi: 10.1109/CVPR.2011.5995319.DOI
- [19]Yikun Wang, Zuyan Liu, Ziyi Wang, Han Hu, Pengfei Liu, and Yongming Rao. Geovista: Web-augmented agentic visual reasoning for geolocalization. arXiv preprint arXiv:2511.15705, 2025.arxiv.org/abs/2511.15705
- [20]Peter Wonka, Michael Wimmer, François X. Sillion, and William Ribarsky. Instant architecture. ACM Transactions on Graphics, 22(3):669–677, 2003. doi: 10.1145/882262.882324.DOI
- [21]Fuzhang Wu, Dong-Ming Yan, Weiming Dong, Xiaopeng Zhang, and Peter Wonka. Inverse procedural modeling of facade layouts. ACM Transactions on Graphics, 33(4):121:1–121:10, 2014. doi: 10.1145/2601097.2601162.DOI
- [22]Rundi Wu, Chang Xiao, and Changxi Zheng. Deepcad: A deep generative network for computer-aided design models. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 6772–6782, 2021.arxiv.org/abs/2105.09492
- [23]Shaofeng Yin, Jiaxin Ge, Zora Zhiruo Wang, Chenyang Wang, Xiuyu Li, Michael J. Black, Trevor Darrell, Angjoo Kanazawa, and Haiwen Feng. Vision-as-inverse-graphics agent via interleaved multimodal reasoning. arXiv preprint arXiv:2601.11109, 2026.arxiv.org/abs/2601.11109