With id

ImGui hashes a widget’s identifier into the ID stack to detect clicks, remember imgui.ini state, and tag draw-list entries. The boost layer piggybacks on the same hash for its telemetry path. When two render sites need to share a widget identifier — composed helpers, two panes showing the same kind of control, a button rendered under two scopes — the boost ships three knobs for sorting out the collision:

with_id("scope") { ... } pushes "scope" onto both ImGui’s ID stack and the boost path, so two scopes contain the same widget identifier without collision.
widget(IDENT, (id = "x")) mangles only ImGui’s hash — useful when the daslang identifier may get renamed but the imgui.ini state and any hex_id-driven scripts must stay stable.
widget(IDENT, (path = "x")) replaces the registry path leaf — the daslang identifier still names the global; "x" is what external drivers target via imgui_force_set / imgui_click.

Source: examples/tutorial/with_id.das.

Walkthrough

options gen2

require imgui
require imgui_app
require opengl/opengl_boost
require live/glfw_live
require live/live_api
require live/live_commands
require live/live_vars
require live_host
require imgui/imgui_live
require imgui/imgui_boost_runtime
require imgui/imgui_boost_v2
require imgui/imgui_widgets_builtin
require imgui/imgui_containers_builtin
require imgui/imgui_id_builtin
require imgui/imgui_visual_aids

// =============================================================================
// TUTORIAL: with_id — scope IDs and registry paths for composed render sites.
//
// Each widget's ImGui hash is derived from its identifier — the same global
// rendered at two sites would hash to the same value and collide. The boost
// already enforces "single-global rendered exactly once per frame" at the
// registry level (loops want the indexed form `IDENT[i]`), but real apps
// still need to compose helpers that surface the same widget kind under
// distinct labels. Three knobs cover the cases:
//
//   with_id("scope") { ... }         — push "scope" onto BOTH the ImGui ID
//                                      stack AND the boost path. Distinct
//                                      scopes → distinct hex_ids AND distinct
//                                      registry paths.
//   widget(IDENT, (id = "x"))        — mangle ImGui's hash with "x" only;
//                                      telemetry path stays the bare
//                                      identifier (script-stable across
//                                      label renames; preserves imgui.ini).
//   widget(IDENT, (path = "x"))      — replace the telemetry path leaf with
//                                      "x"; the bare identifier still names
//                                      the daslang global. Mangles BOTH the
//                                      path AND the ImGui hash.
//
// STANDALONE: daslang.exe modules/dasImgui/examples/tutorial/with_id.das
// LIVE:       daslang-live modules/dasImgui/examples/tutorial/with_id.das
//
// DRIVE (when running live):
//   curl -X POST -d '{"name":"imgui_snapshot"}'                                                       localhost:9090/command
//   curl -X POST -d '{"name":"imgui_click","args":{"target":"ID_WIN/section_a/SAVE_BTN"}}'             localhost:9090/command
//   curl -X POST -d '{"name":"imgui_click","args":{"target":"ID_WIN/section_b/SAVE_BTN"}}'             localhost:9090/command
//   curl -X POST -d '{"name":"imgui_force_set","args":{"target":"ID_WIN/rps_stable","value":0.7}}'           localhost:9090/command
// =============================================================================

[export]
def init() {
    live_create_window("dasImgui with_id tutorial", 720, 520)
    live_imgui_init(live_window)
    let io & = unsafe(GetIO())
    GetStyle().FontScaleMain = 1.5
}

[export]
def update() {
    if (!live_begin_frame()) return
    begin_frame()

    ImGui_ImplGlfw_NewFrame()
    apply_synth_io_override()
    NewFrame()

    SetNextWindowPos(ImVec2(30.0f, 30.0f), ImGuiCond.FirstUseEver)
    SetNextWindowSize(ImVec2(640.0f, 440.0f), ImGuiCond.FirstUseEver)
    window(ID_WIN, (text = "with_id", closable = false,
                    flags = ImGuiWindowFlags.None)) {

        // ---- with_id scope: same widget, two render sites ----
        // SAVE_BTN is a single-global widget. Without with_id, rendering it
        // twice would panic at end-of-frame (registry detects N>1). Each
        // scope contributes a path segment AND a PushID, so the registry
        // sees ID_WIN/section_a/SAVE_BTN and ID_WIN/section_b/SAVE_BTN as
        // distinct entries with distinct ImGui hashes.
        text("Same SAVE_BTN, two scopes:")
        with_id("section_a") {
            button(SAVE_BTN, (text = "Save in A"))
        }
        with_id("section_b") {
            button(SAVE_BTN, (text = "Save in B"))
        }
        text("SAVE_BTN.click_count aggregates: {SAVE_BTN.click_count}")

        separator(WI_SEP_1)

        // ---- Nested chains: outer scope, inner scope, leaf widget ----
        // The path is the chain joined by "/": ID_WIN/outer/inner/NESTED_BTN.
        text("Nested with_id chains:")
        with_id("outer") {
            with_id("inner") {
                button(NESTED_BTN, (text = "Nested deep"))
            }
        }

        separator(WI_SEP_2)

        // ---- id= per-call: stable ImGui hash across label renames ----
        // The button's daslang identifier (HASHED_BTN) controls visibility
        // and live-reload; the imgui hash is mangled by "stable_v1" so
        // scripts targeting the widget by hex_id, and imgui.ini state for
        // this button, stay stable even if HASHED_BTN is later renamed.
        // Telemetry path stays ID_WIN/HASHED_BTN.
        text("Per-call id= - script-stable ImGui hash:")
        button(HASHED_BTN, (text = "Hashed via id=", id = "stable_v1"))

        separator(WI_SEP_3)

        // ---- path= per-call: stable telemetry path across renames ----
        // RPS_PATH is the daslang global (rename it and the variable
        // reference breaks). "rps_stable" is the registry path leaf — the
        // imgui_force_set / imgui_click string used by external drivers. Both the
        // path AND the ImGui hash adopt "rps_stable".
        text("Per-call path= - script-stable telemetry path:")
        slider_float(RPS_PATH, (text = "Speed (path=)",
                                path = "rps_stable"))
    }

    end_of_frame()
    Render()
    var w, h : int
    live_get_framebuffer_size(w, h)
    glViewport(0, 0, w, h)
    glClearColor(0.10f, 0.10f, 0.12f, 1.0f)
    glClear(GL_COLOR_BUFFER_BIT)
    live_imgui_render()

    live_end_frame()
}

