Install VS Code & the 12dPL Extension

The recommended way to write 12dPL is in Visual Studio Code with the 12dPL Language extension installed. You get syntax highlighting, autocompletion for 3000+ library calls, hover documentation, go-to-definition, and inline diagnostics.

Step 1 — Install VS Code

Download and install VS Code from the official site:

• code.visualstudio.com/Download

Pick the installer for your platform (Windows / macOS / Linux) and run it with the default options.

Step 2 — Install the 12dPL Language extension

Inside VS Code:

1. Open the Extensions view — Ctrl+Shift+X on Windows/Linux, Cmd+Shift+X on macOS.
2. Search for 12dPL Language (publisher: nightworks).
3. Click Install.

Or install it from the command line:

code --install-extension nightworks.12dpl-lang-server

Marketplace link: 12dPL Language on the VS Code Marketplace.

Step 3 — Open a 12dPL file

Open any .4dm or .4do file in VS Code. The extension activates automatically, and you'll get colorisation, completions, and diagnostics from that point on.

Compiling & Running a 12dPL Program

A 12dPL program consists of one file containing a starting function called main, and zero or more user-defined functions. The filename must end in .4dm.

Step 1 — Write your macro

Create a file called mymacro.4dm:

void main()
{
    Print("Macro running!\n");
}

Step 2 — Compile

You can compile in three ways:

A. From inside 12d Model

Utilities => Macros => Compile
Utilities => Macros => Compile/run

B. Drag-and-drop

Drop a .4dm file onto an open 12d Model window. The Compile/Run a Macro panel appears automatically.

C. Command line (outside 12d Model)

"C:\Program Files\12d\12dmodel\15.00\nt.x64\cc4d.exe" mymacro.4dm

# With error log:
"C:\Program Files\12d\12dmodel\15.00\nt.x64\cc4d.exe" -log mymacro.4dl mymacro.4dm

The compiler checks syntax and, if there are no errors, creates mymacro.4do — the compiled object ready to run.

Step 3 — Run

To run a compiled .4do file from within 12d Model:

Utilities => Macros => Run

Select the .4do file from the list, optionally add command-line arguments, and click Run.

Alternatively, drag-and-drop a .4do file onto 12d Model to run it directly.

Mouse Conventions

In this documentation, mouse buttons are referred to as:

Basic Language Structure

A 12dPL program is a text file (ending in .4dm) that contains a mandatory main function and zero or more user-defined functions. The language is case-sensitive.

Topics in this section:

