GDL

GDL — the Geometric Description Language — is a procedural, BASIC-influenced scripting language developed by Graphisoft for defining parametric 3D objects inside its Archicad building-information-modelling (BIM) system. A GDL script describes how to generate the 3D geometry, 2D drafting symbol, and parameter list of an architectural object — a door, window, stair, piece of furniture, structural connection — in such a way that the object responds intelligently to the parameters under which it is placed. When an architect drops a GDL window into a wall and adjusts its width, frame depth, or sash count, the GDL script is being re-evaluated to rebuild the geometry and the drawing in their new form.

GDL is unusual among the languages catalogued here in two respects. First, it has lived its entire life embedded inside a single commercial CAD product rather than as a free-standing language with its own compiler, package manager, or community of general-purpose programmers. Second, its primary audience is architects and BIM specialists, not software engineers — which has shaped both its syntax (kept deliberately close to BASIC) and its standard library (dominated by 3D geometric primitives rather than by data-structure manipulation).

History & Origins

Graphisoft and the first ArchiCAD

Graphisoft was founded in Budapest, Hungary, in 1982 by Gábor Bojár and a small group of collaborators. The company’s first products targeted industrial design and architectural CAD on early personal computers. In 1984, Graphisoft released the first version of ArchiCAD on the Apple Macintosh — among the earliest commercial CAD products to model buildings as 3D objects rather than as collections of 2D drawings. The “virtual building” concept that ArchiCAD popularised in the late 1980s prefigured what the industry would later call BIM.

From early on, ArchiCAD distinguished between the project (the model the architect was assembling) and library parts — reusable, parameter-driven components such as doors and windows that could be placed many times into a project with different dimensions and properties. To make those library parts genuinely parametric rather than fixed, Graphisoft developed a small scripting language to describe their geometry and behaviour. That language is GDL.

A BASIC for buildings

GDL’s surface syntax draws openly on BASIC, with line-oriented commands, all-caps keywords by convention, IF … THEN … ENDIF control flow, FOR … NEXT loops, GOSUB/SUBROUTINE style structuring, and a global numeric/string value model. This choice was pragmatic: in the mid-1980s BASIC was the lingua franca of personal-computer programming, and it was a syntax that architects without a software background could plausibly learn. Layered on top of that familiar control-flow language is a set of geometric and drafting primitives — BLOCK, CYLIND, PRISM_, ROTX, ROTY, ROTZ, ADDX, ADDY, ADDZ, LIN_, RECT2, and so on — that operate on a model-space cursor with its own coordinate system and transformation stack.

The resulting language is small but specialised: a competent GDL author thinks less about data structures and more about how to compose primitive solids and 2D symbols under a sequence of coordinate transformations, parameterised by the dimensions and options of the object being defined.

From ArchiCAD to Nemetschek

In 2007, Graphisoft was acquired by Germany’s Nemetschek group, which by then owned several other CAD and AEC software lines. Graphisoft continues as a brand and a product line within Nemetschek, and Archicad — eventually rebranded from the all-caps “ArchiCAD” to the mixed-case “Archicad” — continues to ship with GDL as the parametric-object scripting language. GDL itself does not have an independently advertised version number; it evolves quietly alongside each Archicad release.

Design Philosophy

A few principles distinguish GDL from general-purpose languages:

• Geometry as a side effect. A GDL script does not return a value; it emits geometry and drafting elements into the surrounding object’s model space. Calls such as BLOCK 0.5, 0.3, 0.1 place a rectangular solid at the current cursor position with the current transformation.
• Coordinate-system gymnastics. A great deal of a GDL author’s work is spent translating and rotating the cursor with ADDX/ADDY/ADDZ and ROTX/ROTY/ROTZ (and their multiplicative cousins), pushing and popping transformations from an implicit stack with DEL. Geometry is described relative to the cursor.
• Parameter-driven everything. Every library part is defined by a list of named parameters with types (length, angle, integer, boolean, string, materials, profiles, …), and the script reads from those parameters to decide what to draw. A parameter change re-runs the script.
• Separate scripts for separate concerns. A single library part typically contains several scripts: a 3D script for the volumetric model, a 2D script for the plan symbol, a parameter script for parameter validation and inter-dependencies, a master script for shared setup, and others (properties script, UI script, forward-migration script, and so on).
• BASIC familiarity over computer-science elegance. GDL deliberately avoids the conceptual sophistication of mainstream programming languages so that designers rather than software engineers can read and edit library parts.

Key Language Features

Script structure and primitives

A simple GDL 3D script might look something like:

! a wooden block with a rounded top
material_wood = "Oak"

SET MATERIAL material_wood
BLOCK A, B, h_main

ADDZ h_main
CYLIND h_top, A / 2
DEL 1

