Reimplement the archived UI widget stack on the new element-tree system

The old widget system (archive/dusk/ui/) depended on infrastructure this
rewrite deleted -- a static X-macro element list, a 9-slice UI_FRAME, and
a global gamepad/keyboard focus stack -- so everything below is rebuilt
on top of the new native uielement_t pool + parent/child tree instead,
gamepad/keyboard-only (no mouse support exists in the input system).

New JS widgets (assets/scripts/), all pure composites of Label/Rectangle
following the Button.js pattern: Checkbox, Tab, Slider, Dropdown. Slider/
Dropdown expose a directionInput(dx, dy) hook so a menu can hand them
LEFT/RIGHT before falling back to cursor movement.

New Menu.js replaces the old global uifocus_t stack: a small push/pop
stack of Menu instances where only the topmost consumes CANCEL/ACCEPT/
direction input each tick (needed for nested modals -- a Settings
sub-page menu plus a "discard changes?" Confirm can be open at once).
Held-direction repeat timing matches the old 0.5s delay / 0.1s repeat.

New overlay composites (added via a new UI.addOverlay()/UI.removeOverlay(),
always drawn/updated after normal roots): FpsCounter, ConsoleOverlay
(one Label per console history line, driven directly rather than via
add() since History (16) exceeds the 8-children-per-element cap), Crop
(letterbox/pillarbox bars), and Fullbox (a reusable tweened full-screen
fade covering both the old fullbox and transition effects -- reuses
shared instances rather than allocate-and-dispose, since disposing an
element from inside its own render() callback risks the same JerryScript
refcount corruption hit earlier in this rewrite).

New Confirm.js (Yes/No dialog) and Settings.js (+ SettingsGeneral/
SettingsInput sub-pages) built on Menu. Display/Audio settings pages are
intentionally not ported -- neither had a real backing engine system
even in the old code. Frame is a flat Rectangle for now, not real 9-slice
(a genuinely bigger native lift, deliberately deferred).

Small native binding additions needed by the above, each with its own
unit test: Time.renderDelta, Console.lineCount/getLine/visible/
consumeDirty, a new Screen module, a new Locale module, Input.deadzone,
a new Save module, and Label.color (was missing entirely). Also fixes
a real gap from the UI.addOverlay() work: uiElementDispose() wasn't
removing disposed elements from the new overlay root array, which would
have left dangling ids behind.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.github/workflows/test.yml

@@ -33,3 +33,74 @@ jobs:
             libssl-dev
       - name: Run tests
         run: ./scripts/test-linux.sh
+
+  # Emulator smoke tests: boot the built disc/EBOOT for a fixed window and
+  # confirm the emulator doesn't crash. Not yet verified against a real
+  # runner (no CI run has exercised these) -- continue-on-error so a
+  # flaky/broken emulator step doesn't block the required Linux test job.
+  run-tests-gamecube-dolphin:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso \
+            dolphin-emu xvfb
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build GameCube ISO and boot it in Dolphin
+        run: ./scripts/test-gamecube-dolphin.sh
+
+  run-tests-wii-dolphin:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ghcr.io/extremscorner/libogc2:latest
+    steps:
+      - name: Install Node.js
+        run: apt-get update && apt-get install -y nodejs
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Install additional dependencies
+        run: |
+          apt-get install -y \
+            python3-pip python3-polib python3-pil \
+            python3-dotenv python3-pyqt5 python3-opengl xorriso \
+            dolphin-emu xvfb
+          dkp-pacman -Syu --noconfirm
+          dkp-pacman -S --needed --noconfirm \
+            gamecube-sdl2 ppc-liblzma ppc-libzip \
+            gamecube-tools ppc-libmad ppc-zlib-ng ppc-bzip2 ppc-zstd
+      - name: Build Wii ISO and boot it in Dolphin
+        run: ./scripts/test-wii-dolphin.sh
+
+  run-tests-psp-ppsspp:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Setup pspdev
+        uses: ./.github/actions/setup-pspdev
+      - name: Install PPSSPPHeadless build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y git cmake ninja-build libsdl2-dev zlib1g-dev
+      - name: Build PPSSPPHeadless
+        run: |
+          git clone --recursive --depth 1 https://github.com/hrydgard/ppsspp.git /tmp/ppsspp
+          cmake -S /tmp/ppsspp -B /tmp/ppsspp/build -DCMAKE_BUILD_TYPE=Release
+          cmake --build /tmp/ppsspp/build --target PPSSPPHeadless -- -j$(nproc)
+          echo "PPSSPP_HEADLESS_BIN=/tmp/ppsspp/build/PPSSPPHeadless" >> "$GITHUB_ENV"
+      - name: Build PSP EBOOT and boot it in PPSSPPHeadless
+        run: ./scripts/test-psp-ppsspp.sh

CMakeLists.txt

@@ -13,7 +13,7 @@ cmake_policy(SET CMP0079 NEW)
 # set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
-option(DUSK_NETWORK "Enable network support" ON)
+option(DUSK_NETWORKING "Enable networking support" OFF)
 
 set(DUSK_GAME_NAME "Dusk" CACHE STRING "Game display name")
 set(DUSK_GAME_AUTHOR "YourWishes" CACHE STRING "Game author / coder")
@@ -91,9 +91,9 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
     DUSK_VERSION="${DUSK_VERSION}"
 )
 
-if(DUSK_NETWORK)
+if(DUSK_NETWORKING)
   target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-    DUSK_NETWORK
+    DUSK_NETWORKING
   )
 endif()
 
@@ -123,7 +123,11 @@ if(DUSK_BUILD_TESTS)
 endif()
 
 # Build assets
-file(GLOB_RECURSE DUSK_ASSET_FILES CONFIGURE_DEPENDS "${DUSK_ASSETS_DIR}/*")
+# Deliberately not CONFIGURE_DEPENDS: that reruns the full CMake configure
+# step (which invalidates generated headers and forces a huge rebuild) on
+# every single asset edit. Re-run cmake manually when assets are added or
+# removed.
+file(GLOB_RECURSE DUSK_ASSET_FILES "${DUSK_ASSETS_DIR}/*")
 add_custom_command(
   OUTPUT "${DUSK_ASSETS_ZIP}"
   COMMAND ${CMAKE_COMMAND} -E make_directory "${DUSK_ASSETS_DIR}"

archive/dusk/ui/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (c) 2026 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+add_subdirectory(debug)
+add_subdirectory(frame)
+add_subdirectory(focus)
+add_subdirectory(overlay)
+add_subdirectory(transition)
+add_subdirectory(widget)
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    ui.c
+    uielement.c
+)

archive/dusk/ui/debug/CMakeLists.txt

@@ -7,5 +7,4 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     uiconsole.c
     uifps.c
-    uiplayerpos.c
 )

archive/dusk/ui/debug/uiconsole.c

@@ -0,0 +1,138 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uiconsole.h"
+#include "assert/assert.h"
+#include "console/console.h"
+#include "display/screen/screen.h"
+#include "display/text/text.h"
+#include "display/spritebatch/spritebatch.h"
+#include "display/shader/shaderunlit.h"
+#include "display/mesh/mesh.h"
+#include "util/memory.h"
+
+typedef struct {
+  mesh_t mesh;
+  bool_t built;
+  meshvertex_t vertices[UI_CONSOLE_CACHE_VERTEX_MAX];
+  int32_t vertexCount;
+  int32_t cachedScanX;
+  int32_t cachedScanY;
+} uiconsolecache_t;
+
+uiconsolecache_t UI_CONSOLE_CACHE;
+
+errorret_t uiConsoleDraw(void) {
+  if(!CONSOLE.visible) errorOk();
+
+  if(
+    CONSOLE.dirty ||
+    UI_CONSOLE_CACHE.cachedScanX != SCREEN.scanX ||
+    UI_CONSOLE_CACHE.cachedScanY != SCREEN.scanY
+  ) {
+    errorChain(uiConsoleRebuild());
+  }
+
+  if(UI_CONSOLE_CACHE.vertexCount == 0) errorOk();
+
+  shadermaterial_t material = {
+    .unlit = {
+      .color = COLOR_RED,
+      .texture = FONT_DEFAULT.texture
+    }
+  };
+
+  errorChain(shaderBind(&SHADER_UNLIT));
+  errorChain(shaderSetMaterial(&SHADER_UNLIT, &material));
+  return meshDraw(&UI_CONSOLE_CACHE.mesh, 0, UI_CONSOLE_CACHE.vertexCount);
+}
+
+errorret_t uiConsoleRebuild(void) {
+  int32_t spriteCount = 0;
+  for(uint32_t i = 0; i < CONSOLE_HISTORY_MAX; i++) {
+    char_t c;
+    int32_t j = 0;
+    while((c = CONSOLE.line[i][j++]) != '\0') {
+      if(c != ' ' && c != '\n') spriteCount++;
+    }
+  }
+
+  assertTrue(
+    spriteCount <= UI_CONSOLE_CACHE_GLYPH_MAX,
+    "Console history exceeds fixed cache capacity"
+  );
+
+  const int32_t vertexCount = spriteCount * QUAD_VERTEX_COUNT;
+  UI_CONSOLE_CACHE.vertexCount = vertexCount;
+
+  if(vertexCount > 0) {
+    const float_t lineH = (float_t)FONT_DEFAULT.tileset->tileHeight;
+    const float_t charW = (float_t)FONT_DEFAULT.tileset->tileWidth;
+
+    int32_t index = 0;
+    int32_t row = 0;
+    for(uint32_t i = 0; i < CONSOLE_HISTORY_MAX; i++) {
+      float_t posX = (float_t)SCREEN.scanX;
+      float_t posY = (float_t)SCREEN.scanY + lineH * (float_t)row;
+
+      char_t c;
+      int32_t j = 0;
+      while((c = CONSOLE.line[i][j++]) != '\0') {
+        if(c == '\n') {
+          posX = (float_t)SCREEN.scanX;
+          posY += lineH;
+          row++;
+          continue;
+        }
+
+        if(c == ' ') {
+          posX += charW;
+          continue;
+        }
+
+        const spritebatchsprite_t sprite = textGetSprite(
+          (vec2){ posX, posY }, c, &FONT_DEFAULT
+        );
+        spriteBatchBufferToMesh(
+          &sprite, 1,
+          &UI_CONSOLE_CACHE.vertices[index], QUAD_VERTEX_COUNT
+        );
+
+        index += QUAD_VERTEX_COUNT;
+        posX += charW;
+      }
+
+      row++;
+    }
+
+    if(!UI_CONSOLE_CACHE.built) {
+      errorChain(meshInit(
+        &UI_CONSOLE_CACHE.mesh,
+        QUAD_PRIMITIVE_TYPE,
+        UI_CONSOLE_CACHE_VERTEX_MAX,
+        UI_CONSOLE_CACHE.vertices
+      ));
+      UI_CONSOLE_CACHE.built = true;
+    } else {
+      errorChain(meshFlush(&UI_CONSOLE_CACHE.mesh, 0, vertexCount));
+    }
+  }
+
+  UI_CONSOLE_CACHE.cachedScanX = SCREEN.scanX;
+  UI_CONSOLE_CACHE.cachedScanY = SCREEN.scanY;
+  CONSOLE.dirty = false;
+  errorOk();
+}
+
+errorret_t uiConsoleDispose(void) {
+  if(UI_CONSOLE_CACHE.built) {
+    errorChain(meshDispose(&UI_CONSOLE_CACHE.mesh));
+  }
+
+  memoryZero(&UI_CONSOLE_CACHE, sizeof(uiconsolecache_t));
+  errorOk();
+}

archive/dusk/ui/debug/uiconsole.h

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/mesh/quad.h"
+
+// Fixed capacity for the console's cached glyph mesh, in glyphs -- the
+// mesh/vertex buffer is sized to this once and never grown/shrunk, so
+// history producing more non-space characters than this asserts (see
+// uiConsoleRebuild) instead of reallocating.
+#define UI_CONSOLE_CACHE_GLYPH_MAX 512
+#define UI_CONSOLE_CACHE_VERTEX_MAX (\
+  UI_CONSOLE_CACHE_GLYPH_MAX * QUAD_VERTEX_COUNT \
+)
+
+/**
+ * Renders the console history into the scan-safe area, drawing a mesh
+ * that is only rebuilt when the history changes or the scan-safe origin
+ * moves, rather than rebuffering vertices every frame. No-ops when the
+ * console is not visible.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiConsoleDraw(void);
+
+/**
+ * Rebuilds the cached mesh for the console's current history and
+ * scan-safe origin. Called automatically by uiConsoleDraw() whenever
+ * needed; only needs calling directly to force an immediate rebuild.
+ * The underlying vertex buffer is a fixed-size array (see
+ * UI_CONSOLE_CACHE_VERTEX_MAX) -- asserts if the history produces more
+ * glyphs than that capacity, rather than growing it.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiConsoleRebuild(void);
+
+/**
+ * Frees the mesh and vertex buffer built up by uiConsoleDraw().
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiConsoleDispose(void);

archive/dusk/ui/debug/uifps.c

@@ -7,13 +7,21 @@
 
 #include "uifps.h"
 #include "time/time.h"
-#include "display/spritebatch/spritebatch.h"
+#include "util/string.h"
 #include "display/text/text.h"
 #include "display/screen/screen.h"
 #include "engine/engine.h"
 
 uifps_t UIFPS;
 
+errorret_t uiFPSInit() {
+  uiLabelInit(&UIFPS.fpsLabel, &FONT_DEFAULT);
+  uiLabelInit(&UIFPS.versionLabel, &FONT_DEFAULT);
+  uiLabelSetText(&UIFPS.versionLabel, ENGINE.version);
+  uiLabelSetColor(&UIFPS.versionLabel, color(255, 255, 255, 128));
+  errorOk();
+}
+
 errorret_t uiFPSDraw() {
   char_t fpsText[32];
 
@@ -50,23 +58,21 @@ errorret_t uiFPSDraw() {
     textColor = COLOR_RED;
   }
 
-  errorChain(textDraw(
-    (float_t)SCREEN.scanX,
-    (float_t)SCREEN.scanY,
-    fpsText, textColor,
-    &FONT_DEFAULT
+  uiLabelSetColor(&UIFPS.fpsLabel, textColor);
+  if(stringCompare(fpsText, UIFPS.fpsLabel.text) != 0) {
+    uiLabelSetText(&UIFPS.fpsLabel, fpsText);
+  }
+  errorChain(uiLabelDraw(
+    &UIFPS.fpsLabel, (float_t)SCREEN.scanX, (float_t)SCREEN.scanY
   ));
-  errorChain(spriteBatchFlush());
 
   int32_t versionWidth, versionHeight;
-  textMeasure(ENGINE.version, &FONT_DEFAULT, &versionWidth, &versionHeight);
-  errorChain(textDraw(
+  uiLabelGetSize(&UIFPS.versionLabel, &versionWidth, &versionHeight);
+  errorChain(uiLabelDraw(
+    &UIFPS.versionLabel,
     (float_t)(SCREEN.scanX + SCREEN.scanWidth - versionWidth),
-    (float_t)(SCREEN.scanY + SCREEN.scanHeight - versionHeight),
-    ENGINE.version,
-    color(255, 255, 255, 128),
-    &FONT_DEFAULT
+    (float_t)(SCREEN.scanY + SCREEN.scanHeight - versionHeight)
   ));
 
-  return spriteBatchFlush();
+  errorOk();
 }

archive/dusk/ui/debug/uifps.h

@@ -8,14 +8,24 @@
 #pragma once
 #include "error/error.h"
 #include "time/timeepoch.h"
+#include "ui/widget/uilabel.h"
 
 typedef struct {
   dusktimeepoch_t lastTick;
   float_t fpsAverage;
+  uilabel_t fpsLabel;
+  uilabel_t versionLabel;
 } uifps_t;
 
 extern uifps_t UIFPS;
 
+/**
+ * Initializes the FPS counter, caching the (static) version label.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiFPSInit();
+
 /**
  * Draws the FPS counter on the screen, and also does the update (for now).
  *

archive/dusk/ui/focus/uifocus.c

@@ -12,11 +12,11 @@
 #include "time/time.h"
 
 const uifocusdirmap_t UI_FOCUS_DIR_MAP[] = {
-  { INPUT_ACTION_UP,    UI_FOCUS_DIRECTION_UP,     0, -1 },
-  { INPUT_ACTION_DOWN,  UI_FOCUS_DIRECTION_DOWN,   0,  1 },
-  { INPUT_ACTION_LEFT,  UI_FOCUS_DIRECTION_LEFT,  -1,  0 },
-  { INPUT_ACTION_RIGHT, UI_FOCUS_DIRECTION_RIGHT,  1,  0 },
-  { INPUT_ACTION_NULL,  UI_FOCUS_DIRECTION_NONE,   0,  0 },
+  { INPUT_BIND_UP,    UI_FOCUS_DIRECTION_UP,     0, -1 },
+  { INPUT_BIND_DOWN,  UI_FOCUS_DIRECTION_DOWN,   0,  1 },
+  { INPUT_BIND_LEFT,  UI_FOCUS_DIRECTION_LEFT,  -1,  0 },
+  { INPUT_BIND_RIGHT, UI_FOCUS_DIRECTION_RIGHT,  1,  0 },
+  { INPUT_BIND_NULL,  UI_FOCUS_DIRECTION_NONE,   0,  0 },
 };
 
 uifocus_t UI_FOCUS;
@@ -108,7 +108,7 @@ void uiFocusMoveDirection(
 ) {
   for(
     const uifocusdirmap_t *m = UI_FOCUS_DIR_MAP;
-    m->action != INPUT_ACTION_NULL;
+    m->action != INPUT_BIND_NULL;
     m++
   ) {
     if(m->direction != dir) continue;
@@ -142,19 +142,19 @@ void uiFocusUpdate(void) {
 
   uifocusitem_t *item = &UI_FOCUS.items[UI_FOCUS.count - 1];
 
-  if(inputPressed(INPUT_ACTION_ACCEPT)) {
+  if(inputPressed(INPUT_BIND_ACCEPT)) {
     if(item->selected != NULL) item->selected(item);
     return;
   }
 
-  if(inputPressed(INPUT_ACTION_CANCEL)) {
+  if(inputPressed(INPUT_BIND_CANCEL)) {
     uiFocusPop();
     return;
   }
 
   for(
     const uifocusdirmap_t *m = UI_FOCUS_DIR_MAP;
-    m->action != INPUT_ACTION_NULL;
+    m->action != INPUT_BIND_NULL;
     m++
   ) {
     if(!inputPressed(m->action)) continue;
@@ -167,7 +167,7 @@ void uiFocusUpdate(void) {
   bool_t held = false;
   for(
     const uifocusdirmap_t *m = UI_FOCUS_DIR_MAP;
-    m->action != INPUT_ACTION_NULL;
+    m->action != INPUT_BIND_NULL;
     m++
   ) {
     if(m->direction != UI_FOCUS.direction) continue;

archive/dusk/ui/focus/uifocus.h

@@ -23,7 +23,7 @@
 #define UI_FOCUS_HOLD_REPEAT 0.1f
 
 typedef struct {
-  inputaction_t action;
+  inputbind_t action;
   uifocusdirection_t direction;
   int8_t dx;
   int8_t dy;
@@ -31,7 +31,7 @@ typedef struct {
 
 /**
  * Mapping of input actions to focus directions, terminated by an
- * entry with action == INPUT_ACTION_NULL.
+ * entry with action == INPUT_BIND_NULL.
  */
 extern const uifocusdirmap_t UI_FOCUS_DIR_MAP[];
 