[export]
def shutdown() {
    live_imgui_shutdown()
    live_destroy_window()
}

[export]
def main() {
    init()
    while (!exit_requested()) {
        update()
    }
    shutdown()
}

Requires

One extra module on top of the baseline boost layer:

imgui/imgui_id_builtin — defines with_id(s) { ... } and wires the id= / path= named-arg sugar for every widget macro.

The single-render rule

Single-global widgets render exactly once per frame. Two violations collapse into one runtime panic at end-of-frame:

Single-global widget inside a for loop (would render N times) — the boost macro can usually catch this lexically and macro_error at expansion with a fixit pointing at the indexed form IDENT[i] / IDENT[key] (see Widgets tour for the indexed form).
Single-global widget called from two distinct sites (e.g. shown in two windows at once) — when the macro can’t see the second site lexically, the runtime registry catches it and panics.

with_id is the explicit ID-stack push for case 2 when the indexed form can’t reach (composed helpers, sub-tree data-driven structure).

with_id scopes

Each with_id("scope") { ... } block pushes "scope" onto two stacks: ImGui’s ID stack (so child widgets get distinct hashes) and the boost registry path (so child entries register under distinct paths). Both pop on block exit:

with_id("section_a") {
    button(SAVE_BTN, (text = "Save in A"))
}
with_id("section_b") {
    button(SAVE_BTN, (text = "Save in B"))
}

The two renders show up in the snapshot as ID_WIN/section_a/SAVE_BTN and ID_WIN/section_b/SAVE_BTN — distinct paths AND distinct ImGui hashes. SAVE_BTN.click_count is one global; clicks on either button increment the same counter. If you need separate counters, switch to SAVE_BTN[key] indexed-widget form instead.

Nested chains

with_id chains nest. Each scope contributes one path segment, and the leaf widget’s registry path is the chain joined by /:

with_id("outer") {
    with_id("inner") {
        button(NESTED_BTN, (text = "Nested deep"))
    }
}
// registry path: ID_WIN/outer/inner/NESTED_BTN

with_id doesn’t register a container entry of its own — only the path segment. The leaf widget’s entry is what shows up in the snapshot.

Per-call `id=` — stable hash across renames

The daslang identifier is the source-of-truth name for a widget — it defines the global, drives live-reload visibility, and determines how the variable is referenced elsewhere in the program. The ImGui hash and the registry path are conventions built on top.

id="x" decouples the ImGui hash from the identifier:

button(HASHED_BTN, (text = "Hashed via id=", id = "stable_v1"))

Telemetry path is still ID_WIN/HASHED_BTN (the bare identifier); ImGui’s hash is mangled by "stable_v1" via PushID/PopID wrapping the render call. Practical wins:

imgui.ini stability — rename HASHED_BTN to SAVE_BUTTON_V2 in source, and imgui.ini’s open/close state for this button still matches the same ImGui hash; users don’t lose their layout.
Hex_id-driven scripts — external drivers that target widgets by the hex_id field in the snapshot keep working across daslang identifier renames.

Per-call `path=` — stable registry path across renames

path="x" is the inverse case — keep the daslang identifier internal, expose a stable string to external drivers:

slider_float(RPS_PATH, (text = "Speed (path=)", path = "rps_stable"))

The registry path becomes ID_WIN/rps_stable (the bare identifier is NOT registered). RPS_PATH is still the daslang global — rename it without breaking script drivers. path= also mangles the ImGui hash since widget_prelude does PushID(widget_ident) and widget_ident is the overridden value.

Standalone vs live

Same convention as previous tutorials: daslang for standalone or daslang-live to keep the live-reload server running.

Driving from outside

The registry paths shown above are exactly what external drivers target:

curl -X POST -d '{"name":"imgui_click","args":{"target":"ID_WIN/section_a/SAVE_BTN"}}' \
     localhost:9090/command
curl -X POST -d '{"name":"imgui_click","args":{"target":"ID_WIN/section_b/SAVE_BTN"}}' \
     localhost:9090/command
curl -X POST -d '{"name":"imgui_force_set","args":{"target":"ID_WIN/rps_stable","value":0.7}}' \
     localhost:9090/command

Note the third targets rps_stable (the path= override), not the RPS_PATH identifier — the override replaces the bare-identifier path entry, so the bare-name target would return “no such widget.”

Next steps

State and telemetry come next — the registered widget state structs that back every boost widget, how dotted flags on the identifier (RPS.PUBLIC.NOTLIVE) tune cross-module visibility and live-reload behavior, and the auto-emit hook that surfaces app-side values to the snapshot.