A and B are conventionally the placement-box X and Y dimensions of the library part, supplied by Archicad when the part is placed; h_main and h_top would be user-defined parameters. BLOCK and CYLIND are geometric primitives; ADDZ shifts the cursor upward and DEL 1 pops the most recent transformation.

Parameters

Parameters are declared through Archicad’s library-part editor rather than in code, but they appear in scripts as ordinary global identifiers:

IF gs_window_type = 1 THEN
    CALL "casement_sash" PARAMETERS sash_width = A,
                                    sash_height = B
ELSE
    CALL "fixed_pane"    PARAMETERS pane_width = A,
                                    pane_height = B
ENDIF

The CALL mechanism lets one library part instantiate another, passing parameters by name — a form of composition that lets manufacturers build large libraries of related products on top of shared sub-parts.

Multiple scripts per object

A typical GDL library part includes several scripts that are evaluated for different purposes:

• 3D script — generates the volumetric model used in 3D views.
• 2D script — generates the plan-view symbol (often a stylised representation rather than a literal projection).
• Parameter (or properties) script — validates parameter values and computes derived values.
• Master script — shared initialisation run before the others.
• UI script — customises the parameter-editing dialog presented to the user.

This separation lets a single object behave appropriately in plan, section, elevation, 3D, and quantity-take-off contexts without forcing all of those representations through a single generator.

Subroutines and macros

GDL provides GOSUB/RETURN style subroutines within a script and, more powerfully, the CALL mechanism for invoking another library part as a macro. The macro approach is the dominant means of structuring large libraries: a window library, for instance, might decompose a complete window into separately scripted frames, sashes, sills, casings, and glazing patterns, each parameterised and composed by the top-level part.

Architecture and Tooling

GDL is not a free-standing language with its own compiler. It is interpreted by the Archicad runtime, which evaluates the appropriate script of a library part each time the part is rendered, placed, edited, or listed. GDL source lives inside library-part files (the .gsm format and related extensions), which package the scripts, the parameter list, preview images, and ancillary data into a single bundle that can be distributed and indexed by Archicad.

Editing GDL is normally done inside Archicad’s built-in library-part editor, which presents the scripts in separate tabs alongside the parameter list and a live preview. Third-party text editors are sometimes used by authors who maintain large libraries under version control, with the scripts extracted from the library-part bundle for editing and re-packaged for distribution.

Platform Support

GDL runs wherever Archicad runs. According to Graphisoft’s official documentation, recent Archicad versions are distributed for Microsoft Windows and macOS; GDL is available on the same platforms as a component of those distributions. There is no open-source or platform-independent GDL implementation outside of Archicad, and so the language’s platform reach is, in practice, the platform reach of the host product. Users who need to read or edit GDL scripts without a full Archicad licence have, historically, relied on the demo version of Archicad or on third-party utilities that can open .gsm files.

Community and Ecosystem

The GDL community is organised around the Archicad user base rather than around the language itself. Significant resources include:

• Graphisoft’s official GDL Center and reference documentation, which describe the language, its primitives, and the library-part file format.
• BIM-object portals — Graphisoft’s own past portals and third-party services such as BIMobject — through which manufacturers publish GDL representations of their products for use by architects.
• User forums and community sites run by Graphisoft and by independent Archicad communities, in which experienced GDL authors trade techniques for difficult cases (curved railings, parametric stairs, complex sashes).
• Architectural offices that develop in-house GDL libraries, sometimes shared as part of office templates between collaborating practices.

The audience is small compared with mainstream programming languages, but it is durable: GDL has been in continuous use by working architects for around four decades.

Current Relevance

GDL remains the established way to author parametric library parts in Archicad. Newer Archicad releases have introduced complementary extension mechanisms — Python integration for automation, a more visual property-set system for non-geometric metadata, and tighter integration with formats such as IFC — but GDL continues to occupy the central role for parametric geometric content inside the product. The vast existing inventory of GDL library parts, accumulated over decades by Graphisoft, manufacturers, and architecture offices, gives the language a strong installed-base advantage that any in-place replacement would have to contend with.

For the practising Archicad user, GDL is often the boundary between using the product and extending it. Customising or correcting a library part — even a small change to a window casing or a stair stringer — invariably leads back to a GDL script.

Why It Matters

GDL is an instructive example of a domain-specific language that has quietly served its domain for four decades. It is not on language-popularity rankings and has not produced its own ecosystem of conferences or compilers; yet it sits underneath a sizeable share of the world’s architectural BIM models, embedded in every parametric Archicad library part.

It is also a useful counterpoint to the assumption that scripting languages aimed at non-programmers must be either toy languages or short-lived. GDL chose a BASIC-shaped surface deliberately, accepted the trade-offs that came with that choice, and used the resulting accessibility to bring scripting into the daily work of architects who never wanted to be software engineers. The fact that it is still doing so, several Archicad generations later, is part of the language’s quiet success story.