archive/dusk/ui/frame/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    uiframe.c
+    uiconfirm.c
+)
+
+add_subdirectory(settings)

archive/dusk/ui/frame/settings/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    uisettings.c
+    uisettingsgeneral.c
+    uisettingsinput.c
+    uisettingsdisplay.c
+    uisettingsaudio.c
+)

archive/dusk/ui/frame/settings/uisettings.c

@@ -0,0 +1,248 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uisettings.h"
+#include "uisettingsgeneral.h"
+#include "uisettingsinput.h"
+#include "uisettingsdisplay.h"
+#include "uisettingsaudio.h"
+#include "ui/frame/uiframe.h"
+#include "ui/frame/uiconfirm.h"
+#include "util/memory.h"
+#include "display/text/text.h"
+#include "display/screen/screen.h"
+#include "assert/assert.h"
+#include "locale/localemanager.h"
+#include "asset/loader/locale/assetlocaleloader.h"
+
+uisettings_t UI_SETTINGS;
+
+uisettingstabdef_t UI_SETTINGS_TAB_DEFS[UI_SETTINGS_TAB_COUNT] = {
+  {
+    .localeId = "ui.settings.tabs.general",
+    .init = uiSettingsGeneralInit,
+    .menu = (uimenu_t *)&UI_SETTINGS.data,
+    .load = uiSettingsGeneralLoad,
+    .apply = uiSettingsGeneralApply,
+    .hasChanges = uiSettingsGeneralHasChanges
+  },
+
+  {
+    .localeId = "ui.settings.tabs.input",
+    .init = uiSettingsInputInit,
+    .menu = (uimenu_t *)&UI_SETTINGS.data,
+    .load = uiSettingsInputLoad,
+    .apply = uiSettingsInputApply,
+    .hasChanges = uiSettingsInputHasChanges
+  },
+
+  {
+    .localeId = "ui.settings.tabs.display",
+    .init = uiSettingsDisplayInit,
+    .menu = (uimenu_t *)&UI_SETTINGS.data,
+    .load = uiSettingsDisplayLoad,
+    .apply = uiSettingsDisplayApply,
+    .hasChanges = uiSettingsDisplayHasChanges
+  },
+
+  {
+    .localeId = "ui.settings.tabs.audio",
+    .init = uiSettingsAudioInit,
+    .menu = (uimenu_t *)&UI_SETTINGS.data,
+    .load = uiSettingsAudioLoad,
+    .apply = uiSettingsAudioApply,
+    .hasChanges = uiSettingsAudioHasChanges
+  }
+};
+
+static uisettingstabdef_t UI_SETTINGS_TOP_DEF = {
+  .menu = &UI_SETTINGS.tabsMenu,
+  .load = uiSettingsLoad,
+  .hasChanges = uiSettingsHasChanges
+};
+
+static uisettingstabdef_t *UI_SETTINGS_PENDING_DISCARD = NULL;
+static uisettingstabdef_t *UI_SETTINGS_ACTIVE_TAB = NULL;
+
+errorret_t uiSettingsActivateTab(uisettingstabdef_t *def) {
+  if(def == UI_SETTINGS_ACTIVE_TAB) errorOk();
+
+  errorChain(def->init(&UI_SETTINGS.data));
+  def->menu->user = def;
+  def->load();
+  UI_SETTINGS_ACTIVE_TAB = def;
+
+  errorOk();
+}
+
+void uiSettingsTabChanged(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  if(index >= UI_SETTINGS_TAB_COUNT) return;
+  errorCatch(uiSettingsActivateTab(&UI_SETTINGS_TAB_DEFS[index]));
+}
+
+void uiSettingsTabSelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  if(index >= UI_SETTINGS_TAB_COUNT) return;
+
+  uisettingstabdef_t *def = &UI_SETTINGS_TAB_DEFS[index];
+  errorCatch(uiSettingsActivateTab(def));
+  uiMenuOpen(def->menu);
+}
+
+errorret_t uiSettingsInit(void) {
+  memoryZero(&UI_SETTINGS, sizeof(uisettings_t));
+  UI_SETTINGS_ACTIVE_TAB = NULL;
+
+  for(uint8_t i = 0; i < UI_SETTINGS_TAB_COUNT; i++) {
+    errorChain(assetLocaleGetString(
+      &LOCALE.entry->data.locale,
+      UI_SETTINGS_TAB_DEFS[i].localeId,
+      0,
+      UI_SETTINGS.tabLabels[i],
+      UI_SETTINGS_TAB_LABEL_MAX
+    ));
+  }
+
+  MENU_BEGIN(
+    &UI_SETTINGS.tabsMenu, UI_SETTINGS.tabs, uiSettingsTabSelected,
+    uiSettingsDiscardMenuClosed, uiSettingsTabChanged
+  );
+  for(uint8_t i = 0; i < UI_SETTINGS_TAB_COUNT; i++) {
+    MENU_TAB(UI_SETTINGS.tabLabels[i]);
+  }
+  MENU_END(UI_SETTINGS.tabs, menuIndex);
+
+  UI_SETTINGS.tabsMenu.user = &UI_SETTINGS_TOP_DEF;
+
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.settings.apply",
+    0,
+    UI_SETTINGS.applyLabel,
+    UI_SETTINGS_APPLY_LABEL_MAX
+  ));
+
+  errorChain(uiSettingsActivateTab(&UI_SETTINGS_TAB_DEFS[0]));
+
+  errorOk();
+}
+
+errorret_t uiSettingsDraw(void) {
+  if(!uiMenuIsActive(&UI_SETTINGS.tabsMenu)) errorOk();
+
+  const float_t width = SCREEN.width;
+  const float_t height = SCREEN.height;
+  const float_t x = (float_t)SCREEN.scanX +
+    ((float_t)SCREEN.scanWidth - width) * 0.5f;
+  const float_t y = (float_t)SCREEN.scanY +
+    ((float_t)SCREEN.scanHeight - height) * 0.5f;
+
+  errorChain(uiFrameDrawCached(&UI_SETTINGS.frameCache, x, y, width, height));
+
+  const float_t contentX = x + UI_FRAME_START_X;
+  const float_t contentY = y + UI_FRAME_START_Y;
+  const float_t contentWidth = width - (UI_FRAME_START_X * 2);
+  const float_t contentHeight = height - (UI_FRAME_START_Y * 2);
+
+  errorChain(uiMenuDraw(
+    &UI_SETTINGS.tabsMenu,
+    contentX,
+    contentY,
+    contentWidth,
+    contentHeight
+  ));
+
+  const float_t tabsRowHeight = (float_t)FONT_DEFAULT.tileset->tileHeight;
+  const float_t pageY = contentY + tabsRowHeight + UI_FRAME_PADDING_Y;
+  const float_t pageHeight = contentHeight - tabsRowHeight - UI_FRAME_PADDING_Y;
+
+  if(UI_SETTINGS_ACTIVE_TAB != NULL) {
+    errorChain(uiMenuDraw(
+      UI_SETTINGS_ACTIVE_TAB->menu, contentX, pageY, contentWidth, pageHeight
+    ));
+  }
+
+  errorOk();
+}
+
+errorret_t uiSettingsUpdate(void) {
+  if(!UI_SETTINGS_PENDING_DISCARD) errorOk();
+
+  uisettingstabdef_t *def = UI_SETTINGS_PENDING_DISCARD;
+  UI_SETTINGS_PENDING_DISCARD = NULL;
+
+  return uiSettingsDiscardUpdate(def);
+}
+
+bool_t uiSettingsIsOpen(void) {
+  return uiMenuIsActive(&UI_SETTINGS.tabsMenu);
+}
+
+void uiSettingsOpen() {
+  uiSettingsLoad();
+  uiMenuOpen(&UI_SETTINGS.tabsMenu);
+}
+
+void uiSettingsClose() {
+  uiMenuClose(&UI_SETTINGS.tabsMenu);
+}
+
+errorret_t uiSettingsDispose(void) {
+  errorOk();
+}
+
+void uiSettingsLoad(void) {
+  if(UI_SETTINGS_ACTIVE_TAB != NULL) UI_SETTINGS_ACTIVE_TAB->load();
+}
+
+void uiSettingsApply(void) {
+  if(UI_SETTINGS_ACTIVE_TAB != NULL) UI_SETTINGS_ACTIVE_TAB->apply();
+}
+
+bool_t uiSettingsHasChanges(void) {
+  return UI_SETTINGS_ACTIVE_TAB != NULL && UI_SETTINGS_ACTIVE_TAB->hasChanges();
+}
+
+void uiSettingsDiscardMenuClosed(const uimenu_t *menu) {
+  uisettingstabdef_t *def = (uisettingstabdef_t *)menu->user;
+  if(def->hasChanges()) UI_SETTINGS_PENDING_DISCARD = def;
+}
+
+errorret_t uiSettingsDiscardUpdate(uisettingstabdef_t *def) {
+  #define UI_SETTINGS_DISCARD_TEXT_MAX 128
+  char_t text[UI_SETTINGS_DISCARD_TEXT_MAX];
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.confirm.discard_changes",
+    0,
+    text,
+    UI_SETTINGS_DISCARD_TEXT_MAX
+  ));
+  #undef UI_SETTINGS_DISCARD_TEXT_MAX
+
+  uiConfirmOpen(text, uiSettingsDiscardConfirmResult, def);
+
+  errorOk();
+}
+
+void uiSettingsDiscardConfirmResult(const bool_t result, void *user) {
+  uisettingstabdef_t *def = (uisettingstabdef_t *)user;
+
+  if(!result) {
+    uiMenuOpen(def->menu);
+    return;
+  }
+
+  def->load();
+}

archive/dusk/ui/frame/settings/uisettings.h

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "ui/widget/uimenu.h"
+#include "ui/frame/uiframe.h"
+#include "uisettingsdata.h"
+
+#define UI_SETTINGS_TAB_COUNT 4
+#define UI_SETTINGS_TAB_LABEL_MAX 32
+#define UI_SETTINGS_APPLY_LABEL_MAX 32
+
+typedef struct {
+  const char_t *localeId;
+  errorret_t (*init)(uisettingsdata_t *data);
+  uimenu_t *menu;
+  void (*load)(void);
+  void (*apply)(void);
+  bool_t (*hasChanges)(void);
+} uisettingstabdef_t;
+
+typedef struct {
+  uimenu_t tabsMenu;
+  uimenuitem_t tabs[UI_SETTINGS_TAB_COUNT];
+  char_t tabLabels[UI_SETTINGS_TAB_COUNT][UI_SETTINGS_TAB_LABEL_MAX];
+  char_t applyLabel[UI_SETTINGS_APPLY_LABEL_MAX];
+  uisettingsdata_t data;
+  uiframecache_t frameCache;
+} uisettings_t;
+
+extern uisettings_t UI_SETTINGS;
+extern uisettingstabdef_t UI_SETTINGS_TAB_DEFS[UI_SETTINGS_TAB_COUNT];
+
+/**
+ * Menu closed callback that flags a pending discard-changes
+ * confirmation if the menu's settings page/panel reports unsaved
+ * changes. Pass this directly as a settings page menu's closed
+ * callback. The pending def is picked up by uiSettingsUpdate on the
+ * next tick.
+ *
+ * @param menu The menu that was just closed.
+ */
+void uiSettingsDiscardMenuClosed(const uimenu_t *menu);
+
+/**
+ * Shows the discard-changes confirmation dialog for def. Called once
+ * by uiSettingsUpdate when uiSettingsDiscardMenuClosed has flagged a
+ * pending def.
+ *
+ * @param def The tab/panel def to show the confirmation for.
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsDiscardUpdate(uisettingstabdef_t *def);
+
+/**
+ * Callback passed to uiConfirmOpen by uiSettingsDiscardUpdate. Reopens
+ * the menu if the user chose to keep editing, otherwise reloads the
+ * widgets back to the actual engine values.
+ *
+ * @param result True if the user confirmed discarding changes, false
+ * to keep editing.
+ * @param user The uisettingstabdef_t* this confirmation belongs to.
+ */
+void uiSettingsDiscardConfirmResult(const bool_t result, void *user);
+
+/**
+ * Initializes the settings panel and all of its category pages.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsInit(void);
+
+/**
+ * Draws the settings panel. No-op when not visible.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsDraw(void);
+
+/**
+ * Updates the settings panel. Shows a discard-changes confirmation if
+ * the panel was just closed with unsaved changes.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsUpdate(void);
+
+/**
+ * Returns true when the settings panel is currently open.
+ *
+ * @returns True if open.
+ */
+bool_t uiSettingsIsOpen(void);
+
+/**
+ * Opens the settings panel. No-op when already open.
+ */
+void uiSettingsOpen();
+
+/**
+ * Closes the settings panel. No-op when already closed.
+ */
+void uiSettingsClose();
+
+/**
+ * Disposes of the settings panel.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsDispose(void);
+
+/**
+ * Loads every category page's widgets from the current engine settings.
+ * Called automatically by uiSettingsOpen.
+ */
+void uiSettingsLoad(void);
+
+/**
+ * Applies every category page's widget values to the engine settings.
+ * Called automatically when a page's own Apply button is pressed.
+ */
+void uiSettingsApply(void);
+
+/**
+ * Returns whether any category page has a widget value that differs
+ * from what was loaded.
+ *
+ * @returns True if there are unsaved changes.
+ */
+bool_t uiSettingsHasChanges(void);

archive/dusk/ui/frame/settings/uisettingsaudio.c

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uisettingsaudio.h"
+#include "uisettings.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+void uiSettingsAudioSelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  if(index != UI_SETTINGS_AUDIO_INDEX_APPLY) return;
+  uiSettingsAudioApply();
+}
+
+errorret_t uiSettingsAudioInit(uisettingsdata_t *data) {
+  uisettingsaudio_t *audio = &data->audio;
+  memoryZero(audio, sizeof(uisettingsaudio_t));
+
+  MENU_BEGIN(
+    &audio->menu, audio->items,
+    uiSettingsAudioSelected, uiSettingsDiscardMenuClosed, NULL
+  );
+  MENU_LABEL("No audio settings yet");
+  MENU_BUTTON(UI_SETTINGS.applyLabel);
+
+  MENU_END(audio->items, 1);
+
+  errorOk();
+}
+
+void uiSettingsAudioLoad(void) {
+}
+
+void uiSettingsAudioApply(void) {
+  uiMenuClose(&UI_SETTINGS.data.audio.menu);
+}
+
+bool_t uiSettingsAudioHasChanges(void) {
+  return false;
+}

archive/dusk/ui/frame/settings/uisettingsaudio.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "uisettingsdata.h"
+
+/**
+ * Initializes the audio settings page into the shared settings data
+ * union.
+ *
+ * @param data The shared settings data union to initialize into.
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsAudioInit(uisettingsdata_t *data);
+
+/**
+ * Loads the page's widgets from the current engine audio settings.
+ */
+void uiSettingsAudioLoad(void);
+
+/**
+ * Applies the page's widget values to the engine audio settings.
+ */
+void uiSettingsAudioApply(void);
+
+/**
+ * Returns whether any widget's value differs from what was loaded.
+ *
+ * @returns True if there are unsaved changes.
+ */
+bool_t uiSettingsAudioHasChanges(void);