• Names & Reserved Words
• Comments & Whitespace
• Preprocessing (#include)

Names & Reserved Words

Names

A name denotes an object, function, enumerator, type, or value. Rules:

• Must start with an alphabetic character (a–z, A–Z)
• Can contain letters, digits (0–9), and underscores (_)
• No length restriction
• Case-sensitive — MyVar and myvar are different
• Must be declared before use

Reserved Keywords

The following names cannot be used for user-defined variables or functions:

Built-in Types

C++ Control Keywords

Container Type Keywords

Container keywords follow the pattern $KeyType_$KeyType_Map, $KeyType_Set, etc., where $KeyType is one of: Integer, Integer64, Real, Text, Uid, Guid, Point, Vector2, Vector3, Vector4.

Examples: Real_Set, Text_Multiset, Integer_Text_Multimap

Comments & Whitespace

Whitespace

Spaces, tabs, newlines, and form feeds are all whitespace and are ignored except for separating tokens or inside quoted strings. Blank lines are ignored.

Comments

12dPL supports two comment styles identical to C++:

// Line comment — everything from // to end of line is ignored

/* Block comment — everything between /* and */ is ignored,
   and can span multiple lines */

Example

void main()
{
    Real y = 1; // the rest of this line is a comment

    /* this comment can carry
       over many lines until
       we reach the termination characters */
}

Preprocessing (#include)

You can include other files using the #include directive:

#include "filename"

Example

// file: helpers.h
Point Coord(Real x, Real y, Real z)
{
    Point p;
    Set_x(p, x);
    Set_y(p, y);
    Set_z(p, z);
    return(p);
}

// file: mymacro.4dm
#include "helpers.h"

void main()
{
    Point p = Coord(10.0, 20.0, 2.34);
}

#include "set_ups.h"

void main()
{
    // set_ups.h constants now available
}

Variables & Types

Variables must be declared before use. A declaration consists of a type followed by a comma-separated list of names ending with a semicolon.

Integer fred, joe, tom;
Real x = 1.0, y = 2.0;
Text message = "Hello";

12dPL has a rich type system organised into these categories:

Mathematical Variable Types

Standard variables for arithmetic calculations. They exist only during macro execution.

Automatic Promotions

The following promotions happen automatically when matching function arguments or return types:

Geometric Construction Types

These are temporary in-memory objects used for geometric calculations. They are not stored in 12d Model models.

Point p;
Set_x(p, 100.0);
Set_y(p, 200.0);
Set_z(p, 10.5);

Database Handles

Unlike construction entities, these variables act as handles to data stored in the 12d Model project database. The data persists after the macro terminates.

Element Types

The type of an Element is returned by Get_type(Element elt, Text &type):

Element elt;
Text elt_type;
Get_type(elt, elt_type);
if (elt_type == "Super") {
    Print("It's a Super string!\n");
}

12d Internal Variable Types

These types help access and manage data stored via database handles.

Interface Variable Types

These types are used to build interactive GUI panels and communicate with macro users. All are derived from Widget.

Core Layout Types

Input Controls

File Interface Variable Types

ODBC Database Variable Types

These types provide access to external ODBC databases from within a macro.

Arrays

12dPL supports two kinds of arrays: fixed-size and dynamic.

Fixed Arrays

Size is specified at declaration (can be a literal or a previously-assigned variable). Size is fixed after declaration.

Real real_array[100];    // 100 Reals, indexed 1..100

Integer N = 50;
Text text_array[N];      // 50 Texts (size fixed at this line)

real_array[10] = 3.14;   // access item 10

Dynamic Arrays

Dynamic arrays can grow or shrink at runtime. Items are accessed through function calls, not subscript notation.

Dynamic_Element elts;
Integer num_elts;
Get_elements(model, elts, num_elts);

for (Integer i = 1; i <= num_elts; i++) {
    Element e;
    Get_item(elts, i, e);
    // process element e
}

Constants (Literals)

Integer Constants

Any sequence of decimal digits. Constants ≥ 2³¹ are automatically treated as 64-bit integers. Append LL to force 64-bit.

Integer  a = 1;
Integer  b = 76875;
Integer64 big = 123LL;
Integer64 huge = -123456789123;  // auto 64-bit

Real Constants

Must include a decimal point. Optional fractional part and optional exponent (e or E).

Real x = 6.;
Real y = 1.0;
Real z = 1.0e+1;   // 10.0
Real w = .1e+2;    // 10.0
// Note: 1e1 is NOT valid — decimal point is mandatory

Text Constants

A sequence of characters enclosed in double quotes. Supports escape sequences:

Text s1 = "Hello, world!";
Text s2 = "She said \"hello\"";  // embedded double quote
Text s3 = "Line1\nLine2";        // newline
Text s4 = "back\\slash";         // backslash

Operators

Arithmetic Operators

Relational Operators

Logical Operators

Increment / Decrement

i++;   // post-increment: i = i + 1
i--;   // post-decrement: i = i - 1
++i;   // pre-increment
--i;   // pre-decrement

Bitwise Operators

Assignment Operators

x = y;     // assignment
x += 2;    // x = x + 2
x -= 2;    // x = x - 2
x *= 2;    // x = x * 2
x /= 2;    // x = x / 2
x %= 2;    // x = x % 2

Operator Precedence (high → low)

Flow Control

12dPL supports the standard C++ flow control statements. In a program, a logical expression evaluates to true if its value is non-zero, false if zero.

• if / else / else if
• Conditional expression (? :)
• switch
• while, for, do while
• goto and labels

if / else / else if

if

if (x == 5) {
    x = x + 1;
    y = x * y;
}

if / else

if (x > 0) {
    Print("positive\n");
} else {
    Print("non-positive\n");
}

else if

if (x > 0) {
    Print("positive\n");
} else if (x < 0) {
    Print("negative\n");
} else {
    Print("zero\n");
}

Conditional Expression (Ternary)

The ? : operator provides a concise inline if-else:

// y = absolute value of x
Real y = (x >= 0) ? x : -x;

switch

Evaluates an expression and jumps to the matching case. Supports Integer, Integer64, Real, and Text expressions.

switch (a) {
    case 1 : {
        x = y;
        break;
    }
    case 2: {
        x = y + 1;
        z = x * y;
        // no break — falls through to case 3
    }
    case 3: case 4: {
        x = z + 1;
        break;
    }
    default : {
        y = z + 2;
        break;
    }
}

switch with Text

Text cmd = "write";
switch (cmd) {
    case "write": {
        Print("Writing...\n");
        break;
    }
    case "read": {
        Print("Reading...\n");
        break;
    }
    default: {
        Print("Unknown command\n");
        break;
    }
}

Loops

while

Integer x = 10;
Real product = 1.0;
while (x > 0) {
    product = product * x;
    x = x - 1;
}

for

// Sum numbers 1..10
Integer j = 0;
for (Integer i = 1; i <= 10; i++) {
    j = j + i;
}

Any part of the for header can be omitted (the semicolons must remain). If the test is omitted it is taken as permanently true.

do while

Integer i = 1;
do {
    x = x + i;
    i++;
} while (i < 10);

break

Exits the innermost for, while, do while, or switch:

for (Integer i = 1; i <= 100; i++) {
    if (i == 50) break;  // stop at 50
}

continue

Skips to the next iteration of the innermost loop:

for (Integer i = 1; i <= 10; i++) {
    if (i % 2 == 0) continue;  // skip even numbers
    Print(To_text(i) + "\n");
}

goto and Labels

A label is a name followed by a colon and can be attached to any statement in a function. goto transfers control to the labelled statement.

for (Integer i = 1; i <= 10; i++) {
    if (some_error_condition) goto error;
}

Print("Success\n");
return;

error:
Print("An error occurred\n");

Functions

Functions break tasks into reusable units. Communication is via arguments, return values, and global variables.

• main() — entry point
• User-Defined Functions
• Function Prototypes
• Pass by Value / Reference
• Overloading
• Recursion
• Blocks & Scopes

All 12dPL supplied functions start with a capital letter. Function names are case-sensitive.

main() Function

Every 12dPL program must have exactly one main function. It is the entry point when a macro is run.

void main()
{
    // your program code here
}

main is a void function — it returns nothing. It terminates when:

• The last line of code is executed, or
• A return; statement is encountered

User-Defined Functions

User-defined functions must be defined before their first call in the file (or declared via a prototype — see below).

// Function definition — must come before main() or have a prototype
Integer add_values(Integer a, Integer b)
{
    return(a + b);
}

void main()
{
    Integer result = add_values(10, 20);
    Print(To_text(result) + "\n");  // prints 30
}

Return Statement

Non-void functions must have a return as their last statement. Void functions use return; (or just fall off the end).

Integer user_function(Integer fred, Real joe, Element tom)
{
    // ... code ...
    return(0);  // must be last statement in non-void function
}

Function Prototypes

A prototype declares a function's signature so it can be called before its definition appears in the file.

// Prototype (note the semicolon and no body)
Integer user_function(Integer fred, Real joe, Element tom);
// or omitting parameter names:
Integer user_function(Integer, Real, Element);

void main()
{
    Integer r = user_function(1, 2.0, elt);  // OK — prototype exists
}

// Actual definition can appear after main
Integer user_function(Integer fred, Real joe, Element tom)
{
    // ...
    return(0);
}

Passing by Value / Reference

By Value (default)

A copy of the argument is passed. Changes inside the function do not affect the caller.

void bad_square(Integer x)
{
    x = x * x;  // only modifies the local copy
}

void main()
{
    Integer x = 10;
    bad_square(x);
    // x is still 10
}

By Reference (&)

Place & after the type to pass by reference. Changes inside the function affect the original variable. Used whenever a function needs to return values through its arguments.

void square(Integer &x)
{
    x = x * x;  // modifies the caller's variable
}

void main()
{
    Integer x = 10;
    square(x);
    // x is now 100
}

// Real-world example: Get_name returns the name via a reference argument
Text name;
Get_name(element, name);  // name is filled in by Get_name
Print(name + "\n");

Function Overloading

Multiple functions can share the same name if they differ in argument count or types. 12dPL selects the correct version automatically.

void swap(Integer &x, Integer &y) { Integer z = x; x = y; y = z; }
void swap(Real &x, Real &y)      { Real    z = x; x = y; y = z; }
void swap(Text &x, Text &y)      { Text    z = x; x = y; y = z; }

void main()
{
    Integer ix = 1, iy = 2;
    Real    rx = 1.0, ry = 2.0;
    Text    tx = "a", ty = "b";

    swap(ix, iy);  // calls Integer version
    swap(rx, ry);  // calls Real version
    swap(tx, ty);  // calls Text version
}

Recursion

12dPL supports recursive functions.

// Fibonacci sequence
Integer fib(Integer n)
{
    return n < 2 ? 1 : fib(n - 1) + fib(n - 2);
}

void main()
{
    for (Integer i = 0; i <= 10; i++) {
        Print(To_text(fib(i)) + "\n");
    }
}

Blocks & Scopes

A block is code enclosed in {}. Blocks can be nested. Three scope levels exist:

// Global variables — must be wrapped in braces
{
    Integer global_count;
    Real    global_total;
}

void main()
{
    Integer a = 1;         // local to main

    {
        Integer x = 10;    // local to this inner block
        global_count = x;  // OK — global_count is visible here
    }
    // x is NOT accessible here

    {
        Real x = 10.0;     // different x — local to this block
        global_total = x;
    }
}

Library Overview

12dPL provides over 1,000 built-in functions organized into categories. All library functions start with a capital letter. Most return 0 on success and non-zero on failure.

Function Return Codes

The general convention is:

• 0 — success
• Non-zero — error or special condition

Library Categories

Text Functions

Commonly Used Functions

String Concatenation

Text a = "Hello";
Text b = " World";
Text c = a + b;                    // "Hello World"
Text msg = "Count: " + To_text(42); // "Count: 42"

Example

void main()
{
    Text name;
    Get_name(element, name);
    Integer n = Text_length(name);
    Print("Name: " + name + " (" + To_text(n) + " chars)\n");
}

Math Functions

Real pi = Pi();
Real angle_rad = 45.0 * pi / 180.0;
Real s = Sin(angle_rad);
Real c = Cos(angle_rad);
Print("sin(45°) = " + To_text(s) + "\n");

Input / Output

Console Output

Print("Hello\n");                       // write to output window
Print("Value = " + To_text(42) + "\n");
Clear_console();                        // clear the output window

File Operations

File f;
File_open("output.txt", "w", "ccs=UNICODE", f);
File_write_line(f, "First line");
File_write_line(f, "Second line: " + To_text(value));
File_flush(f);
File_close(f);

File Prompt

Text file_name;
File_prompt("Select output file", "*.txt", file_name);
File f;
File_open(file_name, "w", "ccs=UNICODE", f);

Message Prompts

// Show a message dialog
Error_prompt("Something went wrong!");

// Prompt for a yes/no answer
Integer answer = Yes_no_prompt("Continue?");

Elements & Models

Getting Element Information

Element elt;
Text    name, type;
Integer colour, num_verts;
Model   model;

Get_name(elt, name);      // get element name
Get_type(elt, type);      // get element type string ("Super", "Tin", etc.)
Get_colour(elt, colour);  // get colour index
Get_points(elt, num_verts); // get number of vertices
Get_model(elt, model);    // get the model containing this element

Modifying Elements

Set_name(elt, "New Name");
Set_colour(elt, 3);
Element_draw(elt);  // redraw the element on screen immediately

Iterating Elements in a Model

Model model = Get_model("My Model");
Dynamic_Element elts;
Integer num_elts;

Get_elements(model, elts, num_elts);

for (Integer i = 1; i <= num_elts; i++) {
    Element e;
    Get_item(elts, i, e);
    Text name;
    Get_name(e, name);
    Print(name + "\n");
}

Super String Vertex Coordinates

Element super_str;
Integer n;
Get_points(super_str, n);

for (Integer i = 1; i <= n; i++) {
    Real x, y, z;
    Get_super_vertex_coord(super_str, i, x, y, z);
    Print("  [" + To_text(i) + "] x=" + To_text(x)
          + " y=" + To_text(y) + " z=" + To_text(z) + "\n");
}

Panels & Widgets

12dPL provides a complete GUI framework for building interactive macro dialogs.

Basic Panel Pattern

#include "set_ups.h"

void main()
{
    // 1. Create the panel and widgets
    Panel panel        = Create_panel("My Panel Title");
    Message_Box msg    = Create_message_box("Ready");
    Input_Box input    = Create_input_box("Name", msg);
    Button ok_btn      = Create_finish_button("OK", "ok_reply");

    // 2. Layout with groups
    Vertical_Group vg  = Create_vertical_group(0);
    Append(input, vg);
    Append(msg, vg);

    Horizontal_Group hg = Create_button_group();
    Append(ok_btn, hg);
    Append(hg, vg);
    Append(vg, panel);

    // 3. Show the panel
    Show_widget(panel);

    // 4. Event loop
    Integer running = 1;
    while (running) {
        Integer id; Text cmd, msg_text;
        Wait_on_widgets(id, cmd, msg_text);

        switch (id) {
            case Get_id(panel): {
                if (cmd == "Panel Quit") running = 0;
                break;
            }
            case Get_id(ok_btn): {
                if (cmd == "ok_reply") running = 0;
                break;
            }
        }
    }
}

Key Panel Functions

Common Widget Creators

Model_Box  mb = Create_model_box("Model", msg, CHECK_MODEL_EXISTS);
File_Box   fb = Create_file_box("File", msg, CHECK_FILE_NEW, "*.txt");
Real_Box   rb = Create_real_box("Value", msg, 0.0);
Tick_Box   tb = Create_tick_box("Enabled", msg);
Choice_Box cb = Create_choice_box("Option", msg, "A|B|C");
Colour_Box colb = Create_colour_box("Colour", msg);
Name_Box   nb   = Create_name_box("Name", msg);

Dynamic Arrays

Dynamic arrays grow at runtime and are accessed through function calls (not subscript notation). Indices start at 1.

Dynamic_Text Example

Dynamic_Text items;
Integer count = 0;

// Add items
Add_item(items, count, "Apple");
Add_item(items, count, "Banana");
Add_item(items, count, "Cherry");

// Iterate
for (Integer i = 1; i <= count; i++) {
    Text item;
    Get_item(items, i, item);
    Print(item + "\n");
}

Key Dynamic Array Functions

Library Reference

Every built-in 12dPL function with its signature, parameters and description. Data is sourced from the 12dpl-lang-server dev branch, which extracts the official PDF manual into a structured form.

Type Reference

The 12dPL type system covers primitive numbers, geometric primitives, database handles, file handles, UI widgets and dynamic containers. Descriptions below come from the language server’s typeDocumentation.json (extracted from the official manual).

Snippets Gallery

Ready-to-use code snippets for the most common 12dPL constructs. These mirror the snippets bundled with the VS Code language server, so trigger the matching prefix in your editor for the same expansion. Click Copy to grab a snippet straight into your clipboard.

Code Examples

Example 1 — Hello World

void main()
{
    Print("Hello, 12d World!\n");
}

Example 2 — Write Model Elements to a File

// write_model.4dm
// Writes all element names in a model to a report file

Integer write_out_model(Model model, File file)
{
    Text model_name;
    Dynamic_Element model_elts;
    Integer num_elts, ierr;

    ierr = Get_name(model, model_name);
    if (ierr != 0) return(ierr);

    Uid model_uid;
    Get_id(model, model_uid);
    File_write_line(file, "Model uid " + To_text(model_uid));

    Get_elements(model, model_elts, num_elts);
    File_write_line(file, "There are " + To_text(num_elts)
                         + " elements in: " + model_name);

    for (Integer i = 1; i <= num_elts; i++) {
        Element e;
        Get_item(model_elts, i, e);

        Text ename, etype;
        Get_name(e, ename);
        Get_type(e, etype);

        Integer num_verts;
        Get_points(e, num_verts);

        File_write_line(file, ename + "\t" + etype
                             + "\t" + To_text(num_verts) + " verts");
    }

    File_flush(file);
    File_close(file);
    return(0);
}

void main()
{
    Text model_name;
    Model model;
    while (!Model_exists(model)) {
        Model_prompt("Select a model", model_name);
        model = Get_model(model_name);
    }

    Text file_name;
    File_prompt("Enter file name", "*.rpt", file_name);

    File f;
    File_open(file_name, "w", "ccs=UNICODE", f);
    write_out_model(model, f);
}

Example 3 — Interactive Panel with String Selection

// string_info.4dm
// Panel to select a Super string and report its vertex count and dimensions
#include "set_ups.h"

void main()
{
    Panel panel             = Create_panel("String Info");
    Message_Box msg         = Create_message_box("");
    New_Select_Box sel      = Create_new_select_box("Select string",
                                  "Pick a string", SELECT_STRING, msg);
    Button finish           = Create_finish_button("Finish", "finish_reply");

    Vertical_Group vg       = Create_vertical_group(0);
    Append(sel, vg);
    Append(msg, vg);

    Horizontal_Group hg     = Create_button_group();
    Append(finish, hg);
    Append(hg, vg);
    Append(vg, panel);
    Show_widget(panel);
    Clear_console();

    Integer running = 1;
    while (running) {
        Integer id; Text cmd, wmsg;
        Wait_on_widgets(id, cmd, wmsg);

        switch (id) {
            case Get_id(panel): {
                if (cmd == "Panel Quit") running = 0;
                break;
            }
            case Get_id(finish): {
                if (cmd == "finish_reply") running = 0;
                break;
            }
            case Get_id(sel): {
                if (cmd == "accept select") {
                    Element str; Integer ierr;
                    ierr = Validate(sel, str);
                    if (ierr != TRUE) {
                        Set_data(msg, "Invalid selection");
                        break;
                    }
                    Integer n;
                    Get_points(str, n);

                    Integer use2d, use3d;
                    Get_super_use_3d_level(str, use3d);
                    Get_super_use_2d_level(str, use2d);

                    Text info = To_text(n) + " vertices";
                    if      (use3d == 1) info += " — 3D (Att_ZCoord_Array)";
                    else if (use2d == 1) info += " — 2D (Att_ZCoord_Value)";
                    else                info += " — no Z dimension";

                    Set_data(msg, info);
                }
                break;
            }
        }
    }
}

Example 4 — Recursive Fibonacci

Integer fib(Integer n)
{
    return n < 2 ? 1 : fib(n - 1) + fib(n - 2);
}

void main()
{
    for (Integer i = 0; i <= 10; i++) {
        Print("fib(" + To_text(i) + ") = " + To_text(fib(i)) + "\n");
    }
}

Example 5 — Change String Name and Colour

// change_string.4dm — optional Name and Colour boxes
#include "set_ups.h"

void main()
{
    Panel panel         = Create_panel("Change String Name & Colour");
    Message_Box msg     = Create_message_box("");
    New_Select_Box sel  = Create_new_select_box("Select string",
                              "Pick a string", SELECT_STRING, msg);
    Name_Box   nb       = Create_name_box("New name", msg);
    Colour_Box cb       = Create_colour_box("New colour", msg);
    Button finish       = Create_finish_button("Finish", "finish_reply");

    Set_optional(nb, 1);  // name is optional
    Set_optional(cb, 1);  // colour is optional

    Vertical_Group vg   = Create_vertical_group(0);
    Append(nb, vg);
    Append(cb, vg);
    Append(sel, vg);
    Append(msg, vg);

    Horizontal_Group hg = Create_button_group();
    Append(finish, hg);
    Append(hg, vg);
    Append(vg, panel);
    Show_widget(panel);

    Integer running = 1;
    while (running) {
        Integer id; Text cmd, wmsg;
        Wait_on_widgets(id, cmd, wmsg);

        switch (id) {
            case Get_id(panel): {
                if (cmd == "Panel Quit") running = 0;
                break;
            }
            case Get_id(finish): {
                if (cmd == "finish_reply") running = 0;
                break;
            }
            case Get_id(sel): {
                if (cmd == "accept select") {
                    Element str; Integer ierr;
                    ierr = Validate(sel, str);
                    if (ierr != TRUE) { Set_data(msg, "Invalid"); break; }

                    Text new_name; Integer new_colour;
                    Integer vn = Validate(nb, new_name);
                    Integer vc = Validate(cb, new_colour);

                    if (vn == FALSE) { Set_data(msg, "Name error"); break; }
                    if (vc == FALSE) { Set_data(msg, "Colour error"); break; }

                    if (vn != NO_NAME) Set_name(str, new_name);
                    if (vc != NO_NAME) {
                        Set_colour(str, new_colour);
                        Element_draw(str);
                    }
                    Set_data(msg, "Changes applied");
                }
                break;
            }
        }
    }
}

Type Quick Reference

All 12dPL Types at a Glance

About & Legal Disclaimer

12dPL Docs is a community-maintained reference for the 12d Model Programming Language. It is built automatically from the open-source 12dpl-lang-server project so the function, type, and snippet listings stay in sync with the editor tooling.

What this site is

• A searchable, browsable view of the 3,000+ 12dPL library calls and ~360 built-in types.
• A reference for the snippets bundled with the VS Code extension.
• An overview of language structure, types, operators, flow control, and common examples.

What this site is not

This site is not official 12dPL documentation. It is a community-maintained reference and is not a replacement for the official 12d Model Programming Language manual or any documentation produced by 12d Solutions Pty Ltd.

Legal

• No affiliation. This project is independent and is not affiliated with, endorsed by, sponsored by, or in any way officially connected to 12d Solutions Pty Ltd or any of its subsidiaries. "12d", "12d Model", and related names are trademarks of their respective owners and are used here for descriptive purposes only.
• Source of content. Function signatures, type names, and descriptions are derived from publicly available references and the open-source 12dpl-lang-server project. Content may be incomplete, outdated, or contain errors.
• No warranty. All information is provided "as is", without warranty of any kind, express or implied, including but not limited to warranties of merchantability, fitness for a particular purpose, accuracy, or non-infringement.
• Limitation of liability. The maintainers and contributors of this site shall not be liable for any direct, indirect, incidental, special, consequential, or exemplary damages arising from the use of, or inability to use, this site or its content — including but not limited to data loss, lost profits, or business interruption — even if advised of the possibility of such damages.
• Use at your own risk. You are solely responsible for verifying any information from this site against the official 12d Model documentation before relying on it for production work, safety-critical work, contractual deliverables, or compliance purposes.
• Licensing. The website source is released under the MIT License. Trademarks, product names, and any third-party content remain the property of their respective owners.
• Reporting issues. If you believe content on this site is inaccurate or infringes on rights you hold, please open an issue on the project issue tracker and we will review it promptly.

For official, authoritative 12dPL documentation, please consult the manual provided by 12d Solutions.

© 2026 12dpl-lang-server contributors. Site content released under MIT.