Decoded Programs
Every wall, door and window carries a material and a condition token, supervised by a VLM-distilled material passport over 1.9M elements.
Decoding is bound by overhead, not compute. An output-exact CUDA-graph decoder cuts 6.40→1.91 ms/step (3.4×), plus grammar-parallel draft-and-verify.
A bounded sub-bin offset head escapes the 5 cm token grid, doubling F1@2 cm and locating where the residual error really lives.
Structured-language models such as SceneScript reconstruct a scene as a short program of parametric commands, an editable and semantically explicit representation. We ask three questions that stand between such models and automated ingestion of existing buildings into BIM tools, studied here on synthetic scans: what is the scene made of, how fast can it be produced, and exactly where is each element. BIMScript answers all three within one grammar. First, we extend the layout language with per-element material and condition attributes, supervised by a vision-language-model material-passport corpus we build over 100k synthetic scenes (1.9M pseudo-labeled elements), and route image appearance to the material tokens through a lifted-feature encoder. Second, we show that autoregressive decoding of these programs is dominated not by compute but by kernel-launch and host-synchronization overhead, and remove it with an output-exact CUDA-graph decoder (3.4×) plus a grammar-parallel, tolerance-verified draft-and-verify scheme that exploits the deterministic entity schema. Third, we address the model's 5 cm token-grid granularity with training-free geometric snapping and a hybrid discrete–continuous decoder head that regresses a sub-bin offset. Because each command maps one-to-one onto a native Revit object, we validate direct ingestion end to end with a working add-in and its IFC4 export, and the program's language form supports LLM-driven, sustainability-aware reasoning over the built asset.
Drag the handle. Left is the input point cloud; right is the program BIMScript decodes from it, with walls colored by predicted material and openings by role. Uncurated validation scenes.
Real decoder output. Every line is an object with parameters — readable, diffable, editable, and one-to-one with a native BIM element.
make_wall, id=0, a_x=-5.922, a_y=8.741, a_z=-0.002, b_x=-1.907, b_y=8.757, b_z=-0.002,
height=2.700, thickness=0.0, material=wood_paneling, condition=good
make_wall, id=1, a_x=-1.907, a_y=8.757, a_z=-0.002, b_x=-1.875, b_y=1.616, b_z=-0.002,
height=2.700, thickness=0.0, material=wallpaper, condition=good
make_door, id=1000, wall0_id=1, position_x=-1.891, position_y=5.186, position_z=1.012,
width=0.920, height=2.024, material=composite, condition=new
make_window, id=2000, wall0_id=0, position_x=-3.914, position_y=8.749, position_z=1.520,
width=1.480, height=1.200, material=aluminum, condition=goodA lifted-feature encoder routes image appearance into the sparse point encoder, so the decoder conditions each material and condition token on the element's own geometry tokens through self-attention. Three mechanisms then make decoding fast and precise:
The whole decode step captured in one CUDA graph — zero Python, zero host sync. 6.40→1.91 ms/step, output-exact, no retraining.
A command token fixes the types of all remaining slots, so we draft them in one pass with an
[INFILL] embedding and verify. 51% accepted, 1.36× wall clock.
A bounded within-bin offset head lifts coordinates off the 5 cm grid. F1@2 cm 0.034→0.071.
Synthetic scenes give exact geometry but no material labels. For every element we gather the RGB observations that project onto it and prompt a vision-language model on the resulting crops. Two further cues are computed independently and stored beside the label — not to supply it, but to measure how far it can be trusted.
A BIMScript program is already an object model. Our pyRevit add-in creates native Revit walls with one wall type per predicted material, hosted door and window instances, and the material, condition and source id as shared parameters on every element. The same document exports to IFC4.
| BIMScript | Revit API target | IFC entity / property set |
|---|---|---|
make_wall | Wall.Create (curve, level, height) | IfcWall |
make_door | hosted FamilyInstance on host wall | IfcDoor + IfcRelFillsElement |
make_window | hosted FamilyInstance on host wall | IfcWindow + IfcRelFillsElement |
material=… | wall/family-type material parameter | IfcMaterial / IfcMaterialLayerSet |
condition=… | shared parameter (custom) | custom Pset (e.g. Pset_Condition) |
1,000-scene held-out test split, one greedy decode per scene. Layout is scored over all ground-truth elements; attributes only over elements matched within 10 cm, so coverage should be read alongside them. Latency is batch 1 with GraphStep on one L40S.
| Model | F1@5cm | AvgF1 | Cov. | Mat. acc. | Cond. acc. | Params | s/scene |
|---|---|---|---|---|---|---|---|
| SceneScript public ckpt | 0.581 | 0.667 | — | — | — | 25.9M | 1.47 |
| BIMScript (40k) | 0.577 | 0.676 | 0.701 | 0.629 | 0.842 | 58.4M | 1.14 |
| BIMScript+ (60k) | 0.576 | 0.669 | 0.699 | 0.639 | 0.840 | 58.5M | 1.12 |
Adding material and condition costs nothing in geometry: the material-aware model matches the layout-only baseline on the same splits. BIMScript+ folds the speed and precision fine-tunes into a single checkpoint that serves plain decoding, draft-and-verify, and sub-bin refinement at once.
Because a BIMScript program is an object model rather than a mesh, it drops into the tools the AEC industry already runs on — and because it is language, it is equally readable by a large language model.
Turn a captured point cloud into an object-level building model automatically, replacing the manual hand-tracing step of conventional scan-to-BIM.
Programs ingest directly into Revit as native walls and hosted openings carrying material and condition, and export to the open IFC4 standard for exchange.
A compact, machine-readable inventory an LLM can reason over: embodied-carbon and life-cycle assessment, material passports and circularity, maintenance triage, adaptive reuse.
good, and worn is not recovered.Training, evaluation and decoding code.
coming soonExtraction pipeline and the corpus.
coming soonpyRevit add-in and IFC4 export.
coming soon@article{naikade2026bimscript,
title = {BIMScript: Material-Aware Structured Scene Programs for BIM Ingestion},
author = {Naikade, Prakash Kondibhau and Moeslund, Thomas B. and M{\o}gelmose, Andreas},
journal = {arXiv preprint arXiv:ARXIV_ID},
year = {2026}
}