archive/dusk/ui/frame/settings/uisettingsdata.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "ui/widget/uimenu.h"
+
+#define UI_SETTINGS_GENERAL_ITEM_COUNT 3
+#define UI_SETTINGS_GENERAL_INDEX_LANGUAGE 0
+#define UI_SETTINGS_GENERAL_INDEX_LANGUAGE_DETAIL 1
+#define UI_SETTINGS_GENERAL_INDEX_APPLY 2
+#define UI_SETTINGS_GENERAL_LOCALE_COUNT 3
+#define UI_SETTINGS_GENERAL_LABEL_MAX 32
+#define UI_SETTINGS_GENERAL_INFO_MAX 64
+
+typedef struct {
+  uimenu_t menu;
+  uimenuitem_t items[UI_SETTINGS_GENERAL_ITEM_COUNT];
+  const char_t *localeNames[UI_SETTINGS_GENERAL_LOCALE_COUNT];
+  char_t languageLabel[UI_SETTINGS_GENERAL_LABEL_MAX];
+  char_t labelInfo[UI_SETTINGS_GENERAL_INFO_MAX];
+} uisettingsgeneral_t;
+
+#define UI_SETTINGS_INPUT_ITEM_COUNT 2
+#define UI_SETTINGS_INPUT_LABEL_MAX 32
+#define UI_SETTINGS_INPUT_INDEX_DEADZONE 0
+#define UI_SETTINGS_INPUT_INDEX_APPLY 1
+
+typedef struct {
+  uimenu_t menu;
+  uimenuitem_t items[UI_SETTINGS_INPUT_ITEM_COUNT];
+  char_t deadzoneLabel[UI_SETTINGS_INPUT_LABEL_MAX];
+} uisettingsinput_t;
+
+#define UI_SETTINGS_DISPLAY_ITEM_COUNT 2
+#define UI_SETTINGS_DISPLAY_INDEX_APPLY 1
+
+typedef struct {
+  uimenu_t menu;
+  uimenuitem_t items[UI_SETTINGS_DISPLAY_ITEM_COUNT];
+} uisettingsdisplay_t;
+
+#define UI_SETTINGS_AUDIO_ITEM_COUNT 2
+#define UI_SETTINGS_AUDIO_INDEX_APPLY 1
+
+typedef struct {
+  uimenu_t menu;
+  uimenuitem_t items[UI_SETTINGS_AUDIO_ITEM_COUNT];
+} uisettingsaudio_t;
+
+/**
+ * Shared, overlapping storage for every settings tab's page data. Only
+ * one member is ever live at a time -- the active tab's Init writes
+ * into it, overwriting whatever the previously active tab left there.
+ * This trades simultaneous access to every tab for a memory footprint
+ * of only the single largest page.
+ */
+typedef union {
+  uisettingsgeneral_t general;
+  uisettingsinput_t input;
+  uisettingsdisplay_t display;
+  uisettingsaudio_t audio;
+} uisettingsdata_t;

archive/dusk/ui/frame/settings/uisettingsdisplay.c

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uisettingsdisplay.h"
+#include "uisettings.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+void uiSettingsDisplaySelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  if(index != UI_SETTINGS_DISPLAY_INDEX_APPLY) return;
+  uiSettingsDisplayApply();
+}
+
+errorret_t uiSettingsDisplayInit(uisettingsdata_t *data) {
+  uisettingsdisplay_t *display = &data->display;
+  memoryZero(display, sizeof(uisettingsdisplay_t));
+
+  MENU_BEGIN(
+    &display->menu, display->items,
+    uiSettingsDisplaySelected, uiSettingsDiscardMenuClosed, NULL
+  );
+  MENU_LABEL("No display settings yet");
+  MENU_BUTTON(UI_SETTINGS.applyLabel);
+
+  MENU_END(display->items, 1);
+
+  errorOk();
+}
+
+void uiSettingsDisplayLoad(void) {
+}
+
+void uiSettingsDisplayApply(void) {
+  uiMenuClose(&UI_SETTINGS.data.display.menu);
+}
+
+bool_t uiSettingsDisplayHasChanges(void) {
+  return false;
+}

archive/dusk/ui/frame/settings/uisettingsdisplay.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "uisettingsdata.h"
+
+/**
+ * Initializes the display settings page into the shared settings data
+ * union.
+ *
+ * @param data The shared settings data union to initialize into.
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsDisplayInit(uisettingsdata_t *data);
+
+/**
+ * Loads the page's widgets from the current engine display settings.
+ */
+void uiSettingsDisplayLoad(void);
+
+/**
+ * Applies the page's widget values to the engine display settings.
+ */
+void uiSettingsDisplayApply(void);
+
+/**
+ * Returns whether any widget's value differs from what was loaded.
+ *
+ * @returns True if there are unsaved changes.
+ */
+bool_t uiSettingsDisplayHasChanges(void);

archive/dusk/ui/frame/settings/uisettingsgeneral.c

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uisettingsgeneral.h"
+#include "uisettings.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+#include "locale/localemanager.h"
+#include "locale/localeinfo.h"
+#include "asset/loader/locale/assetlocaleloader.h"
+
+static const localeinfo_t *const UI_SETTINGS_GENERAL_LOCALES[
+  UI_SETTINGS_GENERAL_LOCALE_COUNT
+] = {
+  &LOCALE_EN_US,
+  &LOCALE_JP_JP,
+  &LOCALE_ES_MX
+};
+
+void uiSettingsGeneralSelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  switch(index) {
+    case UI_SETTINGS_GENERAL_INDEX_APPLY:
+      uiSettingsGeneralApply();
+      break;
+
+    default:
+      break;
+  }
+}
+
+errorret_t uiSettingsGeneralInit(uisettingsdata_t *data) {
+  uisettingsgeneral_t *general = &data->general;
+  memoryZero(general, sizeof(uisettingsgeneral_t));
+
+  for(uint8_t i = 0; i < UI_SETTINGS_GENERAL_LOCALE_COUNT; i++) {
+    general->localeNames[i] = UI_SETTINGS_GENERAL_LOCALES[i]->name;
+  }
+
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.settings.general.language",
+    0,
+    general->languageLabel,
+    UI_SETTINGS_GENERAL_LABEL_MAX
+  ));
+  errorChain(assetLocaleGetString(
+    &LOCALE.entry->data.locale,
+    "ui.settings.general.language_detail",
+    0,
+    general->labelInfo,
+    UI_SETTINGS_GENERAL_INFO_MAX
+  ));
+
+  MENU_BEGIN(
+    &general->menu, general->items,
+    uiSettingsGeneralSelected, uiSettingsDiscardMenuClosed, NULL
+  );
+
+  MENU_DROPDOWN(
+    general->languageLabel, general->localeNames,
+    UI_SETTINGS_GENERAL_LOCALE_COUNT, 0
+  );
+  MENU_LABEL(general->labelInfo);
+
+  MENU_BUTTON(UI_SETTINGS.applyLabel);
+  MENU_END(general->items, 1);
+
+  errorOk();
+}
+
+void uiSettingsGeneralLoad(void) {
+  uisettingsgeneral_t *general = &UI_SETTINGS.data.general;
+
+  uint8_t index = 0;
+  for(uint8_t i = 0; i < UI_SETTINGS_GENERAL_LOCALE_COUNT; i++) {
+    if(stringCompare(LOCALE.locale->file, UI_SETTINGS_GENERAL_LOCALES[i]->file) != 0) {
+      continue;
+    }
+    index = i;
+    break;
+  }
+
+  uiDropdownSetSelectedIndex(
+    &general->items[UI_SETTINGS_GENERAL_INDEX_LANGUAGE].dropdown, index
+  );
+}
+
+void uiSettingsGeneralApply(void) {
+  uisettingsgeneral_t *general = &UI_SETTINGS.data.general;
+
+  uint8_t index = uiDropdownGetSelectedIndex(
+    &general->items[UI_SETTINGS_GENERAL_INDEX_LANGUAGE].dropdown
+  );
+  errorCatch(localeManagerSetLocale(UI_SETTINGS_GENERAL_LOCALES[index]));
+
+  uiMenuClose(&general->menu);
+}
+
+bool_t uiSettingsGeneralHasChanges(void) {
+  uisettingsgeneral_t *general = &UI_SETTINGS.data.general;
+
+  uint8_t index = uiDropdownGetSelectedIndex(
+    &general->items[UI_SETTINGS_GENERAL_INDEX_LANGUAGE].dropdown
+  );
+  return stringCompare(
+    LOCALE.locale->file, UI_SETTINGS_GENERAL_LOCALES[index]->file
+  ) != 0;
+}

archive/dusk/ui/frame/settings/uisettingsgeneral.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "uisettingsdata.h"
+
+/**
+ * Initializes the general settings page into the shared settings data
+ * union.
+ *
+ * @param data The shared settings data union to initialize into.
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsGeneralInit(uisettingsdata_t *data);
+
+/**
+ * Loads the page's widgets from the current engine general settings.
+ */
+void uiSettingsGeneralLoad(void);
+
+/**
+ * Applies the page's widget values to the engine general settings.
+ */
+void uiSettingsGeneralApply(void);
+
+/**
+ * Returns whether any widget's value differs from what was loaded.
+ *
+ * @returns True if there are unsaved changes.
+ */
+bool_t uiSettingsGeneralHasChanges(void);

archive/dusk/ui/frame/settings/uisettingsinput.c

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uisettingsinput.h"
+#include "uisettings.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "locale/localemanager.h"
+#include "asset/loader/locale/assetlocaleloader.h"
+#include "input/input.h"
+#include "save/savesettings.h"
+
+void uiSettingsInputSelected(
+  const uimenu_t *menu,
+  const uint8_t index,
+  const uimenuitem_t *item
+) {
+  if(index != UI_SETTINGS_INPUT_INDEX_APPLY) return;
+  uiSettingsInputApply();
+}
+
+errorret_t uiSettingsInputInit(uisettingsdata_t *data) {
+  uisettingsinput_t *input = &data->input;
+  memoryZero(input, sizeof(uisettingsinput_t));
+
+  MENU_BEGIN(
+    &input->menu, input->items,
+    uiSettingsInputSelected, uiSettingsDiscardMenuClosed, NULL
+  );
+  #ifdef DUSK_INPUT_GAMEPAD
+    errorChain(assetLocaleGetString(
+      &LOCALE.entry->data.locale,
+      "ui.settings.input.deadzone",
+      0,
+      input->deadzoneLabel,
+      UI_SETTINGS_INPUT_LABEL_MAX
+    ));
+    MENU_SLIDER_FLOAT(
+      input->deadzoneLabel, INPUT_DEADZONE_DEFAULT, 0.0f, 1.0f, 0.05f
+    );
+  #else
+    MENU_LABEL("No input settings yet");
+  #endif
+
+  MENU_BUTTON(UI_SETTINGS.applyLabel);
+  MENU_END(input->items, 1);
+
+  errorOk();
+}
+
+void uiSettingsInputLoad(void) {
+  #ifdef DUSK_INPUT_GAMEPAD
+    uiSliderSetFloat(
+      &UI_SETTINGS.data.input.items[UI_SETTINGS_INPUT_INDEX_DEADZONE].slider,
+      INPUT.deadzone
+    );
+  #endif
+}
+
+void uiSettingsInputApply(void) {
+  #ifdef DUSK_INPUT_GAMEPAD
+    INPUT.deadzone = uiSliderGetFloat(
+      &UI_SETTINGS.data.input.items[UI_SETTINGS_INPUT_INDEX_DEADZONE].slider
+    );
+  #endif
+  errorCatch(errorPrint(saveSettingsWrite()));
+  uiMenuClose(&UI_SETTINGS.data.input.menu);
+}
+
+bool_t uiSettingsInputHasChanges(void) {
+  #ifdef DUSK_INPUT_GAMEPAD
+    if(uiSliderGetFloat(
+      &UI_SETTINGS.data.input.items[UI_SETTINGS_INPUT_INDEX_DEADZONE].slider
+    ) != INPUT.deadzone) return true;
+  #endif
+
+  return false;
+}

archive/dusk/ui/frame/settings/uisettingsinput.h

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "uisettingsdata.h"
+
+/**
+ * Initializes the input settings page into the shared settings data
+ * union.
+ *
+ * @param data The shared settings data union to initialize into.
+ * @return Any error that occurs.
+ */
+errorret_t uiSettingsInputInit(uisettingsdata_t *data);
+
+/**
+ * Loads the page's widgets from the current engine input settings.
+ */
+void uiSettingsInputLoad(void);
+
+/**
+ * Applies the page's widget values to the engine input settings.
+ */
+void uiSettingsInputApply(void);
+
+/**
+ * Returns whether any widget's value differs from what was loaded.
+ *
+ * @returns True if there are unsaved changes.
+ */
+bool_t uiSettingsInputHasChanges(void);

archive/dusk/ui/frame/uiconfirm.c

@@ -9,7 +9,6 @@
 #include "uiframe.h"
 #include "assert/assert.h"
 #include "util/memory.h"
-#include "util/string.h"
 #include "util/math.h"
 #include "display/screen/screen.h"
 #include "display/text/text.h"
@@ -17,8 +16,6 @@
 #include "display/spritebatch/spritebatch.h"
 #include "display/texture/texture.h"
 #include "display/shader/shaderunlit.h"
-#include "locale/localemanager.h"
-#include "asset/loader/locale/assetlocaleloader.h"
 
 #define UI_CONFIRM_BACKDROP_COLOR color4b(0, 0, 0, 160)
 
@@ -41,27 +38,13 @@ void uiConfirmClosed(const uimenu_t *menu) {
 
 errorret_t uiConfirmInit(void) {
   memoryZero(&UI_CONFIRM, sizeof(uiconfirm_t));
-
-  errorChain(assetLocaleGetString(
-    &LOCALE.entry->data.locale,
-    "ui.confirm.confirm",
-    0,
-    UI_CONFIRM.confirmLabel,
-    UI_CONFIRM_LABEL_MAX
-  ));
-  errorChain(assetLocaleGetString(
-    &LOCALE.entry->data.locale,
-    "ui.confirm.cancel",
-    0,
-    UI_CONFIRM.cancelLabel,
-    UI_CONFIRM_LABEL_MAX
-  ));
+  uiLabelInit(&UI_CONFIRM.textLabel, &FONT_DEFAULT);
 
   MENU_BEGIN(
     &UI_CONFIRM.menu, UI_CONFIRM.items, uiConfirmSelected, uiConfirmClosed, NULL
   );
-  MENU_BUTTON(UI_CONFIRM.confirmLabel);
-  MENU_BUTTON(UI_CONFIRM.cancelLabel);
+  MENU_BUTTON("Confirm");
+  MENU_BUTTON("Cancel");
 
   MENU_END(UI_CONFIRM.items, menuIndex);
 
@@ -86,10 +69,9 @@ errorret_t uiConfirmDraw(void) {
   errorChain(
     spriteBatchBuffer(&backdropSprite, 1, &SHADER_UNLIT, backdropMaterial)
   );
-  errorChain(spriteBatchFlush());
 
   int32_t textW, textH;
-  textMeasure(UI_CONFIRM.text, &FONT_DEFAULT, &textW, &textH);
+  uiLabelGetSize(&UI_CONFIRM.textLabel, &textW, &textH);
 
   float_t rowHeight = (float_t)FONT_DEFAULT.tileset->tileHeight;
   float_t width = mathMax(
@@ -100,18 +82,17 @@ errorret_t uiConfirmDraw(void) {
   float_t x = (float_t)SCREEN.scanX + ((float_t)SCREEN.scanWidth - width) * 0.5f;
   float_t y = (float_t)SCREEN.scanY + ((float_t)SCREEN.scanHeight - height) * 0.5f;
 
-  errorChain(uiFrameDraw(x, y, width, height));
+  errorChain(uiFrameDrawCached(&UI_CONFIRM.frameCache, x, y, width, height));
 
   float_t contentX = x + UI_FRAME_START_X;
   float_t contentY = y + UI_FRAME_START_Y;
   float_t contentWidth = width - (UI_FRAME_START_X * 2);
 
-  errorChain(textDraw(contentX, contentY, UI_CONFIRM.text, COLOR_WHITE, &FONT_DEFAULT));
+  errorChain(uiLabelDraw(&UI_CONFIRM.textLabel, contentX, contentY));
 
   float_t buttonsY = contentY + rowHeight + UI_FRAME_PADDING_Y;
   errorChain(uiMenuDraw(&UI_CONFIRM.menu, contentX, buttonsY, contentWidth, rowHeight));
 
-  errorChain(spriteBatchFlush());
   errorOk();
 }
 
@@ -129,7 +110,7 @@ void uiConfirmOpen(
   void *user
 ) {
   assertNotNull(question, "Question cannot be NULL");
-  stringCopy(UI_CONFIRM.text, question, UI_CONFIRM_TEXT_MAX);
+  uiLabelSetText(&UI_CONFIRM.textLabel, question);
   UI_CONFIRM.callback = callback;
   UI_CONFIRM.user = user;
   UI_CONFIRM.result = false;

archive/dusk/ui/frame/uiconfirm.h

@@ -8,13 +8,13 @@
 #pragma once
 #include "error/error.h"
 #include "ui/widget/uimenu.h"
+#include "ui/widget/uilabel.h"
+#include "ui/frame/uiframe.h"
 
-#define UI_CONFIRM_TEXT_MAX 256
 #define UI_CONFIRM_MIN_WIDTH 160.0f
 #define UI_CONFIRM_INDEX_CONFIRM 0
 #define UI_CONFIRM_INDEX_CANCEL 1
 #define UI_CONFIRM_ITEM_COUNT 2
-#define UI_CONFIRM_LABEL_MAX 32
 
 /**
  * Callback invoked once a confirm dialog is dismissed.
@@ -26,14 +26,13 @@
 typedef void (*uiconfirmcallback_t)(const bool_t result, void *user);
 
 typedef struct {
-  char_t text[UI_CONFIRM_TEXT_MAX];
+  uilabel_t textLabel;
   uimenu_t menu;
   uimenuitem_t items[UI_CONFIRM_ITEM_COUNT];
   uiconfirmcallback_t callback;
   void *user;
   bool_t result;
-  char_t confirmLabel[UI_CONFIRM_LABEL_MAX];
-  char_t cancelLabel[UI_CONFIRM_LABEL_MAX];
+  uiframecache_t frameCache;
 } uiconfirm_t;
 
 extern uiconfirm_t UI_CONFIRM;

archive/dusk/ui/frame/uiframe.c

@@ -72,6 +72,17 @@ errorret_t uiFrameDraw(
     }
   };
   spritebatchsprite_t sprites[9];
+  uiFrameBuildSprites(sprites, x, y, width, height);
+  return spriteBatchBuffer(sprites, 9, &SHADER_UNLIT, material);
+}
+
+void uiFrameBuildSprites(
+  spritebatchsprite_t sprites[9],
+  const float_t x,
+  const float_t y,
+  const float_t width,
+  const float_t height
+) {
   float_t tileW = (float_t)UI_FRAME_BORDER_WIDTH;
   float_t tileH = (float_t)UI_FRAME_BORDER_HEIGHT;
 
@@ -112,8 +123,37 @@ errorret_t uiFrameDraw(
     &UI_FRAME.tileset, 2, 2,
     x + width - tileW, y + height - tileH, tileW, tileH
   );
+}
 
-  return spriteBatchBuffer(sprites, 9, &SHADER_UNLIT, material);
+errorret_t uiFrameDrawCached(
+  uiframecache_t *cache,
+  const float_t x,
+  const float_t y,
+  const float_t width,
+  const float_t height
+) {
+  assertNotNull(cache, "Frame cache cannot be NULL");
+
+  if(
+    !cache->built ||
+    cache->lastX != x || cache->lastY != y ||
+    cache->lastWidth != width || cache->lastHeight != height
+  ) {
+    uiFrameBuildSprites(cache->sprites, x, y, width, height);
+    cache->lastX = x;
+    cache->lastY = y;
+    cache->lastWidth = width;
+    cache->lastHeight = height;
+    cache->built = true;
+  }
+
+  shadermaterial_t material = {
+    .unlit = {
+      .color = COLOR_WHITE,
+      .texture = &UI_FRAME.texture
+    }
+  };
+  return spriteBatchBuffer(cache->sprites, 9, &SHADER_UNLIT, material);
 }
 
 errorret_t uiFrameDispose(void) {

archive/dusk/ui/frame/uiframe.h

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/texture/texture.h"
+#include "display/texture/tileset.h"
+#include "display/spritebatch/spritebatchsprite.h"
+
+#define UI_FRAME_BORDER_WIDTH 6
+#define UI_FRAME_BORDER_HEIGHT 6
+#define UI_FRAME_PADDING_X 2
+#define UI_FRAME_PADDING_Y 2
+#define UI_FRAME_START_X (UI_FRAME_BORDER_WIDTH + UI_FRAME_PADDING_X)
+#define UI_FRAME_START_Y (UI_FRAME_BORDER_HEIGHT + UI_FRAME_PADDING_Y)
+#define UI_FRAME_TILE_WIDTH 1
+#define UI_FRAME_TILE_HEIGHT 1
+#define UI_FRAME_TEXTURE_WIDTH (UI_FRAME_TILE_WIDTH * 3)
+#define UI_FRAME_TEXTURE_HEIGHT (UI_FRAME_TILE_HEIGHT * 3)
+#define UI_FRAME_TEXTURE_WIDTH_POW2 4
+#define UI_FRAME_TEXTURE_HEIGHT_POW2 4 
+
+typedef struct {
+  tileset_t tileset;
+  texture_t texture;
+  color_t pixels[UI_FRAME_BORDER_WIDTH * UI_FRAME_BORDER_HEIGHT];
+} uiframe_t;
+
+extern uiframe_t UI_FRAME;
+
+/**
+ * Initializes the global UI_FRAME: builds the dummy texture and
+ * configures the tileset. Call once after displayInit().
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiFrameInit(void);
+
+/**
+ * Draws UI_FRAME using 9-slice rendering from its 3x3 tileset.
+ * Pushes quads to the sprite batch without flushing.
+ *
+ * @param x Screen x position.
+ * @param y Screen y position.
+ * @param width Total width of the frame.
+ * @param height Total height of the frame.
+ * @return Any error that occurs.
+ */
+errorret_t uiFrameDraw(
+  const float_t x,
+  const float_t y,
+  const float_t width,
+  const float_t height
+);
+
+/**
+ * Builds the 9 sprites for a 9-slice frame at the given rect. Used
+ * internally by uiFrameDraw and uiFrameDrawCached -- call directly only
+ * if you need the raw sprites instead of buffering them.
+ *
+ * @param sprites Destination array of exactly 9 sprites.
+ * @param x Screen x position.
+ * @param y Screen y position.
+ * @param width Total width of the frame.
+ * @param height Total height of the frame.
+ */
+void uiFrameBuildSprites(
+  spritebatchsprite_t sprites[9],
+  const float_t x,
+  const float_t y,
+  const float_t width,
+  const float_t height
+);
+
+/**
+ * A frame's cached 9-slice sprites, plus the rect they were built for.
+ * Owned by whichever widget/screen draws a frame repeatedly (dialogs,
+ * textboxes, settings panels) so uiFrameDrawCached can skip rebuilding
+ * the sprites when the rect hasn't moved since the last draw.
+ */
+typedef struct {
+  spritebatchsprite_t sprites[9];
+  bool_t built;
+  float_t lastX;
+  float_t lastY;
+  float_t lastWidth;
+  float_t lastHeight;
+} uiframecache_t;
+
+/**
+ * Draws a 9-slice frame using a caller-owned cache, only rebuilding the
+ * sprites (via uiFrameBuildSprites) when x/y/width/height differ from
+ * the last call -- unlike uiFrameDraw, which rebuilds unconditionally
+ * every time. Prefer this for frames redrawn every frame at a fixed or
+ * rarely-changing rect (dialogs, panels); use plain uiFrameDraw for
+ * genuinely one-off or per-frame-varying rects.
+ *
+ * @param cache Caller-owned cache, zero-initialized before first use.
+ * @param x Screen x position.
+ * @param y Screen y position.
+ * @param width Total width of the frame.
+ * @param height Total height of the frame.
+ * @return Any error that occurs.
+ */
+errorret_t uiFrameDrawCached(
+  uiframecache_t *cache,
+  const float_t x,
+  const float_t y,
+  const float_t width,
+  const float_t height
+);
+
+/**
+ * Disposes of the global UI_FRAME, releasing its GPU texture.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiFrameDispose(void);

archive/dusk/ui/overlay/uicrop.c

@@ -85,5 +85,5 @@ errorret_t uiCropDraw(void) {
     }
   };
   errorChain(spriteBatchBuffer(sprites, count, &SHADER_UNLIT, material));
-  return spriteBatchFlush();
+  errorOk();
 }

archive/dusk/ui/overlay/uifullbox.c

@@ -75,7 +75,7 @@ errorret_t uiFullboxDraw(uifullbox_t *fullbox) {
     }
   };
   errorChain(spriteBatchBuffer(&sprite, 1, &SHADER_UNLIT, material));
-  return spriteBatchFlush();
+  errorOk();
 }
 
 void uiFullboxTransition(

archive/dusk/ui/overlay/uiloading.c

@@ -11,30 +11,22 @@
 #include "time/time.h"
 #include "display/text/text.h"
 #include "display/screen/screen.h"
-#include "display/spritebatch/spritebatch.h"
 #include "uifullbox.h"
-#include "locale/localemanager.h"
-#include "asset/loader/locale/assetlocaleloader.h"
+
+#define UI_LOADING_TEXT "loading"
 
 uiloading_t UI_LOADING;
 
 errorret_t uiLoadingInit(void) {
   memoryZero(&UI_LOADING, sizeof(uiloading_t));
+  uiLabelInit(&UI_LOADING.textLabel, &FONT_DEFAULT);
+  uiLabelSetText(&UI_LOADING.textLabel, UI_LOADING_TEXT);
   eventInit(
     &UI_LOADING.onTransitionEnd,
     UI_LOADING.onTransitionEndCallbacks,
     UI_LOADING.onTransitionEndUsers,
     4
   );
-
-  errorChain(assetLocaleGetString(
-    &LOCALE.entry->data.locale,
-    "ui.loading.text",
-    0,
-    UI_LOADING.text,
-    UI_LOADING_TEXT_MAX
-  ));
-
   errorOk();
 }
 
@@ -62,7 +54,7 @@ errorret_t uiLoadingDraw(void) {
   if(alpha <= 0.0f) errorOk();
 
   int32_t textW, textH;
-  textMeasure(UI_LOADING.text, &FONT_DEFAULT, &textW, &textH);
+  uiLabelGetSize(&UI_LOADING.textLabel, &textW, &textH);
 
   float_t x = (float_t)(SCREEN.scanX + SCREEN.scanWidth) -
     (float_t)textW - UI_LOADING_MARGIN;
@@ -71,9 +63,10 @@ errorret_t uiLoadingDraw(void) {
 
   color_t color = COLOR_WHITE;
   color.a = (uint8_t)(alpha * 255.0f);
+  uiLabelSetColor(&UI_LOADING.textLabel, color);
 
-  errorChain(textDraw(x, y, UI_LOADING.text, color, &FONT_DEFAULT));
-  return spriteBatchFlush();
+  errorChain(uiLabelDraw(&UI_LOADING.textLabel, x, y));
+  errorOk();
 }
 
 static void uiLoadingTransition(

archive/dusk/ui/overlay/uiloading.h

@@ -8,10 +8,10 @@
 #pragma once
 #include "error/error.h"
 #include "event/event.h"
+#include "ui/widget/uilabel.h"
 
 #define UI_LOADING_FADE_DURATION 0.5f
 #define UI_LOADING_MARGIN 8.0f
-#define UI_LOADING_TEXT_MAX 32
 
 typedef struct {
   float_t fromAlpha;
@@ -21,7 +21,7 @@ typedef struct {
   eventcallback_t onTransitionEndCallbacks[4];
   void *onTransitionEndUsers[4];
   event_t onTransitionEnd;
-  char_t text[UI_LOADING_TEXT_MAX];
+  uilabel_t textLabel;
 } uiloading_t;
 
 extern uiloading_t UI_LOADING;

archive/dusk/ui/transition/uitransitionfade.c

@@ -52,5 +52,5 @@ errorret_t uiTransitionFadeDraw(const uitransitiondata_t *data) {
     }
   };
   errorChain(spriteBatchBuffer(&sprite, 1, &SHADER_UNLIT, material));
-  return spriteBatchFlush();
+  errorOk();
 }

archive/dusk/ui/ui.c

@@ -0,0 +1,62 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "ui.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+#include "display/spritebatch/spritebatch.h"
+#include "display/screen/screen.h"
+#include "ui/uielement.h"
+#include "ui/focus/uifocus.h"
+
+ui_t UI;
+
+errorret_t uiInit(void) {
+  memoryZero(&UI, sizeof(ui_t));
+  uiFocusInit();
+  uiElementsSort();
+
+  uielement_t *element = &UI_ELEMENTS[0];
+  while(!uiElementIsNull(element)) {
+    errorChain(uiElementInit(element));
+    element++;
+  }
+
+  errorOk();
+}
+
+errorret_t uiUpdate(void) {
+  uiFocusUpdate();
+
+  uielement_t *element = &UI_ELEMENTS[0];
+  while(!uiElementIsNull(element)) {
+    errorChain(uiElementUpdate(element));
+    element++;
+  }
+
+  errorOk();
+}
+
+errorret_t uiRender(void) {
+  const uielement_t *element = &UI_ELEMENTS[0];
+  while(!uiElementIsNull(element)) {
+    errorChain(uiElementDraw(element));
+    element++;
+  }
+
+  errorChain(spriteBatchFlush());
+  errorOk();
+}
+
+errorret_t uiDispose(void) {
+  uielement_t *element = &UI_ELEMENTS[0];
+  while(!uiElementIsNull(element)) {
+    errorChain(uiElementDispose(element));
+    element++;
+  }
+  errorOk();
+}

archive/dusk/ui/ui.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+typedef struct {
+  void *nothing;
+} ui_t;
+
+extern ui_t UI;
+
+/**
+ * Initializes the UI system.
+ */
+errorret_t uiInit(void);
+
+/**
+ * Updates the UI system.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiUpdate(void);
+
+/**
+ * Renders the UI system.
+ * 
+ * @return Any error that occurs.
+ */
+errorret_t uiRender(void);
+
+/**
+ * Disposes of the UI system.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiDispose(void);

archive/dusk/ui/uielement.c

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uielement.h"
+#include "assert/assert.h"
+#include "util/sort.h"
+#include "ui/frame/uiframe.h"
+#include "ui/debug/uifps.h"
+#include "engine/engine.h"
+#include "ui/overlay/uifullbox.h"
+#include "ui/overlay/uiloading.h"
+#include "ui/overlay/uicrop.h"
+#include "ui/transition/uitransition.h"
+#include "ui/debug/uiconsole.h"
+#include "ui/frame/uiconfirm.h"
+
+// Priming pass: X does nothing here, so this only exists to process any
+// #include directives nested in uielementlist.h/ui/uielementgame.h at
+// file scope (each such header's own #pragma once makes it a no-op on
+// the real pass below, which happens inside UI_ELEMENTS[]'s braces,
+// where a raw #include of a declaration would be invalid).
+#define X(initFn, updateFn, drawFn, disposeFn, order) // do nothing
+#include "uielementlist.h"
+#undef X
+
+uielement_t UI_ELEMENTS[] = {
+  #define X(initFn, updateFn, drawFn, disposeFn, elementOrder) \
+    { \
+      .init = initFn, .update = updateFn, .draw = drawFn, \
+      .dispose = disposeFn, .order = elementOrder \
+    },
+  #include "uielementlist.h"
+  #undef X
+
+  { 0 } // Null terminator
+};
+
+bool_t uiElementIsNull(const uielement_t *element) {
+  return element->init == NULL &&
+    element->update == NULL &&
+    element->draw == NULL &&
+    element->dispose == NULL;
+}
+
+int_t uiElementCompareOrder(const void *a, const void *b) {
+  const uielement_t *elementA = (const uielement_t *)a;
+  const uielement_t *elementB = (const uielement_t *)b;
+  if(elementA->order < elementB->order) return -1;
+  if(elementA->order > elementB->order) return 1;
+  return 0;
+}
+
+void uiElementsSort(void) {
+  // The trailing null terminator is always the last static entry -- sort
+  // everything before it, and leave it in place.
+  const size_t count = (sizeof(UI_ELEMENTS) / sizeof(UI_ELEMENTS[0])) - 1;
+  sortBubble(UI_ELEMENTS, count, sizeof(uielement_t), uiElementCompareOrder);
+}
+
+errorret_t uiElementInit(uielement_t *element) {
+  assertNotNull(element, "element must not be NULL");
+  if(element->init != NULL) errorChain(element->init());
+  errorOk();
+}
+
+errorret_t uiElementUpdate(uielement_t *element) {
+  assertNotNull(element, "element must not be NULL");
+  if(element->update != NULL) errorChain(element->update());
+  errorOk();
+}
+
+errorret_t uiElementDraw(const uielement_t *element) {
+  assertNotNull(element, "element must not be NULL");
+  if(element->draw != NULL) errorChain(element->draw());
+  errorOk();
+}
+
+errorret_t uiElementDispose(uielement_t *element) {
+  assertNotNull(element, "element must not be NULL");
+  if(element->dispose != NULL) errorChain(element->dispose());
+  errorOk();
+}

archive/dusk/ui/uielement.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+// Built-in order tiers. Lower values update/render first; ties preserve
+// their relative UI_ELEMENTS declaration order (uiElementsSort uses a
+// stable sort). Game-specific elements can use any int32_t value -- these
+// are just the ones the engine itself relies on.
+#define UI_ELEMENT_ORDER_DEFAULT 0
+#define UI_ELEMENT_ORDER_DEBUG   1000
+
+typedef struct {
+  errorret_t (*init)();
+  errorret_t (*update)();
+  errorret_t (*draw)();
+  errorret_t (*dispose)();
+  int32_t order;
+} uielement_t;
+
+extern uielement_t UI_ELEMENTS[];
+
+/**
+ * Returns true when all four callbacks on the element are NULL,
+ * which marks the end of the UI_ELEMENTS array.
+ *
+ * @param element The element to test.
+ * @returns True if the element is the null terminator.
+ */
+bool_t uiElementIsNull(const uielement_t *element);
+
+/**
+ * Compares two elements by their .order field, ascending. Matches
+ * sortcompare_t, for use with the project's sort utilities.
+ *
+ * @param a First uielement_t to compare.
+ * @param b Second uielement_t to compare.
+ * @return Negative if a < b, zero if a == b, positive if a > b.
+ */
+int_t uiElementCompareOrder(const void *a, const void *b);
+
+/**
+ * Stably sorts UI_ELEMENTS in place by .order, ascending. The trailing
+ * null terminator is never moved. Called once by uiInit -- element order
+ * is static after that, so there's no need to re-sort every frame.
+ */
+void uiElementsSort(void);
+
+/**
+ * Initializes a UI element, invoking its init callback if set.
+ *
+ * @param element The element to initialize.
+ * @return Any error that occurs.
+ */
+errorret_t uiElementInit(uielement_t *element);
+
+/**
+ * Updates a UI element, calling its update callback if set.
+ *
+ * @param element The element to update.
+ * @return Any error that occurs.
+ */
+errorret_t uiElementUpdate(uielement_t *element);
+
+/**
+ * Draws a UI element, calling its draw callback if set.
+ *
+ * @param element The element to render.
+ * @return Any error that occurs.
+ */
+errorret_t uiElementDraw(const uielement_t *element);
+
+/**
+ * Disposes of a UI element, invoking its dispose callback if set.
+ *
+ * @param element The element to dispose.
+ * @return Any error that occurs.
+ */
+errorret_t uiElementDispose(uielement_t *element);

archive/dusk/ui/uielementlist.h

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+// X(init, update, draw, dispose, order) -- pass NULL for any callback the
+// element doesn't need. order controls update/draw sequence (lower first,
+// see UI_ELEMENT_ORDER_* in uielement.h); ties preserve declaration order.
+// See uielement.c for how this expands.
+
+X(uiFrameInit, NULL, NULL, uiFrameDispose, UI_ELEMENT_ORDER_DEFAULT)
+
+// Fullbox under: above scene, below system UI.
+X(
+  uiFullboxUnderInit, uiFullboxUnderUpdate, uiFullboxUnderDraw, NULL,
+  UI_ELEMENT_ORDER_DEFAULT
+)
+
+// Text stuffs
+X(uiConfirmInit, NULL, uiConfirmDraw, uiConfirmDispose, UI_ELEMENT_ORDER_DEFAULT)
+
+X(
+  uiTransitionInit, uiTransitionUpdate, uiTransitionDraw, NULL,
+  UI_ELEMENT_ORDER_DEFAULT
+)
+
+// Fullbox over: above absolutely everything (except debug).
+X(
+  uiFullboxOverInit, uiFullboxOverUpdate, uiFullboxOverDraw, NULL,
+  UI_ELEMENT_ORDER_DEFAULT
+)
+
+X(
+  uiLoadingInit, uiLoadingUpdate, uiLoadingDraw, NULL,
+  UI_ELEMENT_ORDER_DEFAULT
+)
+
+X(uiCropInit, NULL, uiCropDraw, NULL, UI_ELEMENT_ORDER_DEFAULT)
+
+// Debug items -- always last.
+X(NULL, NULL, uiConsoleDraw, uiConsoleDispose, UI_ELEMENT_ORDER_DEBUG)
+X(uiFPSInit, NULL, uiFPSDraw, NULL, UI_ELEMENT_ORDER_DEBUG)
+
+// Game-specific UI elements (duskrpg)
+#include "ui/uielementgame.h"

archive/dusk/ui/widget/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    uibutton.c
+    uicheckbox.c
+    uitab.c
+    uislider.c
+    uidropdown.c
+    uiscrolling.c
+    uimenu.c
+    uilabel.c
+    uiwidgetlabel.c
+)

archive/dusk/ui/widget/uibutton.c

@@ -7,15 +7,15 @@
 
 #include "uibutton.h"
 #include "assert/assert.h"
-#include "util/memory.h"
 #include "display/text/text.h"
 #include "display/color.h"
 
 void uiButtonInit(uibutton_t *button, const char_t *label) {
   assertNotNull(button, "Button cannot be NULL");
   assertNotNull(label, "Label cannot be NULL");
-  memoryZero(button, sizeof(uibutton_t));
-  button->label = label;
+  uiWidgetLabelInit(&button->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&button->label, label);
+  button->highlighted = false;
 }
 
 bool_t uiButtonIsHighlighted(const uibutton_t *button) {
@@ -26,6 +26,9 @@ bool_t uiButtonIsHighlighted(const uibutton_t *button) {
 void uiButtonSetHighlighted(uibutton_t *button, const bool_t highlighted) {
   assertNotNull(button, "Button cannot be NULL");
   button->highlighted = highlighted;
+  uiWidgetLabelSetColor(
+    &button->label, highlighted ? COLOR_RED : COLOR_WHITE
+  );
 }
 
 errorret_t uiButtonDraw(
@@ -34,10 +37,6 @@ errorret_t uiButtonDraw(
   const float_t y
 ) {
   assertNotNull(button, "Button cannot be NULL");
-  errorChain(textDraw(
-    x, y, button->label,
-    button->highlighted ? COLOR_RED : COLOR_WHITE,
-    &FONT_DEFAULT
-  ));
+  errorChain(uiWidgetLabelDraw(&button->label, x, y));
   errorOk();
 }

archive/dusk/ui/widget/uibutton.h

@@ -7,9 +7,10 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/widget/uiwidgetlabel.h"
 
 typedef struct {
-  const char_t *label;
+  uiwidgetlabel_t label;
   bool_t highlighted;
 } uibutton_t;
 

archive/dusk/ui/widget/uicheckbox.c

@@ -7,6 +7,7 @@
 
 #include "uicheckbox.h"
 #include "util/memory.h"
+#include "util/string.h"
 #include "display/text/text.h"
 #include "display/color.h"
 
@@ -15,7 +16,9 @@ void uiCheckboxInit(
   const char_t *label
 ) {
   memoryZero(checkbox, sizeof(uicheckbox_t));
-  checkbox->label = label;
+  checkbox->rawLabel = label;
+  uiWidgetLabelInit(&checkbox->label, &FONT_DEFAULT);
+  uiCheckboxRebuildLabel(checkbox);
 }
 
 bool_t uiCheckboxIsChecked(const uicheckbox_t *checkbox) {
@@ -24,6 +27,7 @@ bool_t uiCheckboxIsChecked(const uicheckbox_t *checkbox) {
 
 void uiCheckboxSetChecked(uicheckbox_t *checkbox, const bool_t checked) {
   checkbox->checked = checked;
+  uiCheckboxRebuildLabel(checkbox);
 }
 
 void uiCheckboxToggle(uicheckbox_t *checkbox) {
@@ -36,6 +40,9 @@ bool_t uiCheckboxIsHighlighted(const uicheckbox_t *checkbox) {
 
 void uiCheckboxSetHighlighted(uicheckbox_t *checkbox, const bool_t highlighted) {
   checkbox->highlighted = highlighted;
+  uiWidgetLabelSetColor(
+    &checkbox->label, highlighted ? COLOR_RED : COLOR_WHITE
+  );
 }
 
 errorret_t uiCheckboxDraw(
@@ -43,15 +50,15 @@ errorret_t uiCheckboxDraw(
   const float_t x,
   const float_t y
 ) {
-  color_t color = checkbox->highlighted ? COLOR_RED : COLOR_WHITE;
-  const char_t *mark = checkbox->checked ? "Y " : "N ";
-  errorChain(textDraw(x, y, mark, color, &FONT_DEFAULT));
-
-  int32_t markW, markH;
-  textMeasure(mark, &FONT_DEFAULT, &markW, &markH);
-  errorChain(textDraw(
-    x + (float_t)markW, y, checkbox->label, color, &FONT_DEFAULT
-  ));
-
+  errorChain(uiWidgetLabelDraw(&checkbox->label, x, y));
   errorOk();
 }
+
+void uiCheckboxRebuildLabel(uicheckbox_t *checkbox) {
+  char_t combined[UI_WIDGET_LABEL_TEXT_MAX];
+  stringFormat(
+    combined, UI_WIDGET_LABEL_TEXT_MAX - 1, "%s %s",
+    checkbox->checked ? "Y" : "N", checkbox->rawLabel
+  );
+  uiWidgetLabelSetText(&checkbox->label, combined);
+}

archive/dusk/ui/widget/uicheckbox.h

@@ -7,9 +7,11 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/widget/uiwidgetlabel.h"
 
 typedef struct uicheckbox_s {
-  const char_t *label;
+  const char_t *rawLabel;
+  uiwidgetlabel_t label;
   bool_t checked;
   bool_t highlighted;
 } uicheckbox_t;
@@ -77,3 +79,12 @@ errorret_t uiCheckboxDraw(
   const float_t x,
   const float_t y
 );
+
+/**
+ * Rebuilds the checkbox's cached label ("Y "/"N " mark plus rawLabel)
+ * from its current checked state. Called internally whenever checked
+ * changes.
+ *
+ * @param checkbox The checkbox to update.
+ */
+void uiCheckboxRebuildLabel(uicheckbox_t *checkbox);

archive/dusk/ui/widget/uidropdown.c

@@ -25,10 +25,13 @@ void uiDropdownInit(
   assertTrue(optionCount > 0, "Dropdown must have at least one option");
 
   memoryZero(dropdown, sizeof(uidropdown_t));
-  dropdown->label = label;
+  uiWidgetLabelInit(&dropdown->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&dropdown->label, label);
+  uiWidgetLabelInit(&dropdown->value, &FONT_DEFAULT);
   dropdown->options = options;
   dropdown->optionCount = optionCount;
   dropdown->selectedIndex = selectedIndex < optionCount ? selectedIndex : 0;
+  uiDropdownRebuildValue(dropdown);
 }
 
 uint8_t uiDropdownGetSelectedIndex(const uidropdown_t *dropdown) {
@@ -45,18 +48,21 @@ void uiDropdownSetSelectedIndex(uidropdown_t *dropdown, const uint8_t index) {
   assertNotNull(dropdown, "Dropdown cannot be NULL");
   assertTrue(index < dropdown->optionCount, "Dropdown index out of range");
   dropdown->selectedIndex = index;
+  uiDropdownRebuildValue(dropdown);
 }
 
 void uiDropdownStepNext(uidropdown_t *dropdown) {
   assertNotNull(dropdown, "Dropdown cannot be NULL");
   dropdown->selectedIndex =
     (dropdown->selectedIndex + 1) % dropdown->optionCount;
+  uiDropdownRebuildValue(dropdown);
 }
 
 void uiDropdownStepPrev(uidropdown_t *dropdown) {
   assertNotNull(dropdown, "Dropdown cannot be NULL");
   dropdown->selectedIndex = dropdown->selectedIndex == 0 ?
     dropdown->optionCount - 1 : dropdown->selectedIndex - 1;
+  uiDropdownRebuildValue(dropdown);
 }
 
 bool_t uiDropdownIsHighlighted(const uidropdown_t *dropdown) {
@@ -70,6 +76,9 @@ void uiDropdownSetHighlighted(
 ) {
   assertNotNull(dropdown, "Dropdown cannot be NULL");
   dropdown->highlighted = highlighted;
+  color_t color = highlighted ? COLOR_RED : COLOR_WHITE;
+  uiWidgetLabelSetColor(&dropdown->label, color);
+  uiWidgetLabelSetColor(&dropdown->value, color);
 }
 
 errorret_t uiDropdownDraw(
@@ -79,22 +88,23 @@ errorret_t uiDropdownDraw(
 ) {
   assertNotNull(dropdown, "Dropdown cannot be NULL");
 
-  color_t color = dropdown->highlighted ? COLOR_RED : COLOR_WHITE;
-
-  errorChain(textDraw(x, y, dropdown->label, color, &FONT_DEFAULT));
+  errorChain(uiWidgetLabelDraw(&dropdown->label, x, y));
 
   int32_t labelW, labelH;
-  textMeasure(dropdown->label, &FONT_DEFAULT, &labelW, &labelH);
+  uiWidgetLabelGetSize(&dropdown->label, &labelW, &labelH);
 
-  char_t valueText[UI_DROPDOWN_VALUE_TEXT_MAX];
-  stringFormat(
-    valueText, UI_DROPDOWN_VALUE_TEXT_MAX - 1, "< %s >",
-    uiDropdownGetSelectedOption(dropdown)
-  );
-
-  errorChain(textDraw(
-    x + (float_t)labelW + UI_DROPDOWN_GAP, y, valueText, color, &FONT_DEFAULT
+  errorChain(uiWidgetLabelDraw(
+    &dropdown->value, x + (float_t)labelW + UI_DROPDOWN_GAP, y
   ));
 
   errorOk();
 }
+
+void uiDropdownRebuildValue(uidropdown_t *dropdown) {
+  char_t valueText[UI_WIDGET_LABEL_TEXT_MAX];
+  stringFormat(
+    valueText, UI_WIDGET_LABEL_TEXT_MAX - 1, "< %s >",
+    uiDropdownGetSelectedOption(dropdown)
+  );
+  uiWidgetLabelSetText(&dropdown->value, valueText);
+}

archive/dusk/ui/widget/uidropdown.h

@@ -7,12 +7,13 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/widget/uiwidgetlabel.h"
 
 #define UI_DROPDOWN_GAP 4.0f
-#define UI_DROPDOWN_VALUE_TEXT_MAX 64
 
 typedef struct {
-  const char_t *label;
+  uiwidgetlabel_t label;
+  uiwidgetlabel_t value;
   const char_t *const *options;
   uint8_t optionCount;
   uint8_t selectedIndex;
@@ -111,3 +112,12 @@ errorret_t uiDropdownDraw(
   const float_t x,
   const float_t y
 );
+
+/**
+ * Rebuilds the dropdown's cached value label ("< option >") from its
+ * current selectedIndex. Called internally whenever selectedIndex
+ * changes.
+ *
+ * @param dropdown The dropdown to update.
+ */
+void uiDropdownRebuildValue(uidropdown_t *dropdown);

archive/dusk/ui/widget/uilabel.c

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uilabel.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+#include "display/text/text.h"
+
+void uiLabelInit(uilabel_t *label, font_t *font) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(font, "Font cannot be NULL");
+
+  memoryZero(label, sizeof(uilabel_t));
+  label->font = font;
+  label->color = COLOR_WHITE;
+}
+
+void uiLabelSetText(uilabel_t *label, const char_t *text) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(text, "Text cannot be NULL");
+  assertStrLenMax(text, UI_LABEL_TEXT_MAX, "Label text too long");
+
+  stringCopy(label->text, text, UI_LABEL_TEXT_MAX);
+  label->spriteCount = textBuildSpriteCache(
+    label->text, label->font, label->sprites, UI_LABEL_SPRITE_COUNT_MAX,
+    &label->width, &label->height
+  );
+}
+
+void uiLabelSetColor(uilabel_t *label, const color_t color) {
+  assertNotNull(label, "Label cannot be NULL");
+  label->color = color;
+}
+
+void uiLabelGetSize(
+  const uilabel_t *label,
+  int32_t *outWidth,
+  int32_t *outHeight
+) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(outWidth, "Output width cannot be NULL");
+  assertNotNull(outHeight, "Output height cannot be NULL");
+  *outWidth = label->width;
+  *outHeight = label->height;
+}
+
+errorret_t uiLabelDraw(
+  const uilabel_t *label,
+  const float_t x,
+  const float_t y
+) {
+  assertNotNull(label, "Label cannot be NULL");
+  if(label->spriteCount == 0) errorOk();
+
+  // Cached sprites are relative to (0,0); textDrawSpriteCache translates
+  // into the requested screen position here instead of in
+  // uiLabelSetText, so a label can be repositioned every frame without
+  // rebuilding the (much more expensive) glyph/UV cache.
+  spritebatchsprite_t scratch[UI_LABEL_SPRITE_COUNT_MAX];
+  errorChain(textDrawSpriteCache(
+    label->sprites, label->spriteCount, scratch, x, y, label->color,
+    label->font->texture
+  ));
+  errorOk();
+}

archive/dusk/ui/widget/uilabel.h

@@ -0,0 +1,85 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/text/font.h"
+#include "display/spritebatch/spritebatchsprite.h"
+#include "display/color.h"
+
+#define UI_LABEL_TEXT_MAX 256
+#define UI_LABEL_SPRITE_COUNT_MAX UI_LABEL_TEXT_MAX
+
+typedef struct {
+  char_t text[UI_LABEL_TEXT_MAX];
+  color_t color;
+  font_t *font;
+
+  spritebatchsprite_t sprites[UI_LABEL_SPRITE_COUNT_MAX];
+  uint32_t spriteCount;
+  int32_t width;
+  int32_t height;
+} uilabel_t;
+
+/**
+ * Initializes a label, defaulting to white text and no text set.
+ *
+ * @param label The label to initialize.
+ * @param font Font to use for rendering. Must outlive the label.
+ */
+void uiLabelInit(uilabel_t *label, font_t *font);
+
+/**
+ * Sets the label's text, rebuilding its cached sprites (glyph lookup, UV,
+ * and layout) immediately. This is the only way the sprite cache gets
+ * rebuilt -- uiLabelDraw never recomputes it, so call this whenever the
+ * text changes rather than once up front and expecting it to stay in sync.
+ *
+ * @param label The label to update.
+ * @param text Null-terminated string to display. Must be shorter than
+ * UI_LABEL_TEXT_MAX.
+ */
+void uiLabelSetText(uilabel_t *label, const char_t *text);
+
+/**
+ * Sets the label's tint color. Cheap -- doesn't touch the sprite cache,
+ * since color is applied via the draw material, not baked into sprites.
+ *
+ * @param label The label to update.
+ * @param color The new tint color.
+ */
+void uiLabelSetColor(uilabel_t *label, const color_t color);
+
+/**
+ * Gets the measured size (in pixels) of the label's current text, cached
+ * from the last uiLabelSetText call.
+ *
+ * @param label The label to query.
+ * @param outWidth Pointer to store the width.
+ * @param outHeight Pointer to store the height.
+ */
+void uiLabelGetSize(
+  const uilabel_t *label,
+  int32_t *outWidth,
+  int32_t *outHeight
+);
+
+/**
+ * Draws the label's cached sprites at the given screen position in a
+ * single batched buffer call. Does not recompute glyph layout -- call
+ * uiLabelSetText first whenever the text changes.
+ *
+ * @param label The label to draw.
+ * @param x Screen x position.
+ * @param y Screen y position.
+ * @return Any error that occurs.
+ */
+errorret_t uiLabelDraw(
+  const uilabel_t *label,
+  const float_t x,
+  const float_t y
+);

archive/dusk/ui/widget/uimenu.c

@@ -10,6 +10,7 @@
 #include "util/memory.h"
 #include "display/text/text.h"
 #include "display/color.h"
+#include "ui/widget/uiwidgetlabel.h"
 #include "ui/widget/uibutton.h"
 #include "ui/widget/uitab.h"
 #include "ui/widget/uislider.h"
@@ -102,12 +103,8 @@ errorret_t uiMenuDraw(
 
     if(item->type == UI_MENU_WIDGET_TYPE_LABEL) {
       if(col > 0) { row++; col = 0; }
-      errorChain(textDraw(
-        x,
-        y + (float_t)row * rowHeight,
-        item->label,
-        COLOR_WHITE,
-        &FONT_DEFAULT
+      errorChain(uiWidgetLabelDraw(
+        &item->label, x, y + (float_t)row * rowHeight
       ));
       row++;
       continue;
@@ -274,6 +271,13 @@ uint8_t uiMenuFocusSlotToIndex(const uimenu_t *menu, const uint8_t slot) {
   return 0xFF;
 }
 
+void uiMenuLabelInit(uimenuitem_t *item, const char_t *text) {
+  assertNotNull(item, "Item cannot be NULL");
+  assertNotNull(text, "Text cannot be NULL");
+  uiWidgetLabelInit(&item->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&item->label, text);
+}
+
 void uiMenuItemSetHighlighted(uimenuitem_t *item, const bool_t highlighted) {
   if(item->type == UI_MENU_WIDGET_TYPE_CHECKBOX) {
     uiCheckboxSetHighlighted(&item->checkbox, highlighted);

archive/dusk/ui/widget/uimenu.h

@@ -8,14 +8,13 @@
 #pragma once
 #include "error/error.h"
 #include "ui/focus/uifocus.h"
+#include "ui/widget/uiwidgetlabel.h"
 #include "ui/widget/uibutton.h"
 #include "ui/widget/uicheckbox.h"
 #include "ui/widget/uitab.h"
 #include "ui/widget/uislider.h"
 #include "ui/widget/uidropdown.h"
 
-#define UI_MENU_LABEL_MAX UI_CHECKBOX_LABEL_MAX
-
 typedef struct uimenu_s uimenu_t;
 
 typedef enum {
@@ -32,7 +31,7 @@ typedef enum {
 typedef struct {
   uimenuwidgettype_t type;
   union {
-    char_t *label;
+    uiwidgetlabel_t label;
     uicheckbox_t checkbox;
     uibutton_t button;
     uitab_t tab;
@@ -178,6 +177,15 @@ uint8_t uiMenuFocusSlotToIndex(const uimenu_t *menu, const uint8_t slot);
  */
 void uiMenuItemSetHighlighted(uimenuitem_t *item, const bool_t highlighted);
 
+/**
+ * Initializes a menu item as a standalone label, caching its text.
+ * Used internally by the MENU_LABEL helper macro.
+ *
+ * @param item The item to initialize.
+ * @param text Display text.
+ */
+void uiMenuLabelInit(uimenuitem_t *item, const char_t *text);
+
 /**
  * Internal focus callback  -  forwards selection to the menu's selected handler.
  *
@@ -227,7 +235,7 @@ bool_t uiMenuFocusDirection(
 #define MENU_LABEL(text) \
   assertTrue(menuIndex < menuCapacity, "Menu item count exceeds capacity"); \
   menu->items[menuIndex].type = UI_MENU_WIDGET_TYPE_LABEL; \
-  menu->items[menuIndex].label = text; \
+  uiMenuLabelInit(&menu->items[menuIndex], text); \
   ++menuIndex
 
 #define MENU_SPACER() \

archive/dusk/ui/widget/uislider.c

@@ -30,12 +30,16 @@ void uiSliderInitFloat(
   assertTrue(step > 0.0f, "Slider step must be greater than zero");
 
   memoryZero(slider, sizeof(uislider_t));
-  slider->label = label;
+  uiWidgetLabelInit(&slider->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&slider->label, label);
+  uiWidgetLabelInit(&slider->valueLabel, &FONT_DEFAULT);
   slider->type = UI_SLIDER_TYPE_FLOAT;
   slider->min.f = min;
   slider->max.f = max;
   slider->step.f = step;
   slider->value.f = mathClamp(value, min, max);
+  uiSliderRebuildValueLabel(slider);
+  uiSliderRebuildGeometry(slider);
 }
 
 void uiSliderInitInt(
@@ -52,12 +56,16 @@ void uiSliderInitInt(
   assertTrue(step > 0, "Slider step must be greater than zero");
 
   memoryZero(slider, sizeof(uislider_t));
-  slider->label = label;
+  uiWidgetLabelInit(&slider->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&slider->label, label);
+  uiWidgetLabelInit(&slider->valueLabel, &FONT_DEFAULT);
   slider->type = UI_SLIDER_TYPE_INT;
   slider->min.i = min;
   slider->max.i = max;
   slider->step.i = step;
   slider->value.i = mathClamp(value, min, max);
+  uiSliderRebuildValueLabel(slider);
+  uiSliderRebuildGeometry(slider);
 }
 
 float_t uiSliderGetFloat(const uislider_t *slider) {
@@ -80,6 +88,8 @@ void uiSliderSetFloat(uislider_t *slider, const float_t value) {
     slider->type == UI_SLIDER_TYPE_FLOAT, "Slider is not a float slider"
   );
   slider->value.f = mathClamp(value, slider->min.f, slider->max.f);
+  uiSliderRebuildValueLabel(slider);
+  uiSliderRebuildGeometry(slider);
 }
 
 void uiSliderSetInt(uislider_t *slider, const int32_t value) {
@@ -88,6 +98,8 @@ void uiSliderSetInt(uislider_t *slider, const int32_t value) {
     slider->type == UI_SLIDER_TYPE_INT, "Slider is not an int slider"
   );
   slider->value.i = mathClamp(value, slider->min.i, slider->max.i);
+  uiSliderRebuildValueLabel(slider);
+  uiSliderRebuildGeometry(slider);
 }
 
 void uiSliderStepUp(uislider_t *slider) {
@@ -138,6 +150,9 @@ bool_t uiSliderIsHighlighted(const uislider_t *slider) {
 void uiSliderSetHighlighted(uislider_t *slider, const bool_t highlighted) {
   assertNotNull(slider, "Slider cannot be NULL");
   slider->highlighted = highlighted;
+  color_t color = highlighted ? COLOR_RED : COLOR_WHITE;
+  uiWidgetLabelSetColor(&slider->label, color);
+  uiWidgetLabelSetColor(&slider->valueLabel, color);
 }
 
 errorret_t uiSliderDraw(
@@ -147,47 +162,97 @@ errorret_t uiSliderDraw(
 ) {
   assertNotNull(slider, "Slider cannot be NULL");
 
-  color_t color = slider->highlighted ? COLOR_RED : COLOR_WHITE;
+  errorChain(uiWidgetLabelDraw(&slider->label, x, y));
 
-  errorChain(textDraw(x, y, slider->label, color, &FONT_DEFAULT));
-
-  int32_t labelW, labelH;
-  textMeasure(slider->label, &FONT_DEFAULT, &labelW, &labelH);
-
-  float_t trackX = x + (float_t)labelW + UI_SLIDER_GAP;
-  float_t trackY = y + ((float_t)labelH - UI_SLIDER_TRACK_HEIGHT) * 0.5f;
-
-  spritebatchsprite_t trackSprite = {
-    .min = { trackX, trackY, 0.0f },
-    .max = { trackX + UI_SLIDER_TRACK_WIDTH, trackY + UI_SLIDER_TRACK_HEIGHT, 0.0f },
-    .uvMin = { 0.0f, 0.0f },
-    .uvMax = { 1.0f, 1.0f }
-  };
   shadermaterial_t trackMaterial = {
     .unlit = {
       .color = COLOR_DARK_GRAY,
       .texture = &TEXTURE_WHITE
     }
   };
-  errorChain(spriteBatchBuffer(&trackSprite, 1, &SHADER_UNLIT, trackMaterial));
-  errorChain(spriteBatchFlush());
+  spritebatchsprite_t track = spriteBatchSpriteTranslate(
+    &slider->cachedTrack, x, y
+  );
+  errorChain(spriteBatchBuffer(&track, 1, &SHADER_UNLIT, trackMaterial));
+
+  if(slider->cachedFillVisible) {
+    shadermaterial_t fillMaterial = {
+      .unlit = {
+        .color = slider->highlighted ? COLOR_RED : COLOR_WHITE,
+        .texture = &TEXTURE_WHITE
+      }
+    };
+    spritebatchsprite_t fill = spriteBatchSpriteTranslate(
+      &slider->cachedFill, x, y
+    );
+    errorChain(spriteBatchBuffer(&fill, 1, &SHADER_UNLIT, fillMaterial));
+  }
+
+  if(slider->cachedMarkerCount > 0) {
+    spritebatchsprite_t markers[UI_SLIDER_STEP_MARKERS_MAX];
+    for(int32_t i = 0; i < slider->cachedMarkerCount; i++) {
+      markers[i] = spriteBatchSpriteTranslate(&slider->cachedMarkers[i], x, y);
+    }
+
+    shadermaterial_t markerMaterial = {
+      .unlit = {
+        .color = COLOR_WHITE,
+        .texture = &TEXTURE_WHITE
+      }
+    };
+    errorChain(spriteBatchBuffer(
+      markers, slider->cachedMarkerCount, &SHADER_UNLIT, markerMaterial
+    ));
+  }
+
+  errorChain(uiWidgetLabelDraw(
+    &slider->valueLabel,
+    x + slider->cachedTrack.max[0] + UI_SLIDER_GAP,
+    y
+  ));
+
+  errorOk();
+}
+
+void uiSliderRebuildValueLabel(uislider_t *slider) {
+  char_t valueText[UI_WIDGET_LABEL_TEXT_MAX];
+  if(slider->type == UI_SLIDER_TYPE_INT) {
+    stringFormat(
+      valueText, UI_WIDGET_LABEL_TEXT_MAX - 1, "%d", slider->value.i
+    );
+  } else {
+    stringFormat(
+      valueText, UI_WIDGET_LABEL_TEXT_MAX - 1, "%.2f", slider->value.f
+    );
+  }
+  uiWidgetLabelSetText(&slider->valueLabel, valueText);
+}
+
+void uiSliderRebuildGeometry(uislider_t *slider) {
+  int32_t labelW, labelH;
+  uiWidgetLabelGetSize(&slider->label, &labelW, &labelH);
+
+  float_t trackX = (float_t)labelW + UI_SLIDER_GAP;
+  float_t trackY = ((float_t)labelH - UI_SLIDER_TRACK_HEIGHT) * 0.5f;
+
+  slider->cachedTrack = (spritebatchsprite_t){
+    .min = { trackX, trackY, 0.0f },
+    .max = {
+      trackX + UI_SLIDER_TRACK_WIDTH, trackY + UI_SLIDER_TRACK_HEIGHT, 0.0f
+    },
+    .uvMin = { 0.0f, 0.0f },
+    .uvMax = { 1.0f, 1.0f }
+  };
 
   float_t fillWidth = UI_SLIDER_TRACK_WIDTH * uiSliderGetRatio(slider);
-  if(fillWidth > 0.0f) {
-    spritebatchsprite_t fillSprite = {
+  slider->cachedFillVisible = fillWidth > 0.0f;
+  if(slider->cachedFillVisible) {
+    slider->cachedFill = (spritebatchsprite_t){
       .min = { trackX, trackY, 0.0f },
       .max = { trackX + fillWidth, trackY + UI_SLIDER_TRACK_HEIGHT, 0.0f },
       .uvMin = { 0.0f, 0.0f },
       .uvMax = { 1.0f, 1.0f }
     };
-    shadermaterial_t fillMaterial = {
-      .unlit = {
-        .color = color,
-        .texture = &TEXTURE_WHITE
-      }
-    };
-    errorChain(spriteBatchBuffer(&fillSprite, 1, &SHADER_UNLIT, fillMaterial));
-    errorChain(spriteBatchFlush());
   }
 
   int32_t stepCount = uiSliderGetStepCount(slider);
@@ -195,7 +260,7 @@ errorret_t uiSliderDraw(
     for(int32_t i = 0; i <= stepCount; i++) {
       float_t markerX = trackX +
         UI_SLIDER_TRACK_WIDTH * (float_t)i / (float_t)stepCount;
-      spritebatchsprite_t markerSprite = {
+      slider->cachedMarkers[i] = (spritebatchsprite_t){
         .min = {
           markerX - UI_SLIDER_STEP_MARKER_WIDTH * 0.5f,
           trackY - UI_SLIDER_STEP_MARKER_OVERHANG,
@@ -209,34 +274,9 @@ errorret_t uiSliderDraw(
         .uvMin = { 0.0f, 0.0f },
         .uvMax = { 1.0f, 1.0f }
       };
-      shadermaterial_t markerMaterial = {
-        .unlit = {
-          .color = COLOR_WHITE,
-          .texture = &TEXTURE_WHITE
-        }
-      };
-      errorChain(
-        spriteBatchBuffer(&markerSprite, 1, &SHADER_UNLIT, markerMaterial)
-      );
-      errorChain(spriteBatchFlush());
     }
-  }
-
-  char_t valueText[UI_SLIDER_VALUE_TEXT_MAX];
-  if(slider->type == UI_SLIDER_TYPE_INT) {
-    stringFormat(
-      valueText, UI_SLIDER_VALUE_TEXT_MAX - 1, "%d", slider->value.i
-    );
+    slider->cachedMarkerCount = stepCount + 1;
   } else {
-    stringFormat(
-      valueText, UI_SLIDER_VALUE_TEXT_MAX - 1, "%.2f", slider->value.f
-    );
+    slider->cachedMarkerCount = 0;
   }
-
-  errorChain(textDraw(
-    trackX + UI_SLIDER_TRACK_WIDTH + UI_SLIDER_GAP, y,
-    valueText, color, &FONT_DEFAULT
-  ));
-
-  errorOk();
 }

archive/dusk/ui/widget/uislider.h

@@ -7,13 +7,14 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/widget/uiwidgetlabel.h"
+#include "display/spritebatch/spritebatchsprite.h"
 
 #define UI_SLIDER_TRACK_WIDTH 80.0f
 #define UI_SLIDER_TRACK_HEIGHT 4.0f
 #define UI_SLIDER_STEP_MARKER_WIDTH 2.0f
 #define UI_SLIDER_STEP_MARKER_OVERHANG 1.0f
 #define UI_SLIDER_GAP 4.0f
-#define UI_SLIDER_VALUE_TEXT_MAX 16
 
 /**
  * Number of discrete steps below which an int slider renders individual
@@ -34,13 +35,24 @@ typedef union {
 } uislidervalue_t;
 
 typedef struct {
-  const char_t *label;
+  uiwidgetlabel_t label;
+  uiwidgetlabel_t valueLabel;
   uislidertype_t type;
   uislidervalue_t value;
   uislidervalue_t min;
   uislidervalue_t max;
   uislidervalue_t step;
   bool_t highlighted;
+
+  // Track/fill/marker geometry, cached relative to origin (0,0) and only
+  // rebuilt when the value or step configuration changes (see
+  // uiSliderRebuildGeometry) -- uiSliderDraw just translates these into
+  // position instead of re-deriving them every frame.
+  spritebatchsprite_t cachedTrack;
+  spritebatchsprite_t cachedFill;
+  bool_t cachedFillVisible;
+  spritebatchsprite_t cachedMarkers[UI_SLIDER_STEP_MARKERS_MAX];
+  int32_t cachedMarkerCount;
 } uislider_t;
 
 /**
@@ -183,3 +195,21 @@ errorret_t uiSliderDraw(
   const float_t x,
   const float_t y
 );
+
+/**
+ * Rebuilds the slider's cached value label from its current value.
+ * Called internally whenever value changes.
+ *
+ * @param slider The slider to update.
+ */
+void uiSliderRebuildValueLabel(uislider_t *slider);
+
+/**
+ * Rebuilds the slider's cached track/fill/marker geometry (relative to
+ * origin (0,0)) from its current label size, value, and step
+ * configuration. Called internally on init and whenever the value
+ * changes -- uiSliderDraw never recomputes this itself.
+ *
+ * @param slider The slider to update.
+ */
+void uiSliderRebuildGeometry(uislider_t *slider);

archive/dusk/ui/widget/uitab.c

@@ -7,7 +7,6 @@
 
 #include "uitab.h"
 #include "assert/assert.h"
-#include "util/memory.h"
 #include "display/text/text.h"
 #include "display/color.h"
 #include "display/spritebatch/spritebatch.h"
@@ -17,8 +16,10 @@
 void uiTabInit(uitab_t *tab, const char_t *label) {
   assertNotNull(tab, "Tab cannot be NULL");
   assertNotNull(label, "Label cannot be NULL");
-  memoryZero(tab, sizeof(uitab_t));
-  tab->label = label;
+  uiWidgetLabelInit(&tab->label, &FONT_DEFAULT);
+  uiWidgetLabelSetText(&tab->label, label);
+  tab->active = false;
+  uiTabRebuildBackground(tab);
 }
 
 bool_t uiTabIsActive(const uitab_t *tab) {
@@ -38,15 +39,9 @@ errorret_t uiTabDraw(
 ) {
   assertNotNull(tab, "Tab cannot be NULL");
 
-  int32_t labelW, labelH;
-  textMeasure(tab->label, &FONT_DEFAULT, &labelW, &labelH);
-
-  spritebatchsprite_t sprite = {
-    .min = { x, y, 0.0f },
-    .max = { x + (float_t)labelW, y + (float_t)labelH, 0.0f },
-    .uvMin = { 0.0f, 0.0f },
-    .uvMax = { 1.0f, 1.0f }
-  };
+  spritebatchsprite_t sprite = spriteBatchSpriteTranslate(
+    &tab->cachedBackground, x, y
+  );
   shadermaterial_t material = {
     .unlit = {
       .color = tab->active ? COLOR_GREEN : COLOR_RED,
@@ -54,9 +49,21 @@ errorret_t uiTabDraw(
     }
   };
   errorChain(spriteBatchBuffer(&sprite, 1, &SHADER_UNLIT, material));
-  errorChain(spriteBatchFlush());
 
-  errorChain(textDraw(x, y, tab->label, COLOR_WHITE, &FONT_DEFAULT));
+  errorChain(uiWidgetLabelDraw(&tab->label, x, y));
 
   errorOk();
 }
+
+void uiTabRebuildBackground(uitab_t *tab) {
+  assertNotNull(tab, "Tab cannot be NULL");
+
+  int32_t labelW, labelH;
+  uiWidgetLabelGetSize(&tab->label, &labelW, &labelH);
+  tab->cachedBackground = (spritebatchsprite_t){
+    .min = { 0.0f, 0.0f, 0.0f },
+    .max = { (float_t)labelW, (float_t)labelH, 0.0f },
+    .uvMin = { 0.0f, 0.0f },
+    .uvMax = { 1.0f, 1.0f }
+  };
+}

archive/dusk/ui/widget/uitab.h

@@ -7,10 +7,17 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/widget/uiwidgetlabel.h"
+#include "display/spritebatch/spritebatchsprite.h"
 
 typedef struct {
-  const char_t *label;
+  uiwidgetlabel_t label;
   bool_t active;
+
+  // Background quad, cached relative to origin (0,0) from the label's
+  // size at init -- uiTabDraw only translates this into position, since
+  // active/inactive only changes the material color, not the geometry.
+  spritebatchsprite_t cachedBackground;
 } uitab_t;
 
 /**
@@ -51,3 +58,13 @@ errorret_t uiTabDraw(
   const float_t x,
   const float_t y
 );
+
+/**
+ * Rebuilds the tab's cached background quad (relative to origin (0,0))
+ * from its current label size. Called internally by uiTabInit -- the
+ * background's geometry never changes afterwards, since the tab has no
+ * API to change its label text.
+ *
+ * @param tab The tab to update.
+ */
+void uiTabRebuildBackground(uitab_t *tab);

archive/dusk/ui/widget/uiwidgetlabel.c

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uiwidgetlabel.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+#include "display/text/text.h"
+
+void uiWidgetLabelInit(uiwidgetlabel_t *label, font_t *font) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(font, "Font cannot be NULL");
+
+  memoryZero(label, sizeof(uiwidgetlabel_t));
+  label->font = font;
+  label->color = COLOR_WHITE;
+}
+
+void uiWidgetLabelSetText(uiwidgetlabel_t *label, const char_t *text) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(text, "Text cannot be NULL");
+  assertStrLenMax(text, UI_WIDGET_LABEL_TEXT_MAX, "Label text too long");
+
+  stringCopy(label->text, text, UI_WIDGET_LABEL_TEXT_MAX);
+  label->spriteCount = textBuildSpriteCache(
+    label->text, label->font, label->sprites,
+    UI_WIDGET_LABEL_SPRITE_COUNT_MAX, &label->width, &label->height
+  );
+}
+
+void uiWidgetLabelSetColor(uiwidgetlabel_t *label, const color_t color) {
+  assertNotNull(label, "Label cannot be NULL");
+  label->color = color;
+}
+
+void uiWidgetLabelGetSize(
+  const uiwidgetlabel_t *label,
+  int32_t *outWidth,
+  int32_t *outHeight
+) {
+  assertNotNull(label, "Label cannot be NULL");
+  assertNotNull(outWidth, "Output width cannot be NULL");
+  assertNotNull(outHeight, "Output height cannot be NULL");
+  *outWidth = label->width;
+  *outHeight = label->height;
+}
+
+errorret_t uiWidgetLabelDraw(
+  const uiwidgetlabel_t *label,
+  const float_t x,
+  const float_t y
+) {
+  assertNotNull(label, "Label cannot be NULL");
+  if(label->spriteCount == 0) errorOk();
+
+  spritebatchsprite_t scratch[UI_WIDGET_LABEL_SPRITE_COUNT_MAX];
+  errorChain(textDrawSpriteCache(
+    label->sprites, label->spriteCount, scratch, x, y, label->color,
+    label->font->texture
+  ));
+  errorOk();
+}

archive/dusk/ui/widget/uiwidgetlabel.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+#include "display/text/font.h"
+#include "display/spritebatch/spritebatchsprite.h"
+#include "display/color.h"
+
+// A cached, cheap-to-redraw label sized for embedding directly inside
+// small widgets (buttons, checkboxes, sliders, ...) rather than
+// referencing text by pointer and re-deriving glyph geometry every
+// frame. Capacity is intentionally much smaller than uilabel_t's -- it
+// gets embedded by value in every widget instance (and inside
+// uimenuitem_t's union, which is often arrayed), so keeping it small
+// matters on memory-constrained targets. See uilabel_t for the
+// general-purpose, larger-capacity equivalent.
+#define UI_WIDGET_LABEL_TEXT_MAX 64
+#define UI_WIDGET_LABEL_SPRITE_COUNT_MAX UI_WIDGET_LABEL_TEXT_MAX
+
+typedef struct {
+  char_t text[UI_WIDGET_LABEL_TEXT_MAX];
+  color_t color;
+  font_t *font;
+
+  spritebatchsprite_t sprites[UI_WIDGET_LABEL_SPRITE_COUNT_MAX];
+  uint32_t spriteCount;
+  int32_t width;
+  int32_t height;
+} uiwidgetlabel_t;
+
+/**
+ * Initializes a widget label, defaulting to white text and no text set.
+ *
+ * @param label The label to initialize.
+ * @param font Font to use for rendering. Must outlive the label.
+ */
+void uiWidgetLabelInit(uiwidgetlabel_t *label, font_t *font);
+
+/**
+ * Sets the label's text, rebuilding its cached sprites immediately.
+ * Call this whenever the displayed text changes -- uiWidgetLabelDraw
+ * never recomputes it.
+ *
+ * @param label The label to update.
+ * @param text Null-terminated string to display. Must be shorter than
+ * UI_WIDGET_LABEL_TEXT_MAX.
+ */
+void uiWidgetLabelSetText(uiwidgetlabel_t *label, const char_t *text);
+
+/**
+ * Sets the label's tint color. Cheap -- doesn't touch the sprite cache.
+ *
+ * @param label The label to update.
+ * @param color The new tint color.
+ */
+void uiWidgetLabelSetColor(uiwidgetlabel_t *label, const color_t color);
+
+/**
+ * Gets the measured size (in pixels) of the label's current text, cached
+ * from the last uiWidgetLabelSetText call.
+ *
+ * @param label The label to query.
+ * @param outWidth Pointer to store the width.
+ * @param outHeight Pointer to store the height.
+ */
+void uiWidgetLabelGetSize(
+  const uiwidgetlabel_t *label,
+  int32_t *outWidth,
+  int32_t *outHeight
+);
+
+/**
+ * Draws the label's cached sprites at the given screen position in a
+ * single batched buffer call. Does not recompute glyph layout.
+ *
+ * @param label The label to draw.
+ * @param x Screen x position.
+ * @param y Screen y position.
+ * @return Any error that occurs.
+ */
+errorret_t uiWidgetLabelDraw(
+  const uiwidgetlabel_t *label,
+  const float_t x,
+  const float_t y
+);

archive/duskrpg/ui/textbox/CMakeLists.txt

@@ -3,8 +3,8 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    assetchunkloader.c
+    uitextbox.c
+    uitextboxmain.c
 )

archive/duskrpg/ui/textbox/uitextbox.c

@@ -33,6 +33,7 @@ void uiTextboxInit(
   box->maxLength = maxLength;
   box->lines = lines;
   box->linesMax = linesMax;
+  box->glyphsBuiltForPage = -1;
 }
 
 void uiTextboxSetText(uitextbox_t *box, const char_t *text) {
@@ -43,6 +44,7 @@ void uiTextboxSetText(uitextbox_t *box, const char_t *text) {
   box->scroll = 0;
   box->layoutWidth = 0.0f;
   box->layoutHeight = 0.0f;
+  box->glyphsBuiltForPage = -1;
 }
 
 void uiTextboxBuildLayout(
@@ -52,6 +54,7 @@ void uiTextboxBuildLayout(
 ) {
   assertNotNull(box, "Textbox cannot be NULL");
 
+  box->glyphsBuiltForPage = -1;
   box->layoutWidth = width;
   box->layoutHeight = height;
   box->lineCount = 0;
@@ -138,9 +141,9 @@ void uiTextboxBuildLayout(
 errorret_t uiTextboxUpdate(uitextbox_t *box) {
   assertNotNull(box, "Textbox cannot be NULL");
 
-#ifdef DUSK_TIME_DYNAMIC
-  if(TIME.dynamicUpdate) errorOk();
-#endif
+  #ifdef DUSK_TIME_DYNAMIC
+    if(TIME.dynamicUpdate) errorOk();
+  #endif
 
   if(!uiTextboxPageIsComplete(box)) {
     box->scroll += UI_TEXTBOX_SCROLL_CHARS_PER_TICK;
@@ -169,13 +172,30 @@ errorret_t uiTextboxDraw(
     uiTextboxBuildLayout(box, contentW, contentH);
   }
 
-  errorChain(uiFrameDraw(x, y, width, height));
-  errorChain(spriteBatchFlush());
+  errorChain(uiFrameDrawCached(&box->frameCache, x, y, width, height));
 
   if(box->lineCount == 0 || box->text[0] == '\0') errorOk();
 
-  float_t fontW = (float_t)FONT_DEFAULT.tileset->tileWidth;
-  float_t fontH = (float_t)FONT_DEFAULT.tileset->tileHeight;
+  if(box->glyphsBuiltForPage != box->currentPage) {
+    uiTextboxBuildPageGlyphs(box);
+  }
+
+  if(box->glyphCount == 0) errorOk();
+
+  int32_t visibleCount = 0;
+  while(
+    visibleCount < box->glyphCount &&
+    box->glyphs[visibleCount].revealAt <= box->scroll
+  ) visibleCount++;
+
+  if(visibleCount == 0) errorOk();
+
+  spritebatchsprite_t scratch[UI_TEXTBOX_PAGE_GLYPHS_MAX];
+  for(int32_t i = 0; i < visibleCount; i++) {
+    scratch[i] = spriteBatchSpriteTranslate(
+      &box->glyphs[i].sprite, contentX, contentY
+    );
+  }
 
   shadermaterial_t material = {
     .unlit = {
@@ -183,35 +203,47 @@ errorret_t uiTextboxDraw(
       .texture = FONT_DEFAULT.texture
     }
   };
+  errorChain(spriteBatchBuffer(scratch, visibleCount, &SHADER_UNLIT, material));
+
+  errorOk();
+}
+
+void uiTextboxBuildPageGlyphs(uitextbox_t *box) {
+  assertNotNull(box, "Textbox cannot be NULL");
+
+  box->glyphCount = 0;
 
   int32_t pageFirst = box->currentPage * box->linesPerPage;
   int32_t pageLast = pageFirst + box->linesPerPage;
   if(pageLast > box->lineCount) pageLast = box->lineCount;
 
-  int32_t charsLeft = box->scroll;
+  float_t fontW = (float_t)FONT_DEFAULT.tileset->tileWidth;
+  float_t fontH = (float_t)FONT_DEFAULT.tileset->tileHeight;
 
-  for(int32_t li = pageFirst; li < pageLast && charsLeft > 0; li++) {
+  int32_t consumed = 0;
+  for(int32_t li = pageFirst; li < pageLast; li++) {
     uitextboxline_t *line = &box->lines[li];
-    int32_t visible = line->count < charsLeft ? line->count : charsLeft;
-    float_t lineY = contentY +
+    float_t lineY =
       (float_t)(li - pageFirst) * (fontH + UI_TEXTBOX_LINE_SPACING);
 
-    for(int32_t ci = 0; ci < visible; ci++) {
+    for(int32_t ci = 0; ci < line->count; ci++) {
+      consumed++;
       char_t c = box->text[line->start + ci];
       if(c == ' ') continue;
-      spritebatchsprite_t sprite = textGetSprite(
-        (vec2){ contentX + (float_t)ci * fontW, lineY },
-        c,
-        &FONT_DEFAULT
-      );
-      errorChain(spriteBatchBuffer(&sprite, 1, &SHADER_UNLIT, material));
-    }
 
-    charsLeft -= visible;
+      assertTrue(
+        box->glyphCount < UI_TEXTBOX_PAGE_GLYPHS_MAX,
+        "Textbox page produces too many glyphs"
+      );
+      uitextboxglyph_t *glyph = &box->glyphs[box->glyphCount++];
+      glyph->sprite = textGetSprite(
+        (vec2){ (float_t)ci * fontW, lineY }, c, &FONT_DEFAULT
+      );
+      glyph->revealAt = consumed;
+    }
   }
 
-  errorChain(spriteBatchFlush());
-  errorOk();
+  box->glyphsBuiltForPage = box->currentPage;
 }
 
 int32_t uiTextboxGetPageCharCount(const uitextbox_t *box) {

archive/duskrpg/ui/textbox/uitextbox.h

@@ -7,16 +7,34 @@
 
 #pragma once
 #include "error/error.h"
+#include "ui/frame/uiframe.h"
+#include "display/spritebatch/spritebatchsprite.h"
 
 #define UI_TEXTBOX_LINES_PER_PAGE_MAX 4
 #define UI_TEXTBOX_SCROLL_CHARS_PER_TICK 1
 #define UI_TEXTBOX_LINE_SPACING 0.0f
 
+// Fixed capacity for a page's cached glyph sprites (see uitextboxglyph_t).
+// Sized generously above UI_TEXTBOX_LINES_PER_PAGE_MAX worth of glyphs at
+// typical textbox widths; uiTextboxBuildPageGlyphs asserts if a page
+// somehow produces more than this.
+#define UI_TEXTBOX_PAGE_GLYPHS_MAX 512
+
 typedef struct {
   int32_t start;
   int32_t count;
 } uitextboxline_t;
 
+// A single visible glyph's cached sprite (relative to the textbox's
+// content origin, i.e. (0,0)) plus the scroll value at/after which it
+// becomes visible -- lets uiTextboxDraw turn the typewriter scroll into
+// a simple prefix-count instead of recomputing glyph geometry every
+// frame.
+typedef struct {
+  spritebatchsprite_t sprite;
+  int32_t revealAt;
+} uitextboxglyph_t;
+
 typedef struct {
   char_t *text;
   uint32_t maxLength;
@@ -34,6 +52,15 @@ typedef struct {
 
   int32_t currentPage;
   int32_t scroll;
+
+  // Cached glyph sprites for the current page (see uitextboxglyph_t),
+  // rebuilt only when currentPage no longer matches
+  // glyphsBuiltForPage -- not every frame/scroll tick.
+  uitextboxglyph_t glyphs[UI_TEXTBOX_PAGE_GLYPHS_MAX];
+  int32_t glyphCount;
+  int32_t glyphsBuiltForPage;
+
+  uiframecache_t frameCache;
 } uitextbox_t;
 
 /**
@@ -136,3 +163,13 @@ bool_t uiTextboxHasNextPage(const uitextbox_t *box);
  * @param box The textbox to advance.
  */
 void uiTextboxNextPage(uitextbox_t *box);
+
+/**
+ * Rebuilds the cached glyph sprites (see uitextboxglyph_t) for the
+ * current page from its line layout. Called automatically by
+ * uiTextboxDraw whenever currentPage no longer matches the page the
+ * cache was last built for.
+ *
+ * @param box The textbox to rebuild.
+ */
+void uiTextboxBuildPageGlyphs(uitextbox_t *box);

archive/duskrpg/ui/textbox/uitextboxmain.c

@@ -79,7 +79,6 @@ errorret_t uiTextboxMainDraw(void) {
     &FONT_DEFAULT
   );
   errorChain(spriteBatchBuffer(&caret, 1, &SHADER_UNLIT, material));
-  errorChain(spriteBatchFlush());
 
   errorOk();
 }

archive/duskrpg/ui/textbox/uitextboxmain.h

@@ -6,7 +6,7 @@
  */
 
 #pragma once
-#include "ui/rpg/textbox/uitextbox.h"
+#include "uitextbox.h"
 #include "ui/focus/uifocusitem.h"
 
 #define UI_TEXTBOX_MAIN_LINES 4

archive/duskrpg/ui/uitestlabel.c

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "uitestlabel.h"
+#include "ui/widget/uilabel.h"
+#include "display/text/text.h"
+#include "display/screen/screen.h"
+#include "engine/engine.h"
+
+uilabel_t UI_TEST_LABEL;
+
+errorret_t uiTestLabelInit() {
+  uiLabelInit(&UI_TEST_LABEL, &FONT_DEFAULT);
+  uiLabelSetText(&UI_TEST_LABEL, "duskrpg");
+  errorOk();
+}
+
+errorret_t uiTestLabelDraw() {
+  int32_t versionWidth, versionHeight;
+  textMeasure(ENGINE.version, &FONT_DEFAULT, &versionWidth, &versionHeight);
+
+  errorChain(uiLabelDraw(
+    &UI_TEST_LABEL,
+    (float_t)(SCREEN.scanX + SCREEN.scanWidth - UI_TEST_LABEL.width),
+    (float_t)(
+      SCREEN.scanY + SCREEN.scanHeight - versionHeight -
+      UI_TEST_LABEL.height
+    )
+  ));
+  errorOk();
+}

archive/duskrpg/ui/uitestlabel.h

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "error/error.h"
+
+/**
+ * Initializes the test label, a smoke test for the duskrpg-side UI
+ * element extension point (uielementgame.h).
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiTestLabelInit();
+
+/**
+ * Draws the test label above the engine's debug version number.
+ *
+ * @return Any error that occurs.
+ */
+errorret_t uiTestLabelDraw();

archive/test/ui/CMakeLists.txt

@@ -6,6 +6,6 @@
 include(dusktest)
 
 # Tests
-dusktest(test_cutscenesystem.c)
-dusktest(test_cutscenecontrol.c)
-dusktest(test_cutscenemaparea.c)
+dusktest(test_uiframe.c)
+dusktest(test_uislider.c)
+dusktest(test_uitab.c)

archive/test/ui/test_uiframe.c

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "ui/frame/uiframe.h"
+
+static void test_uiFrameBuildSprites_layout(void **state) {
+  UI_FRAME.tileset = (tileset_t){
+    .tileWidth = 1,
+    .tileHeight = 1,
+    .tileCount = 9,
+    .columns = 3,
+    .rows = 3,
+    .uv = { 0.25f, 0.25f }
+  };
+
+  const float_t x = 100.0f;
+  const float_t y = 50.0f;
+  const float_t width = 40.0f;
+  const float_t height = 30.0f;
+  const float_t tileW = (float_t)UI_FRAME_BORDER_WIDTH;
+  const float_t tileH = (float_t)UI_FRAME_BORDER_HEIGHT;
+
+  spritebatchsprite_t sprites[9];
+  uiFrameBuildSprites(sprites, x, y, width, height);
+
+  // Top-left corner sits exactly at the rect's origin.
+  assert_float_equal(sprites[0].min[0], x, 0.0001f);
+  assert_float_equal(sprites[0].min[1], y, 0.0001f);
+  assert_float_equal(sprites[0].max[0], x + tileW, 0.0001f);
+  assert_float_equal(sprites[0].max[1], y + tileH, 0.0001f);
+  assert_float_equal(sprites[0].uvMin[0], 0.0f, 0.0001f);
+  assert_float_equal(sprites[0].uvMin[1], 0.0f, 0.0001f);
+  assert_float_equal(sprites[0].uvMax[0], 0.25f, 0.0001f);
+  assert_float_equal(sprites[0].uvMax[1], 0.25f, 0.0001f);
+
+  // Top-middle edge stretches to fill the width minus both corners.
+  assert_float_equal(sprites[1].min[0], x + tileW, 0.0001f);
+  assert_float_equal(sprites[1].max[0], x + width - tileW, 0.0001f);
+  assert_float_equal(sprites[1].max[1], y + tileH, 0.0001f);
+
+  // Center tile fills the remaining interior on both axes.
+  assert_float_equal(sprites[4].min[0], x + tileW, 0.0001f);
+  assert_float_equal(sprites[4].min[1], y + tileH, 0.0001f);
+  assert_float_equal(sprites[4].max[0], x + width - tileW, 0.0001f);
+  assert_float_equal(sprites[4].max[1], y + height - tileH, 0.0001f);
+
+  // Bottom-right corner sits exactly at the rect's far corner, sampling
+  // tileset column 2, row 2.
+  assert_float_equal(sprites[8].min[0], x + width - tileW, 0.0001f);
+  assert_float_equal(sprites[8].min[1], y + height - tileH, 0.0001f);
+  assert_float_equal(sprites[8].max[0], x + width, 0.0001f);
+  assert_float_equal(sprites[8].max[1], y + height, 0.0001f);
+  assert_float_equal(sprites[8].uvMin[0], 0.5f, 0.0001f);
+  assert_float_equal(sprites[8].uvMin[1], 0.5f, 0.0001f);
+}
+
+int main(int argc, char **argv) {
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test(test_uiFrameBuildSprites_layout),
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

archive/test/ui/test_uislider.c

@@ -0,0 +1,114 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "ui/widget/uislider.h"
+#include "util/memory.h"
+
+// uiSliderInitFloat/InitInt require a real font (FONT_DEFAULT) to build
+// the label's glyph cache, which needs a live GL context this test binary
+// doesn't have -- see the label size caching contract for why this is
+// safe to bypass here (uiSliderRebuildGeometry only reads slider->label's
+// already-measured width/height, it never touches the font itself).
+static void sliderSetupFloat(
+  uislider_t *slider,
+  const float_t value,
+  const float_t min,
+  const float_t max,
+  const float_t step
+) {
+  memoryZero(slider, sizeof(uislider_t));
+  slider->label.width = 20;
+  slider->label.height = 10;
+  slider->type = UI_SLIDER_TYPE_FLOAT;
+  slider->min.f = min;
+  slider->max.f = max;
+  slider->step.f = step;
+  slider->value.f = value;
+}
+
+static void sliderSetupInt(
+  uislider_t *slider,
+  const int32_t value,
+  const int32_t min,
+  const int32_t max,
+  const int32_t step
+) {
+  memoryZero(slider, sizeof(uislider_t));
+  slider->label.width = 20;
+  slider->label.height = 10;
+  slider->type = UI_SLIDER_TYPE_INT;
+  slider->min.i = min;
+  slider->max.i = max;
+  slider->step.i = step;
+  slider->value.i = value;
+}
+
+static void test_uiSliderRebuildGeometry_trackPosition(void **state) {
+  uislider_t slider;
+  sliderSetupFloat(&slider, 0.0f, 0.0f, 1.0f, 0.1f);
+  uiSliderRebuildGeometry(&slider);
+
+  const float_t expectedX = (float_t)slider.label.width + UI_SLIDER_GAP;
+  const float_t expectedY =
+    ((float_t)slider.label.height - UI_SLIDER_TRACK_HEIGHT) * 0.5f;
+
+  assert_float_equal(slider.cachedTrack.min[0], expectedX, 0.0001f);
+  assert_float_equal(slider.cachedTrack.min[1], expectedY, 0.0001f);
+  assert_float_equal(
+    slider.cachedTrack.max[0], expectedX + UI_SLIDER_TRACK_WIDTH, 0.0001f
+  );
+}
+
+static void test_uiSliderRebuildGeometry_fillVisibility(void **state) {
+  uislider_t slider;
+
+  // At the minimum value, the ratio is 0 -- no fill should be visible.
+  sliderSetupFloat(&slider, 0.0f, 0.0f, 10.0f, 1.0f);
+  uiSliderRebuildGeometry(&slider);
+  assert_false(slider.cachedFillVisible);
+
+  // Halfway to max -- fill should cover half the track.
+  sliderSetupFloat(&slider, 5.0f, 0.0f, 10.0f, 1.0f);
+  uiSliderRebuildGeometry(&slider);
+  assert_true(slider.cachedFillVisible);
+  assert_float_equal(
+    slider.cachedFill.max[0] - slider.cachedFill.min[0],
+    UI_SLIDER_TRACK_WIDTH * 0.5f,
+    0.0001f
+  );
+}
+
+static void test_uiSliderRebuildGeometry_stepMarkers(void **state) {
+  uislider_t slider;
+
+  // 5 steps between 0 and 10 -- under the marker cap, so markers render.
+  sliderSetupInt(&slider, 0, 0, 10, 2);
+  uiSliderRebuildGeometry(&slider);
+  assert_int_equal(slider.cachedMarkerCount, 6);
+  assert_float_equal(
+    slider.cachedMarkers[0].min[0], slider.cachedTrack.min[0] -
+      UI_SLIDER_STEP_MARKER_WIDTH * 0.5f,
+    0.0001f
+  );
+
+  // 100 steps -- over the marker cap, so it falls back to a smooth fill
+  // with no markers.
+  sliderSetupInt(&slider, 0, 0, 100, 1);
+  uiSliderRebuildGeometry(&slider);
+  assert_int_equal(slider.cachedMarkerCount, 0);
+}
+
+int main(int argc, char **argv) {
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test(test_uiSliderRebuildGeometry_trackPosition),
+    cmocka_unit_test(test_uiSliderRebuildGeometry_fillVisibility),
+    cmocka_unit_test(test_uiSliderRebuildGeometry_stepMarkers),
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

archive/test/ui/test_uitab.c

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dusktest.h"
+#include "ui/widget/uitab.h"
+#include "util/memory.h"
+
+// uiTabInit requires a real font (FONT_DEFAULT) to build the label's
+// glyph cache, which needs a live GL context this test binary doesn't
+// have. uiTabRebuildBackground only reads the label's already-measured
+// width/height, so it's safe to set those directly and exercise it here.
+static void test_uiTabRebuildBackground_matchesLabelSize(void **state) {
+  uitab_t tab;
+  memoryZero(&tab, sizeof(uitab_t));
+  tab.label.width = 42;
+  tab.label.height = 12;
+
+  uiTabRebuildBackground(&tab);
+
+  assert_float_equal(tab.cachedBackground.min[0], 0.0f, 0.0001f);
+  assert_float_equal(tab.cachedBackground.min[1], 0.0f, 0.0001f);
+  assert_float_equal(tab.cachedBackground.max[0], 42.0f, 0.0001f);
+  assert_float_equal(tab.cachedBackground.max[1], 12.0f, 0.0001f);
+}
+
+int main(int argc, char **argv) {
+  const struct CMUnitTest tests[] = {
+    cmocka_unit_test(test_uiTabRebuildBackground_matchesLabelSize),
+  };
+
+  return cmocka_run_group_tests(tests, NULL, NULL);
+}

assets/locale/en_US.po

@@ -10,9 +10,6 @@ msgid "ui.title"
 msgstr ""
 "Welcome"
 
-msgid "save.linux.mkdirp_failed"
-msgstr "Failed to create save directory, check the disk is not full or write-protected."
-
 #: src/dusk/ui/frame/settings/uisettings.c
 msgid "ui.settings.tabs.general"
 msgstr "General"
@@ -59,130 +56,6 @@ msgstr "Items"
 msgid "ui.game_menu.settings"
 msgstr "Settings"
 
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save"
-msgstr "Save"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_success"
-msgstr "Game saved."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_cancelled"
-msgstr "Save cancelled."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_unavailable"
-msgstr "Can't save - no save device found."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_temporary"
-msgstr "This session is temporary - no save device was found, so saving is disabled."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_create_confirm"
-msgstr "No save data found. Create a new save?"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_failed_format"
-msgstr "Save failed: %s"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_check_failed_format"
-msgstr "Can't save: %s"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.message"
-msgstr "No save device found. You can continue, but\nprogress will not be saved."
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.retry"
-msgstr "Retry"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.continue"
-msgstr "Continue Anyway"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.message"
-msgstr "No save data found. Create a new save?"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.yes"
-msgstr "Yes"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.no"
-msgstr "No"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.new_game"
-msgstr "New Game"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.load_game"
-msgstr "Load Game"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.options"
-msgstr "Options"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.quit"
-msgstr "Quit Game"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.confirm"
-msgstr "Confirm"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.cancel"
-msgstr "Cancel"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.attack"
-msgstr "Attack"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.flee"
-msgstr "Flee"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.target_format"
-msgstr "Enemy %u (%u/%u HP)"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.hp_format"
-msgstr "HP %u/%u"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.mp_format"
-msgstr "MP %u/%u"
-
-#: src/dusk/ui/frame/settings/uisettingsaudio.c
-msgid "ui.settings.audio.placeholder"
-msgstr "No audio settings yet"
-
-#: src/dusk/ui/frame/settings/uisettingsdisplay.c
-msgid "ui.settings.display.placeholder"
-msgstr "No display settings yet"
-
-#: src/dusk/ui/frame/settings/uisettingsinput.c
-msgid "ui.settings.input.placeholder"
-msgstr "No input settings yet"
-
-#: src/dusk/ui/frame/backpack/uibackpack.c
-msgid "ui.backpack.category_format"
-msgstr "Category %u"
-
-#: src/dusk/ui/overlay/uiloading.c
-msgid "ui.loading.text"
-msgstr "loading"
-
-#: src/dusk/ui/overlay/uiautosave.c
-msgid "ui.autosave.saving"
-msgstr "SAVING"
-
 msgid "item.potion.name"
 msgstr "Potion"
 

assets/locale/es_MX.po

@@ -57,130 +57,6 @@ msgstr "Objetos"
 msgid "ui.game_menu.settings"
 msgstr "Configuración"
 
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save"
-msgstr "Guardar"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_success"
-msgstr "Partida guardada."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_cancelled"
-msgstr "Guardado cancelado."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_unavailable"
-msgstr "No se puede guardar: no se encontró ningún dispositivo de guardado."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_temporary"
-msgstr "Esta sesión es temporal - no se encontró ningún dispositivo de guardado, por lo que guardar está deshabilitado."
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_create_confirm"
-msgstr "No se encontraron datos guardados. ¿Crear una partida nueva?"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_failed_format"
-msgstr "Error al guardar: %s"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_check_failed_format"
-msgstr "No se puede guardar: %s"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.message"
-msgstr "No se encontró ningún dispositivo de guardado. Puedes continuar, pero\nel progreso no se guardará."
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.retry"
-msgstr "Reintentar"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.continue"
-msgstr "Continuar de todos modos"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.message"
-msgstr "No se encontraron datos guardados. ¿Crear una partida nueva?"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.yes"
-msgstr "Sí"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.no"
-msgstr "No"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.new_game"
-msgstr "Nueva Partida"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.load_game"
-msgstr "Cargar Partida"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.options"
-msgstr "Opciones"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.quit"
-msgstr "Salir del Juego"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.confirm"
-msgstr "Confirmar"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.cancel"
-msgstr "Cancelar"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.attack"
-msgstr "Atacar"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.flee"
-msgstr "Huir"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.target_format"
-msgstr "Enemigo %u (%u/%u PS)"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.hp_format"
-msgstr "PS %u/%u"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.mp_format"
-msgstr "PM %u/%u"
-
-#: src/dusk/ui/frame/settings/uisettingsaudio.c
-msgid "ui.settings.audio.placeholder"
-msgstr "Aún no hay opciones de audio"
-
-#: src/dusk/ui/frame/settings/uisettingsdisplay.c
-msgid "ui.settings.display.placeholder"
-msgstr "Aún no hay opciones de pantalla"
-
-#: src/dusk/ui/frame/settings/uisettingsinput.c
-msgid "ui.settings.input.placeholder"
-msgstr "Aún no hay opciones de entrada"
-
-#: src/dusk/ui/frame/backpack/uibackpack.c
-msgid "ui.backpack.category_format"
-msgstr "Categoría %u"
-
-#: src/dusk/ui/overlay/uiloading.c
-msgid "ui.loading.text"
-msgstr "cargando"
-
-#: src/dusk/ui/overlay/uiautosave.c
-msgid "ui.autosave.saving"
-msgstr "GUARDANDO"
-
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "Poción"

assets/locale/jp_JP.po

@@ -57,130 +57,6 @@ msgstr "アイテム"
 msgid "ui.game_menu.settings"
 msgstr "設定"
 
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save"
-msgstr "セーブ"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_success"
-msgstr "セーブしました。"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_cancelled"
-msgstr "セーブをキャンセルしました。"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_unavailable"
-msgstr "セーブできません - セーブデバイスが見つかりません。"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_temporary"
-msgstr "このセッションは一時的です - セーブデバイスが見つからなかったため、セーブは無効になっています。"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_create_confirm"
-msgstr "セーブデータが見つかりません。新しいセーブを作成しますか？"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_failed_format"
-msgstr "セーブに失敗しました: %s"
-
-#: src/dusk/ui/frame/game/uigamemenu.c
-msgid "ui.game_menu.save_check_failed_format"
-msgstr "セーブできません: %s"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.message"
-msgstr "セーブデバイスが見つかりません。続行できますが、\n進行状況は保存されません。"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.retry"
-msgstr "再試行"
-
-#: src/dusk/ui/frame/initial/uiinitialnocard.c
-msgid "ui.initial.no_card.continue"
-msgstr "続行する"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.message"
-msgstr "セーブデータが見つかりません。新しいセーブを作成しますか？"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.yes"
-msgstr "はい"
-
-#: src/dusk/ui/frame/initial/uiinitialcreatesave.c
-msgid "ui.initial.create_save.no"
-msgstr "いいえ"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.new_game"
-msgstr "ニューゲーム"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.load_game"
-msgstr "ロードゲーム"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.options"
-msgstr "オプション"
-
-#: src/dusk/ui/frame/mainmenu/uimainmenu.c
-msgid "ui.main_menu.quit"
-msgstr "ゲームを終了"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.confirm"
-msgstr "確認"
-
-#: src/dusk/ui/frame/uiconfirm.c
-msgid "ui.confirm.cancel"
-msgstr "キャンセル"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.attack"
-msgstr "攻撃"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.flee"
-msgstr "逃げる"
-
-#: src/dusk/ui/frame/battle/uibattlemenu.c
-msgid "ui.battle.menu.target_format"
-msgstr "敵%u (%u/%u HP)"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.hp_format"
-msgstr "HP %u/%u"
-
-#: src/dusk/ui/frame/battle/uibattlehud.c
-msgid "ui.battle.hud.mp_format"
-msgstr "MP %u/%u"
-
-#: src/dusk/ui/frame/settings/uisettingsaudio.c
-msgid "ui.settings.audio.placeholder"
-msgstr "オーディオ設定はまだありません"
-
-#: src/dusk/ui/frame/settings/uisettingsdisplay.c
-msgid "ui.settings.display.placeholder"
-msgstr "表示設定はまだありません"
-
-#: src/dusk/ui/frame/settings/uisettingsinput.c
-msgid "ui.settings.input.placeholder"
-msgstr "入力設定はまだありません"
-
-#: src/dusk/ui/frame/backpack/uibackpack.c
-msgid "ui.backpack.category_format"
-msgstr "カテゴリー%u"
-
-#: src/dusk/ui/overlay/uiloading.c
-msgid "ui.loading.text"
-msgstr "読み込み中"
-
-#: src/dusk/ui/overlay/uiautosave.c
-msgid "ui.autosave.saving"
-msgstr "保存中"
-
 #: src/dusk/rpg/item/item.json
 msgid "item.potion.name"
 msgstr "ポーション"