Fix memory tests

.github/workflows/build.yml

@@ -106,7 +106,7 @@ jobs:
       - name: Copy output files.
         run: |
           mkdir -p ./git-artifcats/Dusk/apps/Dusk
-          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/Dusk.dol
+          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
           cp build-wii/dusk.dsk ./git-artifcats/Dusk/apps/Dusk/dusk.dsk
           cp docker/dolphin/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
       - name: Upload Wii binary

archive/loader/CMakeLists.txt

@@ -10,6 +10,4 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
     assettileset.c
     assetlanguage.c
     assetscript.c
-    assetmap.c
-    assetmapchunk.c
 )

archive/loader/assettexture.c

@@ -0,0 +1,78 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assettexture.h"
+#include "asset/assettype.h"
+#include "assert/assert.h"
+#include "display/texture/texture.h"
+#include "util/endian.h"
+
+errorret_t assetTextureLoad(assetentire_t entire) {
+  assertNotNull(entire.data, "Data pointer cannot be NULL.");
+  assertNotNull(entire.output, "Output pointer cannot be NULL.");
+
+  assettexture_t *assetData = (assettexture_t *)entire.data;
+  texture_t *texture = (texture_t *)entire.output;
+
+  // Read header and version (first 4 bytes)
+  if(
+    assetData->header[0] != 'D' || 
+    assetData->header[1] != 'T' ||
+    assetData->header[2] != 'X'
+  ) {
+    errorThrow("Invalid texture header");
+  }
+  
+  // Version (can only be 1 atm)
+  if(assetData->version != 0x01) {
+    errorThrow("Unsupported texture version");
+  }
+
+  // Fix endian
+  assetData->width = endianLittleToHost32(assetData->width);
+  assetData->height = endianLittleToHost32(assetData->height);
+
+  // Check dimensions.
+  if(
+    assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
+    assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
+  ) {
+    errorThrow("Invalid texture dimensions");
+  }
+
+  // Validate format
+  textureformat_t format;
+  texturedata_t data;
+
+  switch(assetData->type) {
+    case 0x00: // RGBA8888
+      format = TEXTURE_FORMAT_RGBA;
+      data.rgbaColors = (color_t *)assetData->data;
+      break;
+
+    // case 0x01:
+    //   format = TEXTURE_FORMAT_RGB;
+    //   break;
+    
+    // case 0x02:
+    //   format = TEXTURE_FORMAT_RGB565;
+    //   break;
+
+    // case 0x03:
+    //   format = TEXTURE_FORMAT_RGB5A3;
+    //   break;
+
+    default:
+      errorThrow("Unsupported texture format");
+  }
+
+  errorChain(textureInit(
+    texture, assetData->width, assetData->height, format, data
+  ));
+
+  errorOk();
+}

archive/loader/assettexture.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "error/error.h"
+#include "display/color.h"
 
 #define ASSET_TEXTURE_WIDTH_MAX 2048
 #define ASSET_TEXTURE_HEIGHT_MAX 2048
@@ -20,9 +21,10 @@ typedef struct assetentire_s assetentire_t;
 typedef struct {
   char_t header[3];
   uint8_t version;
+  uint8_t type;
   uint32_t width;
   uint32_t height;
-  uint8_t palette[ASSET_TEXTURE_SIZE_MAX];
+  uint8_t data[ASSET_TEXTURE_SIZE_MAX * sizeof(color4b_t)];
 } assettexture_t;
 #pragma pack(pop)
 

assets/init.lua

@@ -70,8 +70,9 @@ elseif LINUX then
     inputBind("mouse_x", INPUT_ACTION_POINTERX)
     inputBind("mouse_y", INPUT_ACTION_POINTERY)
   end
+
 else
   print("Unknown platform, no default input bindings set.")
 end
 
-sceneSet('scene/minesweeper.lua')
+sceneSet('scene/main_menu/main_menu.lua')

assets/locale/en_US.po

@@ -1,9 +1,60 @@
-#
 msgid ""
 msgstr ""
-"Language: en_US\n"
+"Project-Id-Version: ExampleApp 1.0\n"
+"Language: en\n"
 "Content-Type: text/plain; charset=UTF-8\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\n"
+"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : n==2 ? 1 : (n<7 ? 2 : 3));\n"
 
-msgid "ui.test"
-msgstr "Hello this is a test."
+#: ui/menu.c:10
+msgid "ui.title"
+msgstr ""
+"Welcome"
+
+#: ui/user.c:22
+msgid "ui.greeting"
+msgstr "Hello, %s!"
+
+#: ui/files.c:40
+msgid "ui.file_status"
+msgstr "%s has %d files."
+
+#: ui/cart.c:55
+msgid "cart.item_count"
+msgid_plural "cart.item_count"
+msgstr[0] "%d item"
+msgstr[1] "%d items (dual)"
+msgstr[2] "%d items (few)"
+msgstr[3] "%d items (many)"
+
+#: ui/notifications.c:71
+msgid ""
+"ui.multiline_help"
+msgstr ""
+"Line one of the help text.\n"
+"Line two continues here.\n"
+"Line three ends here."
+
+#: ui/errors.c:90
+msgid ""
+"error.upload_failed.long"
+msgstr ""
+"Upload failed for file \"%s\".\n"
+"Please try again later or contact support."
+
+#: ui/messages.c:110
+msgid ""
+"user.invite_status"
+msgid_plural ""
+"user.invite_status"
+msgstr[0] ""
+"%s invited %d user.\n"
+"Please review the request."
+msgstr[1] ""
+"%s invited %d users (dual).\n"
+"Please review the requests."
+msgstr[2] ""
+"%s invited %d users (few).\n"
+"Please review the requests."
+msgstr[3] ""
+"%s invited %d users (many).\n"
+"Please review the requests."

assets/scene/main_menu/main_menu.lua

@@ -0,0 +1,46 @@
+module('spritebatch')
+module('camera')
+module('color')
+module('ui')
+module('screen')
+module('time')
+module('text')
+module('tileset')
+module('texture')
+module('input')
+module('shader')
+module('locale')
+
+screenSetBackground(colorCornflowerBlue())
+camera = cameraCreate(CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC)
+
+text = localeGetText('cart.item_count', 52, 2)
+
+function sceneDispose()
+end
+
+function sceneUpdate()
+end
+
+function sceneRender()
+  -- Update camera
+  camera.top = screenGetHeight()
+  camera.right = screenGetWidth()
+
+  shaderBind(SHADER_UNLIT)
+  proj = cameraGetProjectionMatrix(camera)
+  shaderSetMatrix(SHADER_UNLIT, SHADER_UNLIT_PROJECTION, proj)
+  view = cameraGetViewMatrix(camera)
+  shaderSetMatrix(SHADER_UNLIT, SHADER_UNLIT_VIEW, view)
+
+  -- shaderSetTexture(SHADER_UNLIT, SHADER_UNLIT_TEXTURE, nil)
+  -- spriteBatchPush(
+  --   32, 32,
+  --   64, 64,
+  --   colorWhite()
+  -- )
+  -- spriteBatchFlush()
+
+  textDraw(10, 10, text, colorWhite())
+  spriteBatchFlush()
+end

assets/scene/minesweeper.lua

@@ -1,256 +0,0 @@
-module('spritebatch')
-module('camera')
-module('color')
-module('ui')
-module('screen')
-module('time')
-module('glm')
-module('text')
-module('tileset')
-module('texture')
-module('input')
-
-CELL_STATE_DEFAULT = 0
-CELL_STATE_HOVER = 1
-CELL_STATE_DOWN = 2
-CELL_STATE_DISABLED = 3
-
-screenSetBackground(colorCornflowerBlue())
-camera = cameraCreate(CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC)
-
--- tilesetUi = tilesetGetByName("ui")
--- textureUi = textureLoad(tilesetUi.texture)
-
--- tilesetBorder = tilesetGetByName("border")
--- textureBorder = textureLoad(tilesetBorder.texture)
-
--- textureGrid = textureLoad("minesweeper/grid_bg.dpi")
-
--- tilesetCell = tilesetGetByName("cell")
--- textureCell = textureLoad(tilesetCell.texture)
--- cellSliceDefault = tilesetPositionGetUV(tilesetCell, 3, 5)
--- cellSliceHover = tilesetPositionGetUV(tilesetCell, 3, 4)
--- cellSliceDown = tilesetPositionGetUV(tilesetCell, 3, 6)
--- cellSliceDisabled = tilesetPositionGetUV(tilesetCell, 3, 7)
-
--- sweepwerCols = 10
--- sweeperRows = 14
-
--- mouseX = -1
--- mouseY = -1
--- centerX = 0
--- centerY = 0
--- boardWidth = sweepwerCols * tilesetCell.tileWidth
--- boardHeight = sweeperRows * tilesetCell.tileHeight
-
--- i = 0
--- cells = {}
--- for y = 1, sweeperRows do
---   for x = 1, sweepwerCols do
---     cells[i] = CELL_STATE_DEFAULT
---     i = i + 1
---   end
--- end
-
-function cellDraw(x, y, type)
-  local slice = cellSliceDefault
-  if type == CELL_STATE_HOVER then
-    slice = cellSliceHover
-  elseif type == CELL_STATE_DOWN then
-    slice = cellSliceDown
-  elseif type == CELL_STATE_DISABLED then
-    slice = cellSliceDisabled
-  end
-
-  spriteBatchPush(textureCell,
-    x, y,
-    x + tilesetCell.tileWidth, y + tilesetCell.tileHeight,
-    colorWhite(),
-    slice.u0, slice.v0,
-    slice.u1, slice.v1
-  )
-end
-
-function backgroundDraw()
-  local t = (TIME.time / 40) % 1
-  local scaleX = screenGetWidth() / textureGrid.width
-  local scaleY = screenGetHeight() / textureGrid.height
-  local u0 = t * scaleX
-  local v0 = t * scaleY
-  local u1 = scaleX + u0
-  local v1 = scaleY + v0
-
-  spriteBatchPush(textureGrid,
-    0, 0,
-    screenGetWidth(), screenGetHeight(),
-    colorWhite(),
-    u0, v0,
-    u1, v1
-  )
-end
-
-function borderDraw(x, y, innerWidth, innerHeight)
-  -- Top Left
-  local uv = tilesetPositionGetUV(tilesetBorder, 0, 0)
-  spriteBatchPush(textureBorder,
-    x - tilesetBorder.tileWidth, y  - tilesetBorder.tileWidth,
-    x, y,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Top Right
-  uv = tilesetPositionGetUV(tilesetBorder, 10, 0)
-  spriteBatchPush(textureBorder,
-    x + innerWidth, y - tilesetBorder.tileHeight,
-    x + innerWidth + tilesetBorder.tileWidth, y,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Bottom Left
-  uv = tilesetPositionGetUV(tilesetBorder, 0, 10)
-  spriteBatchPush(textureBorder,
-    x - tilesetBorder.tileWidth, y + innerHeight,
-    x, y + innerHeight + tilesetBorder.tileHeight,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Bottom Right
-  uv = tilesetPositionGetUV(tilesetBorder, 10, 10)
-  spriteBatchPush(textureBorder,
-    x + innerWidth, y + innerHeight,
-    x + innerWidth + tilesetBorder.tileWidth, y + innerHeight + tilesetBorder.tileHeight,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Top
-  uv = tilesetPositionGetUV(tilesetBorder, 1, 0)
-  spriteBatchPush(textureBorder,
-    x, y - tilesetBorder.tileHeight,
-    x + innerWidth, y,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Bottom
-  uv = tilesetPositionGetUV(tilesetBorder, 1, 10)
-  spriteBatchPush(textureBorder,
-    x, y + innerHeight,
-    x + innerWidth, y + innerHeight + tilesetBorder.tileHeight,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Left
-  uv = tilesetPositionGetUV(tilesetBorder, 0, 1)
-  spriteBatchPush(textureBorder,
-    x - tilesetBorder.tileWidth, y,
-    x, y + innerHeight,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-
-  -- Right
-  uv = tilesetPositionGetUV(tilesetBorder, 10, 1)
-  spriteBatchPush(textureBorder,
-    x + innerWidth, y,
-    x + innerWidth + tilesetBorder.tileWidth, y + innerHeight,
-    colorWhite(),
-    uv.u0, uv.v0,
-    uv.u1, uv.v1
-  )
-end
-
-x = 0
-y = 0
-
-function sceneDispose()
-end
-
-function sceneUpdate()
-  x = x + inputAxis(INPUT_ACTION_LEFT, INPUT_ACTION_RIGHT)
-  y = y + inputAxis(INPUT_ACTION_UP, INPUT_ACTION_DOWN)
-end
-
-
-function sceneRender()
-  -- Update camera
-  cameraPushMatrix(camera)
-  camera.bottom = screenGetHeight()
-  camera.right = screenGetWidth()
-
-  spriteBatchPush(
-    nil,
-    x, y, x + 32, y + 32,
-    colorWhite()
-  )
-
-  -- Update mouse position
-  -- if INPUT_POINTER then
-  --   mouseX = inputGetValue(INPUT_ACTION_POINTERX) * screenGetWidth()
-  --   mouseY = inputGetValue(INPUT_ACTION_POINTERY) * screenGetHeight()
-
-  --   -- Draw cursor
-  --   spriteBatchPush(
-  --     nil,
-  --     mouseX - 2, mouseY - 2,
-  --     mouseX + 2, mouseY + 2,
-  --     colorRed(),
-  --     0, 0,
-  --     1, 1
-  --   )
-  -- end
-
-
-  -- textDraw(10, 10, "Hello World")
-  
-  -- centerX = math.floor(screenGetWidth() / 2)
-  -- centerY = math.floor(screenGetHeight() / 2)
-
-  -- Draw elements
-  -- backgroundDraw()
-  -- borderDraw(
-  --   centerX - (boardWidth / 2), centerY - (boardHeight / 2),
-  --   boardWidth, boardHeight
-  -- )
-
-  -- i = 0
-  -- -- Foreach cell
-  -- local offX = centerX - (boardWidth / 2)
-  -- local offY = centerY - (boardHeight / 2)
-  -- for y = 0, sweeperRows - 1 do
-  --   for x = 0, sweepwerCols - 1 do
-  --     i = y * sweepwerCols + x
-      
-  --     -- Hovered
-  --     if
-  --       cells[i] == CELL_STATE_DEFAULT and
-  --       mouseX >= x * tilesetCell.tileWidth + offX and mouseX < (x + 1) * tilesetCell.tileWidth + offX and
-  --       mouseY >= y * tilesetCell.tileHeight + offY and mouseY < (y + 1) * tilesetCell.tileHeight + offY
-  --     then
-  --       cells[i] = CELL_STATE_HOVER
-  --     else
-  --       cells[i] = CELL_STATE_DEFAULT
-  --     end
-      
-  --     cellDraw(
-  --       x * tilesetCell.tileWidth + offX,
-  --       y * tilesetCell.tileHeight + offY,
-  --       cells[i]
-  --     )
-  --   end
-  -- end
-  spriteBatchFlush()
-
-  cameraPopMatrix()
-end

assets/test.json

@@ -0,0 +1,19 @@
+{
+  "name": "Dominic",
+  "age": 31,
+  "likes": [
+    "thing1",
+    "thing2"
+  ],
+  "options": {
+    "someParam": true,
+    "someSubObject": {
+      "someSubSubParam": 52
+    },
+    "someArray": [
+      1,
+      2,
+      3
+    ]
+  }
+}

cmake/modules/CompileLibZip.cmake

@@ -1,17 +0,0 @@
-include(FetchContent)
-
-set(ENABLE_ZSTD OFF CACHE BOOL "" FORCE)
-set(BUILD_TOOLS OFF CACHE BOOL "" FORCE)
-set(BUILD_REGRESS OFF CACHE BOOL "" FORCE)
-set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-set(BUILD_DOC OFF CACHE BOOL "" FORCE)
-set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-set(LIBZIP_DO_INSTALL OFF CACHE BOOL "" FORCE)
-
-FetchContent_Declare(
-  libzip
-  GIT_REPOSITORY https://github.com/nih-at/libzip.git
-  GIT_TAG v1.11.4
-)
-
-FetchContent_MakeAvailable(libzip)

cmake/modules/CompileLua.cmake

@@ -1,20 +0,0 @@
-# Compile lua
-include(FetchContent)
-FetchContent_Declare(
-  liblua
-  URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
-)
-FetchContent_MakeAvailable(liblua)
-set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
-set(LUA_C_FILES 
-  lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
-  ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
-  loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
-  lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
-)
-list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
-add_library(liblua STATIC ${LUA_C_FILES})
-target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
-target_compile_definitions(liblua PRIVATE LUA_USE_C89)
-add_library(lua::lua ALIAS liblua)
-set(Lua_FOUND TRUE CACHE BOOL "Lua found" FORCE)

cmake/modules/Findlibzip.cmake

@@ -1,43 +1,17 @@
-
-# Allow user to manually specify libzip paths
-# LIBZIP_ROOT: root directory for libzip (optional)
-# LIBZIP_INCLUDE_DIR: path to zip.h (optional)
-# LIBZIP_LIBRARY: path to libzip library (optional)
-
 find_package(ZLIB REQUIRED)
 
-if(NOT LIBZIP_INCLUDE_DIR AND LIBZIP_ROOT)
-    find_path(LIBZIP_INCLUDE_DIR NAMES zip.h HINTS "${LIBZIP_ROOT}/include")
-endif()
-if(NOT LIBZIP_INCLUDE_DIR)
-    find_path(LIBZIP_INCLUDE_DIR NAMES zip.h)
-endif()
+find_path(LIBZIP_INCLUDE_DIR NAMES zip.h)
 mark_as_advanced(LIBZIP_INCLUDE_DIR)
 
-if(NOT LIBZIP_LIBRARY AND LIBZIP_ROOT)
-    find_library(LIBZIP_LIBRARY NAMES zip HINTS "${LIBZIP_ROOT}/lib")
-endif()
-if(NOT LIBZIP_LIBRARY)
-    find_library(LIBZIP_LIBRARY NAMES zip)
-endif()
+find_library(LIBZIP_LIBRARY NAMES zip)
 mark_as_advanced(LIBZIP_LIBRARY)
 
-if(LIBZIP_LIBRARY)
-    get_filename_component(_libzip_libdir ${LIBZIP_LIBRARY} DIRECTORY)
-endif()
-if(NOT _libzip_pkgcfg AND LIBZIP_ROOT)
-    find_file(_libzip_pkgcfg libzip.pc
-        HINTS "${LIBZIP_ROOT}/lib/pkgconfig" "${LIBZIP_ROOT}/libdata/pkgconfig"
-        NO_DEFAULT_PATH
-    )
-endif()
-if(NOT _libzip_pkgcfg AND LIBZIP_LIBRARY)
-    find_file(_libzip_pkgcfg libzip.pc
-        HINTS ${_libzip_libdir} ${LIBZIP_INCLUDE_DIR}/..
-        PATH_SUFFIXES pkgconfig lib/pkgconfig libdata/pkgconfig
-        NO_DEFAULT_PATH
-    )
-endif()
+get_filename_component(_libzip_libdir ${LIBZIP_LIBRARY} DIRECTORY)
+find_file(_libzip_pkgcfg libzip.pc
+    HINTS ${_libzip_libdir} ${LIBZIP_INCLUDE_DIR}/..
+    PATH_SUFFIXES pkgconfig lib/pkgconfig libdata/pkgconfig
+    NO_DEFAULT_PATH
+)
 
 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(

cmake/modules/Findstb.cmake

@@ -0,0 +1,31 @@
+# Copyright (c) 2026 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(FetchContent)
+FetchContent_Declare(
+  stb
+  GIT_REPOSITORY https://github.com/nothings/stb.git
+)
+
+# Fetch stb if not already done
+FetchContent_MakeAvailable(stb)
+
+# Find the stb_image.h header
+set(STB_INCLUDE_DIR "${stb_SOURCE_DIR}")
+set(STB_IMAGE_HEADER "${stb_SOURCE_DIR}/stb_image.h")
+
+if(EXISTS "${STB_IMAGE_HEADER}")
+  add_library(stb_image INTERFACE)
+  target_include_directories(stb_image INTERFACE "${STB_INCLUDE_DIR}")
+  set(STB_IMAGE_FOUND TRUE)
+else()
+  set(STB_IMAGE_FOUND FALSE)
+endif()
+
+# Standard CMake variables
+set(STB_IMAGE_INCLUDE_DIRS "${STB_INCLUDE_DIR}")
+set(STB_IMAGE_LIBRARIES stb_image)
+
+mark_as_advanced(STB_IMAGE_INCLUDE_DIRS STB_IMAGE_LIBRARIES STB_IMAGE_FOUND)

cmake/modules/Findyyjson.cmake

@@ -0,0 +1,18 @@
+include(FetchContent)
+
+if(NOT TARGET yyjson)
+	FetchContent_Declare(
+		yyjson
+		GIT_REPOSITORY https://github.com/ibireme/yyjson.git
+		GIT_TAG        0.12.0
+	)
+	FetchContent_MakeAvailable(yyjson)
+endif()
+
+# Provide an imported target if not already available
+if(NOT TARGET yyjson::yyjson)
+	add_library(yyjson::yyjson ALIAS yyjson)
+endif()
+
+# Mark yyjson as found for find_package compatibility
+set(yyjson_FOUND TRUE)

cmake/targets/dolphin.cmake

@@ -21,7 +21,26 @@ set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
 set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
 find_package(cglm REQUIRED)
 
-include(cmake/modules/CompileLua.cmake)
+# Compile lua
+include(FetchContent)
+FetchContent_Declare(
+  liblua
+  URL https://www.lua.org/ftp/lua-5.5.0.tar.gz
+)
+FetchContent_MakeAvailable(liblua)
+set(LUA_SRC_DIR "${liblua_SOURCE_DIR}/src")
+set(LUA_C_FILES 
+  lapi.c lauxlib.c lbaselib.c lcode.c lcorolib.c lctype.c ldblib.c ldebug.c
+  ldo.c ldump.c lfunc.c lgc.c linit.c liolib.c llex.c lmathlib.c lmem.c
+  loadlib.c lobject.c lopcodes.c loslib.c lparser.c lstate.c lstring.c
+  lstrlib.c ltable.c ltablib.c ltm.c lundump.c lutf8lib.c lvm.c lzio.c
+)
+list(TRANSFORM LUA_C_FILES PREPEND "${LUA_SRC_DIR}/")
+add_library(liblua STATIC ${LUA_C_FILES})
+target_include_directories(liblua PUBLIC "${LUA_SRC_DIR}")
+target_compile_definitions(liblua PRIVATE LUA_USE_C89)
+add_library(lua::lua ALIAS liblua)
+set(Lua_FOUND TRUE CACHE BOOL "Lua found" FORCE)
 
 # Link libraries
 target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE

cmake/targets/vita.cmake

@@ -1,62 +0,0 @@
-include("${VITASDK}/share/vita.cmake" REQUIRED)
-
-
-# Manually define libzip for Vita
-set(LIBZIP_LIBRARY "${VITASDK}/lib/libzip.a" CACHE FILEPATH "libzip library for Vita")
-set(LIBZIP_INCLUDE_DIR "${VITASDK}/include" CACHE PATH "libzip include dir for Vita")
-
-set(VITA_APP_NAME "Red Rectangle")
-set(VITA_TITLEID  "VSDK00017")
-set(VITA_VERSION  "01.00")
-
-
-
-target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-  mathneon
-  vitashark
-  kubridge_stub
-  SceAppMgr_stub
-  SceAudio_stub
-  SceCtrl_stub
-  SceCommonDialog_stub
-  SceDisplay_stub
-  SceKernelDmacMgr_stub
-  SceGxm_stub
-  SceShaccCg_stub
-  SceSysmodule_stub
-  ScePower_stub
-  SceTouch_stub
-  SceVshBridge_stub
-  SceIofilemgr_stub
-  SceShaccCgExt
-  SDL2-static
-  libtaihen_stub.a
-  lua::lua
-  zip
-  pthread
-  m
-)
-
-target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
-  ${SDL2_INCLUDE_DIRS}
-)
-
-target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
-  DUSK_SDL2
-  DUSK_OPENGL
-  DUSK_VITA
-  DUSK_INPUT_GAMEPAD
-  DUSK_PLATFORM_ENDIAN_LITTLE
-  DUSK_DISPLAY_WIDTH=960
-  DUSK_DISPLAY_HEIGHT=544
-)
-
-vita_create_self(${DUSK_BINARY_TARGET_NAME}.self ${DUSK_BINARY_TARGET_NAME})
-vita_create_vpk(${DUSK_BINARY_TARGET_NAME}.vpk ${VITA_TITLEID} ${DUSK_BINARY_TARGET_NAME}.self
-  VERSION ${VITA_VERSION}
-  NAME ${VITA_APP_NAME}
-  # FILE sce_sys/icon0.png sce_sys/icon0.png
-  # FILE sce_sys/livearea/contents/bg.png sce_sys/livearea/contents/bg.png
-  # FILE sce_sys/livearea/contents/startup.png sce_sys/livearea/contents/startup.png
-  # FILE sce_sys/livearea/contents/template.xml sce_sys/livearea/contents/template.xml
-)

docker/vita/Dockerfile

@@ -1,64 +0,0 @@
-FROM ubuntu:22.04
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && apt-get install -y \
-    cmake \
-    git \
-    curl \
-    sudo \
-    wget \
-    libarchive-tools \
-    python3 \
-    python3-pip \
-    python3-dotenv \
-    python3-polib \
-    python3-pil \
-    python3-pyqt5 \
-    python3-opengl \
- && rm -rf /var/lib/apt/lists/*
-
-RUN git clone https://github.com/vitasdk/vdpm /vdpm
-WORKDIR /vdpm
-RUN ./bootstrap-vitasdk.sh
-
-ENV VITASDK=/usr/local/vitasdk
-ENV PATH="${VITASDK}/bin:${PATH}"
-
-RUN git clone https://github.com/vitasdk/packages.git /vitapackages
-WORKDIR /vitapackages
-
-RUN bash -lc '\
-    dir_array=( \
-      zlib \
-      bzip2 \
-      henkaku \
-      taihen \
-      kubridge \
-      openal-soft \
-      openssl \
-      curl \
-      curlpp \
-      expat \
-      opus \
-      opusfile \
-      glm \
-      kuio \
-      vitaShaRK \
-      libmathneon \
-      vitaGL \
-      SceShaccCgExt \
-      sdl2 \
-      libzip \
-      luajit \
-    ); \
-    curdir=$(pwd); \
-    for d in "${dir_array[@]}"; do \
-      echo "${curdir}/${d}"; \
-      cd "${curdir}/${d}"; \
-      vita-makepkg; \
-      vdpm *-arm.tar.xz; \
-    done \
-'
-
-WORKDIR /workdir

scripts/build-knulli.sh

@@ -1,5 +1,6 @@
 #!/bin/bash
 cmake -S . -B build-knulli -G Ninja \
+  -DDUSK_BUILD_TESTS=ON \
   -DDUSK_TARGET_SYSTEM=knulli \
   -DCMAKE_TOOLCHAIN_FILE=./cmake/toolchains/aarch64-linux-gnu.cmake \
   -DCMAKE_BUILD_TYPE=Release

scripts/build-vita-docker.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-docker build -t dusk-vita -f docker/vita/Dockerfile .
-docker run --rm -v $(pwd):/workdir dusk-vita /bin/bash -c "./scripts/build-vita.sh"

scripts/build-vita.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-cd /workdir
-cmake -S . -B build-vita \
-  -DDUSK_TARGET_SYSTEM=vita \
-  -DCMAKE_TOOLCHAIN_FILE="$VITASDK/share/vita.toolchain.cmake"
-cmake --build build-vita -- -j$(nproc)

src/CMakeLists.txt

@@ -4,8 +4,10 @@
 # https://opensource.org/licenses/MIT
 
 add_subdirectory(dusk)
+# add_subdirectory(duskrpg)
+add_subdirectory(dusktrivia)
 
-if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "knulli" OR DUSK_TARGET_SYSTEM STREQUAL "vita")
+if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "knulli")
   add_subdirectory(dusklinux)
   add_subdirectory(dusksdl2)
   add_subdirectory(duskgl)

src/dusk/CMakeLists.txt

@@ -14,6 +14,24 @@ if(NOT libzip_FOUND)
   target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC zip)
 endif()
 
+if(NOT stb_image_FOUND)
+  find_package(stb REQUIRED)
+  if(STB_IMAGE_FOUND)
+    target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC stb_image)
+  else()
+    message(FATAL_ERROR "stb_image not found. Please ensure stb is correctly fetched.")
+  endif()
+endif()
+
+if(NOT yyjson_FOUND)
+  find_package(yyjson REQUIRED)
+  if(yyjson_FOUND)
+    target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC yyjson::yyjson)
+  else()
+    message(FATAL_ERROR "yyjson not found. Please ensure yyjson is correctly fetched.")
+  endif()
+endif()
+
 if(NOT Lua_FOUND)
   find_package(Lua REQUIRED)
   if(Lua_FOUND AND NOT TARGET Lua::Lua)
@@ -52,12 +70,9 @@ add_subdirectory(engine)
 add_subdirectory(error)
 add_subdirectory(event)
 add_subdirectory(input)
-add_subdirectory(item)
 add_subdirectory(locale)
-add_subdirectory(map)
 add_subdirectory(scene)
 add_subdirectory(script)
-add_subdirectory(story)
 add_subdirectory(time)
 add_subdirectory(ui)
 add_subdirectory(util)

src/dusk/asset/CMakeLists.txt

@@ -7,7 +7,8 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     asset.c
+    assetfile.c
 )
 
 # Subdirs
-add_subdirectory(type)
+add_subdirectory(loader)

src/dusk/asset/asset.c

@@ -9,7 +9,6 @@
 #include "util/memory.h"
 #include "util/string.h"
 #include "assert/assert.h"
-#include "asset/assettype.h"
 #include "engine/engine.h"
 #include "util/string.h"
 
@@ -33,107 +32,20 @@ bool_t assetFileExists(const char_t *filename) {
   return true;
 }
 
-errorret_t assetLoad(const char_t *filename, void *output) {
+errorret_t assetLoad(
+  const char_t *filename,
+  assetfileloader_t loader,
+  void *params,
+  void *output
+) {
   assertStrLenMax(filename, FILENAME_MAX, "Filename too long.");
   assertNotNull(output, "Output pointer cannot be NULL.");
+  assertNotNull(loader, "Asset file loader cannot be NULL.");
 
-  // Determine the asset type by reading the extension
-  const assettypedef_t *def = NULL;
-  for(uint_fast8_t i = 0; i < ASSET_TYPE_COUNT; i++) {
-    const assettypedef_t *cmp = &ASSET_TYPE_DEFINITIONS[i];
-    assertNotNull(cmp, "Asset type definition cannot be NULL.");
-    if(cmp->extension == NULL) continue;
-    if(!stringEndsWithCaseInsensitive(filename, cmp->extension)) continue;
-    def = cmp;
-    break;
-  }
-  if(def == NULL) {
-    errorThrow("Unknown asset type for file: %s", filename);
-  }
-
-  // Get file size of the asset.
-  zip_stat_t st;
-  zip_stat_init(&st);
-  if(!zip_stat(ASSET.zip, filename, 0, &st) == 0) {
-    errorThrow("Failed to stat asset file: %s", filename);
-  }
-
-  // Minimum file size.
-  zip_int64_t fileSize = (zip_int64_t)st.size;
-  if(fileSize <= 0) {
-    errorThrow("Asset file is empty: %s", filename);
-  }
-
-  // Try to open the file
-  zip_file_t *file = zip_fopen(ASSET.zip, filename, 0);
-  if(file == NULL) {
-    errorThrow("Failed to open asset file: %s", filename);
-  }
-
-  // Load the asset data
-  switch(def->loadStrategy) {
-    case ASSET_LOAD_STRAT_ENTIRE:
-      assertNotNull(def->entire, "Asset load function cannot be NULL.");
-
-      // Must have more to read
-      if(fileSize <= 0) {
-        zip_fclose(file);
-        errorThrow("No data remaining to read for asset: %s", filename);
-      }
-
-      if(fileSize > def->dataSize) {
-        zip_fclose(file);
-        errorThrow(
-          "Asset file has too much data remaining after header: %s",
-          filename
-        );
-      }
-
-      // Create space to read the entire asset data
-      void *data = memoryAllocate(fileSize);
-      if(!data) {
-        zip_fclose(file);
-        errorThrow(
-          "Failed to allocate memory for asset data of file: %s", filename
-        );
-      }
-
-      // Read in the asset data.
-      zip_int64_t bytesRead = zip_fread(file, data, fileSize);
-      if(bytesRead == 0 || bytesRead > fileSize) {
-        memoryFree(data);
-        zip_fclose(file);
-        errorThrow("Failed to read asset data for file: %s", filename);
-      }
-      fileSize -= bytesRead;
-      
-      // Close the file now we have the data
-      zip_fclose(file);
-
-      // Pass to the asset type loader
-      assetentire_t entire = {
-        .data = data,
-        .output = output
-      };
-      errorret_t ret = def->entire(entire);
-      memoryFree(data);
-
-      errorChain(ret);
-      break;
-
-    case ASSET_LOAD_STRAT_CUSTOM:
-      assertNotNull(def->custom, "Asset load function cannot be NULL.");
-      assetcustom_t customData = {
-        .zipFile = file,
-        .output = output
-      };
-      errorChain(def->custom(customData));
-      break;
-
-    default:
-      assertUnreachable("Unknown asset load strategy.");
-  }
-
+  assetfile_t file;
+  errorChain(assetFileInit(&file, filename, params, output));
+  errorChain(loader(&file));
+  errorChain(assetFileDispose(&file));
   errorOk();
 }
 

src/dusk/asset/asset.h

@@ -7,8 +7,8 @@
 
 #pragma once
 #include "error/error.h"
-#include "assettype.h"
 #include "asset/assetplatform.h"
+#include "assetfile.h"
 
 #ifndef assetInitPlatform
   #error "Platform must define assetInitPlatform function."
@@ -20,7 +20,7 @@
 #define ASSET_FILE_NAME "dusk.dsk"
 #define ASSET_HEADER_SIZE 3
 
-typedef struct {
+typedef struct asset_s {
   zip_t *zip;
   assetplatform_t platform;
 } asset_t;
@@ -41,13 +41,20 @@ errorret_t assetInit(void);
 bool_t assetFileExists(const char_t *filename);
 
 /**
- * Loads an asset by its filename, the output type depends on the asset type.
+ * Loads an asset by its filename,
  * 
  * @param filename The filename of the asset to retrieve.
+ * @param loader Loader to use for loading the asset file.
+ * @param params Parameters to pass to the loader.
  * @param output The output pointer to store the loaded asset data.
  * @return An error code if the asset could not be loaded.
  */
-errorret_t assetLoad(const char_t *filename, void *output);
+errorret_t assetLoad(
+  const char_t *filename,
+  assetfileloader_t loader,
+  void *params,
+  void *output
+);
 
 /**
  * Disposes/cleans up the asset system.

src/dusk/asset/assetfile.c

@@ -0,0 +1,309 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+
+errorret_t assetFileInit(
+  assetfile_t *file,
+  const char_t *filename,
+  void *params,
+  void *output
+) {
+  memoryZero(file, sizeof(assetfile_t));
+
+  file->filename = filename;
+  file->params = params;
+  file->output = output;
+
+  // Stat the file
+  zip_stat_init(&file->stat);
+  if(!zip_stat(ASSET.zip, filename, 0, &file->stat) == 0) {
+    errorThrow("Failed to stat asset file: %s", filename);
+  }
+
+  // Minimum file size.
+  file->size = (zip_int64_t)file->stat.size;
+  if(file->size <= 0) {
+    errorThrow("Invalid asset file size: %s", filename);
+  }
+
+  errorOk();
+}
+
+errorret_t assetFileRewind(assetfile_t *file) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(file->zipFile, "Asset file must be opened before rewinding.");
+
+  if(file->position == 0) {
+    errorOk();
+  }
+
+  errorChain(assetFileClose(file));
+  errorChain(assetFileOpen(file));
+  errorOk();
+}
+
+errorret_t assetFileOpen(assetfile_t *file) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(file->filename, "Asset file filename cannot be NULL.");
+  assertNotNull(ASSET.zip, "Asset zip cannot be NULL.");
+  assertNull(file->zipFile, "Asset file already open.");
+
+  file->zipFile = zip_fopen(ASSET.zip, file->filename, 0);
+  if(file->zipFile == NULL) {
+    errorThrow("Failed to open asset file: %s", file->filename);
+  }
+  file->position = 0;
+  errorOk();
+}
+
+errorret_t assetFileRead(
+  assetfile_t *file,
+  void *buffer,
+  const size_t bufferSize
+) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(file->zipFile, "Asset file must be opened before reading.");
+
+  // I assume zip_fread takes buffer NULL for skipping?
+  zip_int64_t bytesRead = zip_fread(file->zipFile, buffer, bufferSize);
+  if(bytesRead < 0) {
+    errorThrow("Failed to read from asset file: %s", file->filename);
+  }
+  file->position += bytesRead;
+  file->lastRead = bytesRead;
+  errorOk();
+}
+
+errorret_t assetFileClose(assetfile_t *file) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(file->zipFile, "Asset file must be opened before closing.");
+
+  if(zip_fclose(file->zipFile) != 0) {
+    errorThrow("Failed to close asset file: %s", file->filename);
+  }
+  file->zipFile = NULL;
+  file->position = 0;
+  errorOk();
+}
+
+errorret_t assetFileDispose(assetfile_t *file) {
+  if(file->zipFile != NULL) {
+    errorChain(assetFileClose(file));
+  }
+  memoryZero(file, sizeof(assetfile_t));
+  errorOk();
+}
+
+// Line Reader;
+void assetFileLineReaderInit(
+  assetfilelinereader_t *reader,
+  assetfile_t *file,
+  uint8_t *readBuffer,
+  const size_t readBufferSize,
+  uint8_t *outBuffer,
+  const size_t outBufferSize
+) {
+  assertNotNull(reader, "Line reader cannot be NULL.");
+  assertNotNull(file, " File cannot be NULL.");
+  assertNotNull(readBuffer, "Read buffer cannot be NULL.");
+  assertNotNull(outBuffer, "Output buffer cannot be NULL.");
+  assertTrue(readBufferSize > 0, "Read buffer size must be greater than 0.");
+  assertTrue(outBufferSize > 0, "Output buffer size must be greater than 0.");
+  
+  memoryZero(reader, sizeof(assetfilelinereader_t));
+
+  reader->file = file;
+  reader->readBuffer = readBuffer;
+  reader->readBufferSize = readBufferSize;
+  reader->outBuffer = outBuffer;
+  reader->outBufferSize = outBufferSize;
+}
+
+size_t assetFileLineReaderUnreadBytes(const assetfilelinereader_t *reader) {
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertTrue(reader->bufferEnd >= reader->bufferStart, "Invalid buffer state.");
+  return reader->bufferEnd - reader->bufferStart;
+}
+
+const uint8_t *assetFileLineReaderUnreadPtr(const assetfilelinereader_t *reader) {
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->readBuffer, "Read buffer cannot be NULL.");
+  return reader->readBuffer + reader->bufferStart;
+}
+
+static errorret_t assetFileLineReaderAppend(
+  assetfilelinereader_t *reader,
+  const uint8_t *src,
+  size_t srcLength
+) {
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->outBuffer, "Out buffer cannot be NULL.");
+
+  if(srcLength == 0) {
+    errorOk();
+  }
+
+  /* reserve room for optional NUL terminator */
+  if (reader->lineLength + srcLength >= reader->outBufferSize) {
+    errorThrow("Line length exceeds output buffer size.");
+  }
+
+  memoryCopy(reader->outBuffer + reader->lineLength, src, srcLength);
+  reader->lineLength += srcLength;
+  errorOk();
+}
+
+static void assetFileLineReaderTerminate(assetfilelinereader_t *reader) {
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->outBuffer, "Out buffer cannot be NULL.");
+  assertTrue(reader->lineLength < reader->outBufferSize, "Line length exceeds out buffer.");
+  reader->outBuffer[reader->lineLength] = '\0';
+}
+
+static ssize_t assetFileLineReaderFindNewline(const assetfilelinereader_t *reader) {
+  size_t i;
+
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->readBuffer, "Read buffer cannot be NULL.");
+
+  for (i = reader->bufferStart; i < reader->bufferEnd; ++i) {
+    if (reader->readBuffer[i] == '\n') {
+      return (ssize_t)i;
+    }
+  }
+
+  return -1;
+}
+
+errorret_t assetFileLineReaderFill(assetfilelinereader_t *reader) {
+
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->file, "File cannot be NULL.");
+  assertNotNull(reader->readBuffer, "Read buffer cannot be NULL.");
+
+  if(reader->eof) errorOk();
+
+  errorret_t ret;
+
+  size_t unreadBytes = assetFileLineReaderUnreadBytes(reader);
+
+  /* If buffer is fully consumed, refill from start. */
+  if (unreadBytes == 0) {
+    reader->bufferStart = 0;
+    reader->bufferEnd = 0;
+
+    errorChain(assetFileRead(
+      reader->file,
+      reader->readBuffer,
+      reader->readBufferSize
+    ));
+
+    if(reader->file->lastRead == 0) {
+      reader->eof = true;
+      errorOk();
+    }
+
+    reader->bufferStart = 0;
+    reader->bufferEnd = reader->file->lastRead;
+    errorOk();
+  }
+
+  /*
+   * There are unread bytes left but no newline in them.
+   * If bufferStart > 0, slide unread bytes to front so we can read more.
+   * This only happens when necessary to make space.
+   */
+  if(reader->bufferEnd == reader->readBufferSize) {
+    if(reader->bufferStart == 0) {
+      /*
+       * Entire read buffer is unread and contains no newline.
+       * Caller must have a large enough outBuffer to accumulate across fills,
+       * so we consume these bytes into outBuffer before refilling.
+       */
+      errorOk();
+    }
+
+    memoryMove(
+      reader->readBuffer,
+      reader->readBuffer + reader->bufferStart,
+      unreadBytes
+    );
+    reader->bufferStart = 0;
+    reader->bufferEnd = unreadBytes;
+  }
+
+  errorChain(assetFileRead(
+    reader->file,
+    reader->readBuffer + reader->bufferEnd,
+    reader->readBufferSize - reader->bufferEnd
+  ));
+
+  if(reader->file->lastRead == 0) {
+    reader->eof = true;
+    errorOk();
+  }
+
+  reader->bufferEnd += reader->file->lastRead;
+  errorOk();
+}
+
+errorret_t assetFileLineReaderNext(assetfilelinereader_t *reader) {
+  assertNotNull(reader, "Reader cannot be NULL.");
+  assertNotNull(reader->file, "File cannot be NULL.");
+  assertNotNull(reader->readBuffer, "Read buffer cannot be NULL.");
+  assertNotNull(reader->outBuffer, "Out buffer cannot be NULL.");
+
+  reader->lineLength = 0;
+
+  for (;;) {
+    ssize_t newlineIndex = assetFileLineReaderFindNewline(reader);
+
+    if (newlineIndex >= 0) {
+      size_t chunkLength = (size_t)newlineIndex - reader->bufferStart;
+      errorret_t ret;
+
+      /* strip CR in CRLF */
+      if (chunkLength > 0 && reader->readBuffer[(size_t)newlineIndex - 1] == '\r') {
+        chunkLength--;
+      }
+
+      errorChain(assetFileLineReaderAppend(
+        reader,
+        reader->readBuffer + reader->bufferStart,
+        chunkLength
+      ));
+      
+      reader->bufferStart = (size_t)newlineIndex + 1;
+      assetFileLineReaderTerminate(reader);
+      errorOk();
+    }
+
+    if (assetFileLineReaderUnreadBytes(reader) > 0) {
+      errorChain(assetFileLineReaderAppend(
+        reader,
+        assetFileLineReaderUnreadPtr(reader),
+        assetFileLineReaderUnreadBytes(reader)
+      ));
+
+      reader->bufferStart = reader->bufferEnd;
+    }
+
+    if(reader->eof) {
+      if(reader->lineLength > 0) {
+        assetFileLineReaderTerminate(reader);
+        errorOk();
+      }
+
+      errorThrow("End of file reached.");
+    }
+
+    errorChain(assetFileLineReaderFill(reader));
+  }
+}

src/dusk/asset/assetfile.h

@@ -0,0 +1,138 @@
+/**
+ * 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 <zip.h>
+
+typedef struct assetfile_s assetfile_t;
+
+typedef errorret_t (*assetfileloader_t)(assetfile_t *file);
+
+typedef struct assetfile_s {
+  const char_t *filename;
+  void *params;
+  void *output;
+
+  zip_stat_t stat;
+  zip_int64_t size;
+  zip_int64_t position;
+  zip_int64_t lastRead;
+  zip_file_t *zipFile;
+} assetfile_t;
+
+/**
+ * Initializes the asset file structure in preparation for loading. This will
+ * stat the file but not open the handle.
+ * 
+ * @param file The asset file structure to initialize.
+ * @param filename The name of the asset file to load.
+ * @param params Optional loader params.
+ * @param output Output pointer for the loader.
+ * @return Error indicating success or failure.
+ */
+errorret_t assetFileInit(
+  assetfile_t *file,
+  const char_t *filename,
+  void *params,
+  void *output
+);
+
+/**
+ * Opens the asset file for reading. After opening the loader is responsible
+ * for closing the file.
+ * 
+ * @param file The asset file to open.
+ * @return An error code if the file could not be opened.
+ */
+errorret_t assetFileOpen(assetfile_t *file);
+
+/**
+ * Rewind the file to the initial position.
+ * 
+ * @param file The asset file to rewind.
+ */
+errorret_t assetFileRewind(assetfile_t *file);
+
+/**
+ * Read bytes from the asset file. Assumes the file has already been opened
+ * prior to trying to read anything.
+ * 
+ * @param file File to read from.
+ * @param buffer Buffer to read the file data into., or NULL to skip bytes.
+ * @param size Size of the buffer to read into.
+ */
+errorret_t assetFileRead(
+  assetfile_t *file,
+  void *buffer,
+  const size_t bufferSize
+);
+
+/**
+ * Closes the asset file and releases any resources associated with it.
+ * 
+ * @param file The asset file to close.
+ * @return An error code if the file could not be closed properly.
+ */
+errorret_t assetFileClose(assetfile_t *file);
+
+/**
+ * Disposes the asset file structure, closing any open handles and zeroing
+ * out the structure.
+ * 
+ * @param file The asset file to dispose.
+ * @return An error code if the file could not be disposed properly.
+ */
+errorret_t assetFileDispose(assetfile_t *file);
+
+typedef struct {
+  assetfile_t *file;
+  uint8_t *readBuffer;
+  size_t readBufferSize;
+  uint8_t *outBuffer;
+  size_t outBufferSize;
+
+  // A
+  size_t bufferStart;
+  size_t bufferEnd;
+  bool_t eof;//?
+
+  // Updated each reach:
+  size_t lineLength;
+} assetfilelinereader_t;
+
+/**
+ * Initializes a line reader for the given asset file. The line reader will read
+ * lines from the file into the provided line buffer, using the provided buffer
+ * for reading chunks of the file.
+ * 
+ * @param file The asset file to read from. Must already be opened.
+ * @param readBuffer Buffer to use for reading chunks of the file.
+ * @param readBufferSize Size of the read buffer.
+ * @param outBuffer Buffer to read lines into. Lines will be null-terminated.
+ * @param outBufferSize Size of the output buffer.
+ * @return An initialized line reader structure.
+ */
+void assetFileLineReaderInit(
+  assetfilelinereader_t *reader,
+  assetfile_t *file,
+  uint8_t *readBuffer,
+  const size_t readBufferSize,
+  uint8_t *outBuffer,
+  const size_t outBufferSize
+);
+
+/**
+ * Reads the next line from the asset file into the line buffer. The line
+ * buffer is null-terminated and does not include the newline character.
+ * 
+ * @param reader The line reader to read from.
+ * @return An error code if a failure occurs, or errorOk() if a line was read
+ *         successfully. If the end of the file is reached, errorEndOfFile() is
+ *         returned.
+ */
+errorret_t assetFileLineReaderNext(assetfilelinereader_t *reader);

src/dusk/asset/assettype.h

@@ -1,106 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "type/assettexture.h"
-// #include "type/assetpalette.h"
-#include "type/assettileset.h"
-#include "type/assetlanguage.h"
-#include "type/assetscript.h"
-#include "type/assetmap.h"
-#include "type/assetmapchunk.h"
-#include <zip.h>
-
-typedef enum {
-  ASSET_TYPE_NULL,
-  
-  ASSET_TYPE_TEXTURE,
-  // ASSET_TYPE_PALETTE,
-  ASSET_TYPE_TILESET,
-  ASSET_TYPE_LANGUAGE,
-  ASSET_TYPE_SCRIPT,
-  ASSET_TYPE_MAP,
-  ASSET_TYPE_MAP_CHUNK,
-
-  ASSET_TYPE_COUNT,
-} assettype_t;
-
-typedef enum {
-  ASSET_LOAD_STRAT_ENTIRE,
-  ASSET_LOAD_STRAT_CUSTOM
-} assetloadstrat_t;
-
-typedef struct assetentire_s {
-  void *data;
-  void *output;
-} assetentire_t;
-
-typedef struct assetcustom_s {
-  zip_file_t *zipFile;
-  void *output;
-} assetcustom_t;
-
-typedef struct {
-  const char_t *extension;
-  const size_t dataSize;
-  const assetloadstrat_t loadStrategy;
-  union {
-    errorret_t (*entire)(assetentire_t entire);
-    errorret_t (*custom)(assetcustom_t custom);
-  };
-} assettypedef_t;
-
-static const assettypedef_t ASSET_TYPE_DEFINITIONS[ASSET_TYPE_COUNT] = {
-  [ASSET_TYPE_NULL] = {
-    0
-  },
-
-  [ASSET_TYPE_TEXTURE] = {
-    .extension = "dpt",
-    .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
-    .dataSize = sizeof(assettexture_t),
-    .entire = assetTextureLoad
-  },
-
-  // [ASSET_TYPE_PALETTE] = {
-  //   .extension = "dpf",
-  //   .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
-  //   .dataSize = sizeof(palette_t),
-  //   .entire = assetPaletteLoad
-  // },
-
-  [ASSET_TYPE_TILESET] = {
-    .extension = "dtf",
-    .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
-    .dataSize = sizeof(assettileset_t),
-    .entire = assetTilesetLoad
-  },
-
-  [ASSET_TYPE_LANGUAGE] = {
-    .extension = "DLF",
-    .loadStrategy = ASSET_LOAD_STRAT_CUSTOM,
-    .custom = assetLanguageHandler
-  },
-
-  [ASSET_TYPE_SCRIPT] = {
-    .extension = "lua",
-    .loadStrategy = ASSET_LOAD_STRAT_CUSTOM,
-    .custom = assetScriptHandler
-  },
-
-  // [ASSET_TYPE_MAP] = {
-  //   .extension = "DMF",
-  //   .loadStrategy = ASSET_LOAD_STRAT_CUSTOM,
-  //   .custom = assetMapHandler
-  // },
-
-  // [ASSET_TYPE_MAP_CHUNK] = {
-  //   .extension = "DMC",
-  //   .loadStrategy = ASSET_LOAD_STRAT_CUSTOM,
-  //   .custom = assetMapChunkHandler
-  // },
-};

src/dusk/asset/loader/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2026 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+
+# Subdirs
+add_subdirectory(display)
+add_subdirectory(locale)
+add_subdirectory(script)
+add_subdirectory(json)

src/dusk/asset/loader/display/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (c) 2026 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    assettextureloader.c
+    assettilesetloader.c
+)

src/dusk/asset/loader/display/assettextureloader.c

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assettextureloader.h"
+#include "assert/assert.h"
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+#include "log/log.h"
+#include "util/endian.h"
+
+stbi_io_callbacks ASSET_TEXTURE_STB_CALLBACKS = {
+  .read = assetTextureReader,
+  .skip = assetTextureSkipper,
+  .eof = assetTextureEOF
+};
+
+int assetTextureReader(void *user, char *data, int size) {
+  assertNotNull(data, "Data buffer for stb_image callbacks cannot be NULL.");
+
+  assetfile_t *file = (assetfile_t*)user;
+  assertNotNull(file, "Asset file in stb_image callbacks cannot be NULL.");
+  
+  errorret_t ret = assetFileRead(file, data, (size_t)size);
+  if(ret.code != ERROR_OK) {
+    errorCatch(errorPrint(ret));
+    return -1;
+  }
+
+  return file->lastRead;
+}
+
+void assetTextureSkipper(void *user, int n) {
+  assetfile_t *file = (assetfile_t*)user;
+  assertNotNull(file, "Asset file in stb_image callbacks cannot be NULL.");
+
+  errorret_t ret = assetFileRead(file, NULL, (size_t)n);
+  if(ret.code != ERROR_OK) {
+    errorCatch(errorPrint(ret));
+  }
+}
+
+int assetTextureEOF(void *user) {
+  assetfile_t *file = (assetfile_t*)user;
+  assertNotNull(file, "Asset file in stb_image callbacks cannot be NULL.");
+
+  return file->position >= file->size;
+}
+
+errorret_t assetTextureLoader(assetfile_t *file) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(file->params, "Asset file parameters cannot be NULL.");
+  assertNotNull(file->output, "Asset file output cannot be NULL.");
+
+  assettextureloaderparams_t *p = (assettextureloaderparams_t*)file->params;
+  assertNotNull(p, "Asset texture loader parameters cannot be NULL.");
+
+  int channelsDesired;
+  switch(p->format) {
+    case TEXTURE_FORMAT_RGBA:
+      channelsDesired = 4;
+      break;
+
+    default:
+      errorThrow("Bad texture format.");
+  }
+
+  int width, height, channels;
+  errorChain(assetFileOpen(file));
+  uint8_t *data = stbi_load_from_callbacks(
+    &ASSET_TEXTURE_STB_CALLBACKS,
+    file,
+    &width,
+    &height,
+    &channels,
+    channelsDesired
+  );
+  errorChain(assetFileClose(file));
+
+  if(data == NULL) {
+    const char_t *errorStr = stbi_failure_reason();
+    errorThrow("Failed to load texture from file %s.", errorStr);
+  }
+
+  // Fixes a specific bug probably with Dolphin but for now just assuming endian
+  if(!isHostLittleEndian()) {
+    stbi__vertical_flip(data, width, height, channelsDesired);
+  }
+
+  errorChain(textureInit(
+    (texture_t*)file->output,
+    (int32_t)width, (int32_t)height,
+    p->format,
+    (texturedata_t){
+      .rgbaColors = (color_t*)data
+    }
+  ));
+
+  stbi_image_free(data);
+  errorOk();
+}
+
+errorret_t assetTextureLoad(
+  const char_t *path,
+  texture_t *out,
+  const textureformat_t format
+) {
+  assettextureloaderparams_t params = {
+    .format = format
+  };
+  return assetLoad(path, assetTextureLoader, &params, out);
+}

src/dusk/asset/loader/display/assettextureloader.h

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/asset.h"
+#include "display/texture/texture.h"
+
+typedef struct {
+  textureformat_t format;
+} assettextureloaderparams_t;
+
+/**
+ * STB image read callback for asset files.
+ * 
+ * @param user User data passed to the callback, should be an assetfile_t*.
+ * @param data Buffer to read the file data into.
+ * @param size Size of the buffer to read into.
+ * @return Number of bytes read, or -1 on error.
+ */
+int assetTextureReader(void *user, char *data, int size);
+
+void assetTextureSkipper(void *user, int n);
+
+int assetTextureEOF(void *user);
+
+/**
+ * Handler for texture assets.
+ * 
+ * @param file Asset file to load the texture from.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetTextureLoader(assetfile_t *file);
+
+/**
+ * Loads a texture from the specified path.
+ * 
+ * @param path Path to the texture asset.
+ * @param out Output texture to load into.
+ * @param format Format of the texture to load.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetTextureLoad(
+  const char_t *path,
+  texture_t *out,
+  const textureformat_t format
+);

src/dusk/asset/loader/display/assettilesetloader.c

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assettilesetloader.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/endian.h"
+
+errorret_t assetTilesetLoader(assetfile_t *file) {
+  assertNotNull(file, "Asset file pointer for tileset loader is null.");
+
+  tileset_t *out = (tileset_t *)file->output;
+  assertNotNull(out, "Output pointer for tileset loader is null.");
+
+  uint8_t *entire = memoryAllocate(file->size);
+  errorChain(assetFileOpen(file));
+  errorChain(assetFileRead(file, entire, file->size));
+  errorChain(assetFileClose(file));
+  assertTrue(file->lastRead == file->size, "Failed to read entire file.");
+
+
+  if(
+    entire[0] != 'D' || 
+    entire[1] != 'T' ||
+    entire[2] != 'F'
+  ) {
+    errorThrow("Invalid tileset header");
+  }
+
+  if(entire[3] != 0x00) {
+    errorThrow("Unsupported tileset version");
+  }
+
+  // Fix endianness
+
+  out->tileWidth = endianLittleToHost16(*(uint16_t *)(entire + 4));
+  out->tileHeight = endianLittleToHost16(*(uint16_t *)(entire + 6));
+  out->columns = endianLittleToHost16(*(uint16_t *)(entire + 8));
+  out->rows = endianLittleToHost16(*(uint16_t *)(entire + 10));
+  // out->right = endianLittleToHost16(*(uint16_t *)(entire + 12));
+  // out->bottom = endianLittleToHost16(*(uint16_t *)(entire + 14));
+
+  if(out->tileWidth == 0) {
+    errorThrow("Tile width cannot be 0");
+  }
+  if(out->tileHeight == 0) {
+    errorThrow("Tile height cannot be 0");
+  }
+  if(out->columns == 0) {
+    errorThrow("Column count cannot be 0");
+  }
+  if(out->rows == 0) {
+    errorThrow("Row count cannot be 0");
+  }
+
+  out->uv[0] = endianLittleToHostFloat(*(float *)(entire + 16));
+  out->uv[1] = endianLittleToHostFloat(*(float *)(entire + 20));
+
+  if(out->uv[1] < 0.0f || out->uv[1] > 1.0f) {
+    errorThrow("Invalid v0 value in tileset");
+  }
+
+  // Setup tileset
+  out->tileCount = out->columns * out->rows;
+
+  memoryFree(entire);
+
+  errorOk();
+}
+
+errorret_t assetTilesetLoad(
+  const char_t *path,
+  tileset_t *out
+) {
+  return assetLoad(path, assetTilesetLoader, NULL, out);
+}

src/dusk/asset/loader/display/assettilesetloader.h

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/asset.h"
+#include "display/texture/tileset.h"
+
+/**
+ * Handler for tileset assets.
+ * 
+ * @param file Asset file to load the tileset from.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetTilesetLoader(assetfile_t *file);
+
+/**
+ * Loads a tileset from the specified path.
+ * 
+ * @param path Path to the tileset asset.
+ * @param out Output tileset to load into.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetTilesetLoad(
+  const char_t *path,
+  tileset_t *out
+);

src/dusk/asset/loader/json/CMakeLists.txt

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

src/dusk/asset/loader/json/assetjsonloader.c

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetjsonloader.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+
+errorret_t assetJsonLoadFileToDoc(assetfile_t *file, yyjson_doc **outDoc) {
+  assertNotNull(file, "Asset file pointer for JSON loader is null.");
+  assertNotNull(outDoc, "Output pointer for JSON loader is null.");
+
+  if(file->size > ASSET_JSON_FILE_SIZE_MAX) {
+    errorThrow("JSON exceeds maximum allowed size");
+  }
+
+  // Create buffer
+  uint8_t *buffer = memoryAllocate(file->size);
+
+  errorChain(assetFileOpen(file));
+
+  // Read entire file
+  errorChain(assetFileRead(file, buffer, file->size));
+  assertTrue(file->lastRead == file->size, "Failed to read entire JSON file.");
+
+  errorChain(assetFileClose(file));
+
+  *outDoc = yyjson_read(
+    buffer,
+    file->size,
+    YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS
+  );
+  memoryFree(buffer);
+
+  if(!*outDoc) errorThrow("Failed to parse JSON");
+  errorOk();
+}
+
+errorret_t assetJsonLoader(assetfile_t *file) {
+  yyjson_doc **outDoc = (yyjson_doc **)file->output;
+  assertNotNull(outDoc, "Output pointer for JSON loader is null.");
+  return assetJsonLoadFileToDoc(file, outDoc);
+}
+
+errorret_t assetJsonLoad(
+  const char_t *path,
+  yyjson_doc **outDoc
+) {
+  return assetLoad(path, assetJsonLoader, NULL, outDoc);
+}

src/dusk/asset/loader/json/assetjsonloader.h

@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/asset.h"
+#include "yyjson.h"
+
+#define ASSET_JSON_FILE_SIZE_MAX 1024*256
+
+typedef struct {
+  void *nothing;
+} assetjsonloaderparams_t;
+
+/**
+ * Loads a JSON document from the specified asset file.
+ * 
+ * @param file Asset file to load the JSON document from.
+ * @param outDoc Pointer to store the loaded JSON document.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetJsonLoadFileToDoc(assetfile_t *file, yyjson_doc **outDoc);
+
+/**
+ * Handler for locale assets.
+ * 
+ * @param file Asset file to load the locale from.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetJsonLoader(assetfile_t *file);
+
+/**
+ * Loads a locale from the specified path.
+ * 
+ * @param path Path to the locale asset.
+ * @param outDoc Pointer to store the loaded JSON document.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetJsonLoad(
+  const char_t *path,
+  yyjson_doc **outDoc
+);

src/dusk/asset/loader/locale/CMakeLists.txt

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

src/dusk/asset/loader/locale/assetlocaleloader.c

@@ -0,0 +1,807 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetlocaleloader.h"
+#include "util/memory.h"
+#include "util/math.h"
+#include "util/string.h"
+#include "assert/assert.h"
+
+errorret_t assetLocaleFileInit(
+  assetlocalefile_t *localeFile,
+  const char_t *path
+) {
+  assertNotNull(localeFile, "Locale file cannot be NULL.");
+  assertNotNull(path, "Locale file path cannot be NULL.");
+  
+  memoryZero(localeFile, sizeof(assetlocalefile_t));
+
+  // Init the asset file.
+  errorChain(assetFileInit(&localeFile->file, path, NULL, NULL));
+
+  // Open the file handle
+  errorChain(assetFileOpen(&localeFile->file));
+
+  // Get the blank key, this is basically the header info for po files
+  char_t buffer[1024];
+  errorChain(assetLocaleGetString(localeFile, "", 0, buffer, sizeof(buffer)));
+  errorChain(assetLocaleParseHeader(localeFile, buffer, sizeof(buffer)));
+
+  errorOk();
+}
+
+errorret_t assetLocaleFileDispose(assetlocalefile_t *localeFile) {
+  assertNotNull(localeFile, "Locale file cannot be NULL.");
+
+  errorChain(assetFileClose(&localeFile->file));
+  errorChain(assetFileDispose(&localeFile->file));
+
+  errorOk();
+}
+
+errorret_t assetLocaleParseHeader(
+  assetlocalefile_t *localeFile,
+  char_t *headerBuffer,
+  const size_t headerBufferSize
+) {
+  assertNotNull(localeFile, "Locale file cannot be NULL.");
+  assertNotNull(headerBuffer, "Header buffer cannot be NULL.");
+  assertTrue(headerBufferSize > 0, "Header buffer size must be > 0.");
+
+  // Find "Plural-Forms: " line and parse out plural form info
+  char_t *pluralFormsLine = strstr(headerBuffer, "Plural-Forms:");
+  if(!pluralFormsLine) {
+    errorOk();
+  }
+
+  pluralFormsLine += strlen("Plural-Forms:");
+
+  // Expect nplurals
+  char_t *npluralsStr = strstr(pluralFormsLine, "nplurals=");
+  if(!npluralsStr) {
+    errorThrow("Failed to find nplurals in Plural-Forms header.");
+  }
+  npluralsStr += strlen("nplurals=");
+  localeFile->pluralStateCount = (uint8_t)atoi(npluralsStr);
+
+  if(localeFile->pluralStateCount == 0) {
+    errorThrow("nplurals must be greater than 0.");
+  }
+  if(localeFile->pluralStateCount > ASSET_LOCALE_FILE_PLURAL_FORM_COUNT) {
+    errorThrow(
+      "nplurals exceeds maximum supported plural forms: %d > %d",
+      localeFile->pluralStateCount,
+      ASSET_LOCALE_FILE_PLURAL_FORM_COUNT
+    );
+  }
+
+  // Expect plural=
+  char_t *pluralStr = strstr(pluralFormsLine, "plural=");
+  if(!pluralStr) {
+    errorThrow("Failed to find plural in Plural-Forms header.");
+  }
+  pluralStr += strlen("plural=");
+
+  // Expect ( [expressions] )
+  char_t *openParen = strchr(pluralStr, '(');
+  char_t *closeParen = strrchr(pluralStr, ')');
+  if(!openParen || !closeParen || closeParen < openParen) {
+    errorThrow("Failed to find plural expression in Plural-Forms header.");
+  }
+
+  // Parse:
+  // n [op] value ? index : n [op] value ? index : ... : final_index
+  char_t *ptr = openParen + 1;
+  uint8_t pluralIndex = 0;
+  uint8_t definedCount = 0;
+
+  while(1) {
+    while(*ptr == ' ') ptr++;
+
+    // Allow grouped subexpressions like:
+    //   (n<7 ? 2 : 3)
+    // or
+    //   (((3)))
+    uint8_t parenDepth = 0;
+    while(*ptr == '(') {
+      parenDepth++;
+      ptr++;
+      while(*ptr == ' ') ptr++;
+    }
+
+    // Final fallback: just an integer
+    if(*ptr != 'n') {
+      char_t *endPtr = NULL;
+      int32_t finalIndex = (int32_t)strtol(ptr, &endPtr, 10);
+      if(endPtr == ptr) {
+        errorThrow("Expected final plural index.");
+      }
+      ptr = endPtr;
+
+      while(*ptr == ' ') ptr++;
+      while(parenDepth > 0) {
+        if(*ptr != ')') {
+          errorThrow("Expected ')' after final plural index.");
+        }
+        ptr++;
+        parenDepth--;
+
+        while(*ptr == ' ') ptr++;
+      }
+
+      if(*ptr != ')') {
+        errorThrow("Expected ')' at end of plural expression.");
+      }
+
+      if(finalIndex < 0 || finalIndex >= localeFile->pluralStateCount) {
+        errorThrow(
+          "Final plural expression index out of bounds: %d (nplurals: %d)",
+          finalIndex,
+          localeFile->pluralStateCount
+        );
+      }
+
+      localeFile->pluralDefaultIndex = (uint8_t)finalIndex;
+      definedCount++;
+      break;
+    }
+
+    if(pluralIndex >= localeFile->pluralStateCount - 1) {
+      errorThrow(
+        "Too many plural conditions. Expected %d conditional clauses for nplurals=%d.",
+        localeFile->pluralStateCount - 1,
+        localeFile->pluralStateCount
+      );
+    }
+
+    ptr++; // skip 'n'
+
+    while(*ptr == ' ') ptr++;
+
+    // Determine operator
+    assetlocalepluraloperation_t op;
+    if(strncmp(ptr, "==", 2) == 0) {
+      op = ASSET_LOCALE_PLURAL_OP_EQUAL;
+      ptr += 2;
+    } else if(strncmp(ptr, "!=", 2) == 0) {
+      op = ASSET_LOCALE_PLURAL_OP_NOT_EQUAL;
+      ptr += 2;
+    } else if(strncmp(ptr, "<=", 2) == 0) {
+      op = ASSET_LOCALE_PLURAL_OP_LESS_EQUAL;
+      ptr += 2;
+    } else if(strncmp(ptr, ">=", 2) == 0) {
+      op = ASSET_LOCALE_PLURAL_OP_GREATER_EQUAL;
+      ptr += 2;
+    } else if(*ptr == '<') {
+      op = ASSET_LOCALE_PLURAL_OP_LESS;
+      ptr++;
+    } else if(*ptr == '>') {
+      op = ASSET_LOCALE_PLURAL_OP_GREATER;
+      ptr++;
+    } else {
+      errorThrow("Unsupported plural operator.");
+    }
+
+    while(*ptr == ' ') ptr++;
+
+    // Parse the comparitor value
+    char_t *endPtr = NULL;
+    int32_t value = (int32_t)strtol(ptr, &endPtr, 10);
+    if(endPtr == ptr) {
+      errorThrow("Expected value for plural expression.");
+    }
+    ptr = endPtr;
+
+    while(*ptr == ' ') ptr++;
+
+    // Parse ternary operator
+    if(*ptr != '?') {
+      errorThrow("Expected '?' after plural expression.");
+    }
+    ptr++;
+
+    while(*ptr == ' ') ptr++;
+
+    // Parse the indice
+    endPtr = NULL;
+    int32_t index = (int32_t)strtol(ptr, &endPtr, 10);
+    if(endPtr == ptr) {
+      errorThrow("Expected index for plural expression.");
+    }
+    ptr = endPtr;
+
+    if(index < 0 || index >= localeFile->pluralStateCount) {
+      errorThrow(
+        "Plural expression index out of bounds: %d (nplurals: %d)",
+        index,
+        localeFile->pluralStateCount
+      );
+    }
+
+    // Store plural expression.
+    localeFile->pluralIndices[pluralIndex] = (uint8_t)index;
+    localeFile->pluralOps[pluralIndex] = op;
+    localeFile->pluralValues[pluralIndex] = value;
+    pluralIndex++;
+    definedCount++;
+
+    while(*ptr == ' ') ptr++;
+
+    // Close any grouping parens that wrapped this conditional branch
+    while(parenDepth > 0) {
+      if(*ptr != ')') {
+        break;
+      }
+      ptr++;
+      parenDepth--;
+
+      while(*ptr == ' ') ptr++;
+    }
+
+    if(*ptr != ':') {
+      errorThrow("Expected ':' after plural expression.");
+    }
+    ptr++;
+  }
+
+  // Must define exactly nplurals outcomes:
+  //   (nplurals - 1) conditional results + 1 final fallback result
+  if(
+    pluralIndex != localeFile->pluralStateCount - 1 || 
+    definedCount != localeFile->pluralStateCount
+  ) {
+    errorThrow("Plural expression count does not match nplurals.");
+  }
+
+  errorOk();
+}
+
+
+uint8_t assetLocaleEvaluatePlural(
+  assetlocalefile_t *file,
+  const int32_t pluralCount
+) {
+  assertNotNull(file, "Locale file cannot be NULL.");
+  assertTrue(pluralCount >= 0, "Plural count cannot be negative.");
+
+  for(uint8_t i = 0; i < file->pluralStateCount - 1; i++) {
+    int32_t value = file->pluralValues[i];
+    switch(file->pluralOps[i]) {
+      case ASSET_LOCALE_PLURAL_OP_EQUAL:
+        if(pluralCount == value) return file->pluralIndices[i];
+        break;
+
+      case ASSET_LOCALE_PLURAL_OP_NOT_EQUAL:
+        if(pluralCount != value) return file->pluralIndices[i];
+        break;
+
+      case ASSET_LOCALE_PLURAL_OP_LESS:
+        if(pluralCount < value) return file->pluralIndices[i];
+        break;
+
+      case ASSET_LOCALE_PLURAL_OP_LESS_EQUAL:
+        if(pluralCount <= value) return file->pluralIndices[i];
+        break;
+
+      case ASSET_LOCALE_PLURAL_OP_GREATER:
+        if(pluralCount > value) return file->pluralIndices[i];
+        break;
+
+      case ASSET_LOCALE_PLURAL_OP_GREATER_EQUAL:
+        if(pluralCount >= value) return file->pluralIndices[i];
+        break;
+    }
+  }
+
+  return file->pluralDefaultIndex;
+}
+
+errorret_t assetLocaleLineSkipBlanks(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer
+) {
+  while(!reader->eof) {
+    // Skip blank lines
+    if(lineBuffer[0] == '\0') {
+      errorChain(assetFileLineReaderNext(reader));
+      continue;
+    }
+
+    // Skip comment lines
+    if(lineBuffer[0] == '#') {
+      errorChain(assetFileLineReaderNext(reader));
+      continue;
+    }
+    
+    // Is line only spaces?
+    size_t lineLength = strlen((char_t *)lineBuffer);
+    size_t i;
+    bool_t onlySpaces = true;
+    for(i = 0; i < lineLength; i++) {
+      if(lineBuffer[i] != ' ') {
+        onlySpaces = false;
+        break;
+      }
+    }
+
+    if(onlySpaces) {
+      errorChain(assetFileLineReaderNext(reader));
+      continue;
+    }
+    break;
+  }
+
+  errorOk();
+}
+
+errorret_t assetLocaleLineUnbuffer(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer,
+  uint8_t *stringBuffer,
+  const size_t stringBufferSize
+) {
+  stringBuffer[0] = '\0';
+
+  // At the point this funciton is called, we are looking for an opening quote.
+  char_t *start = strchr((char_t *)lineBuffer, '"');
+  if(!start) {
+    errorThrow("Expected open (0) \"");
+  }
+
+  char *end = strchr(start + 1, '"');
+  if(!end) {
+    errorThrow("Expected close (0) \"");
+  }
+  *end = '\0';
+
+  if(strlen(start) >= stringBufferSize) {
+    errorThrow("String buffer overflow");
+  }
+  memoryCopy(stringBuffer, start + 1, strlen(start));
+
+  // Now start buffering lines out
+  while(!reader->eof) {
+    errorChain(assetFileLineReaderNext(reader));
+
+    // Skip blank lines
+    errorChain(assetLocaleLineSkipBlanks(reader, lineBuffer));
+    
+    // Skip starting spaces
+    char_t *ptr = (char_t *)lineBuffer;
+    while(*ptr == ' ') {
+      ptr++;
+    }
+
+    // Only consider lines starting with quote
+    if(*ptr != '"') {
+      break;
+    }
+
+    ptr++; // move past first quote
+    
+    bool_t escaping = false;
+    char_t *dest = (char_t *)stringBuffer + strlen((char_t *)stringBuffer);
+    while(*ptr) {
+      if(escaping) {
+        // Handle escape sequences
+        switch(*ptr) {
+          case 'n': *dest++ = '\n'; break;
+          case 't': *dest++ = '\t'; break;
+          case '\\': *dest++ = '\\'; break;
+          case '"': *dest++ = '"'; break;
+          default:
+            errorThrow("Unknown escape sequence: \\%c", *ptr);
+        }
+        escaping = false;
+      } else if(*ptr == '\\') {
+        escaping = true;
+      } else if(*ptr == '"') {
+        // End of string
+        break;
+      } else {
+        // Regular character
+        *dest++ = *ptr;
+      }
+      if((size_t)(dest - (char_t *)stringBuffer) >= stringBufferSize) {
+        errorThrow("String buffer overflow");
+      }
+      ptr++;
+    }
+    *dest = '\0';
+  }
+
+  errorOk();
+}
+
+errorret_t assetLocaleGetString(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *stringBuffer,
+  const size_t stringBufferSize
+) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(messageId, "Message ID cannot be NULL.");
+  assertTrue(pluralCount >= 0, "Plural index cannot be negative.");
+  assertNotNull(stringBuffer, "String buffer cannot be NULL.");
+  assertTrue(stringBufferSize > 0, "String buffer size must be > 0");
+  assetfilelinereader_t reader;
+
+  bool_t msgidFound = false, msgidPluralFound = false, msgstrFound = false;
+  uint8_t msgidBuffer[256];
+  uint8_t msgidPluralBuffer[256];
+  uint8_t readBuffer[1024];
+  uint8_t lineBuffer[1024];
+  uint8_t pluralIndex = 0xFF;
+
+  msgidBuffer[0] = '\0';
+  msgidPluralBuffer[0] = '\0';
+  stringBuffer[0] = '\0';
+
+  // Rewind and start reading lines.
+  errorChain(assetFileRewind(&file->file));
+  assetFileLineReaderInit(
+    &reader,
+    &file->file,
+    readBuffer,
+    sizeof(readBuffer),
+    lineBuffer,
+    sizeof(lineBuffer)
+  );
+
+  // Skip blanks, comments, etc and start looking for msgid's
+  errorChain(assetLocaleLineSkipBlanks(&reader, lineBuffer));
+
+  while(!reader.eof) {
+    // Is this msgid?
+    if(memoryCompare(lineBuffer, "msgid", 5) != 0) {
+      errorChain(assetFileLineReaderNext(&reader));
+      msgidBuffer[0] = '\0';
+      continue;
+    }
+
+    // Unbuffer the msgid
+    assetLocaleLineUnbuffer(
+      &reader, lineBuffer, (uint8_t *)msgidBuffer, sizeof(msgidBuffer)
+    );
+
+    // Is this the needle?
+    if(memoryCompare(msgidBuffer, messageId, strlen(messageId)) != 0) {
+      continue;
+    }
+
+    msgidFound = true;
+    break;
+  }
+  if(!msgidFound) {
+    errorThrow("Failed to find message ID: %s", messageId);
+  }
+  
+  // We are either going to see a msgstr or a msgid_plural
+  while(!reader.eof) {
+    errorChain(assetLocaleLineSkipBlanks(&reader, lineBuffer));
+
+    // Is msgid_plural?
+    if(
+      !msgidPluralFound &&
+      memoryCompare(lineBuffer, "msgid_plural", 12) == 0
+    ) {
+      // Yes, start reading plural ID
+      assetLocaleLineUnbuffer(
+        &reader,
+        lineBuffer,
+        (uint8_t *)msgidPluralBuffer,
+        sizeof(msgidPluralBuffer)
+      );
+      msgidPluralFound = true;
+
+      // At this point we determine the plural index to use by running the
+      // plural formula
+      pluralIndex = assetLocaleEvaluatePlural(
+        file,
+        pluralCount
+      );
+      continue;
+    }
+
+    // Should be msgstr if not plural.
+    if(memoryCompare(lineBuffer, "msgstr", 6) != 0) {
+      errorThrow("Expected msgstr after msgid, found: %s", lineBuffer);
+      continue;
+    }
+
+    // If plural we need an index
+    if(msgidPluralFound) {
+      // Skip blank chars
+      char_t *ptr = (char_t *)lineBuffer + 6;
+      while(*ptr == ' ') {
+        ptr++;
+      }
+
+      if(*ptr != '[') {
+        errorThrow("Expected [ for plural form, found: %s", lineBuffer);
+      }
+
+      ptr++; // move past [
+
+      // Parse until ]
+      char *end = strchr(ptr, ']');
+      if(!end) {
+        errorThrow("Expected ] for plural form, found: %s", lineBuffer);
+      }
+      *end = '\0';
+
+      int32_t index = atoi(ptr);
+      if(index != pluralIndex) {
+        // Not the plural form we want, skip to the next useable line
+        while(!reader.eof) {
+          errorChain(assetFileLineReaderNext(&reader));
+          errorChain(assetLocaleLineSkipBlanks(&reader, lineBuffer));
+          if(
+            lineBuffer[0] == '\"' ||
+            lineBuffer[0] == '\0' ||
+            lineBuffer[0] == '#'
+          ) continue;
+          break;
+        }
+        continue;
+      }
+
+      // Undo damage to line buffer from unbuffering.
+      *end = ']';
+    }
+
+    // Parse out msgstr
+    errorChain(assetLocaleLineUnbuffer(
+      &reader, lineBuffer, (uint8_t *)stringBuffer, stringBufferSize
+    ));
+    msgstrFound = true;
+    break;
+  };
+
+  if(!msgstrFound) {
+    errorThrow("Failed to find msgstr for message ID: %s", messageId);
+  }
+
+  errorOk();
+}
+
+errorret_t assetLocaleGetStringWithVA(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralIndex,
+  char_t *buffer,
+  const size_t bufferSize,
+  ...
+) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertNotNull(messageId, "Message ID cannot be NULL.");
+  assertNotNull(buffer, "Buffer cannot be NULL.");
+  assertTrue(bufferSize > 0, "Buffer size must be > 0.");
+  assertTrue(pluralIndex >= 0, "Plural cannot be negative.");
+
+  char_t *tempBuffer;
+  tempBuffer = memoryAllocate(bufferSize);
+  errorret_t ret = assetLocaleGetString(
+    file,
+    messageId,
+    pluralIndex,
+    tempBuffer,
+    bufferSize
+  );
+  if(ret.code != ERROR_OK) {
+    memoryFree(tempBuffer);
+    return ret;
+  }
+
+  va_list args;
+  va_start(args, bufferSize);
+  int result = vsnprintf(buffer, bufferSize, tempBuffer, args);
+  va_end(args);
+  memoryFree(tempBuffer);
+
+  if(result < 0) {
+    errorThrow("Failed to format locale string for ID: %s", messageId);
+  }
+
+  return ret;
+}
+
+errorret_t assetLocaleGetStringWithArgs(
+  assetlocalefile_t *file,
+  const char_t *id,
+  const int32_t plural,
+  char_t *buffer,
+  const size_t bufferSize,
+  const assetlocalearg_t *args,
+  const size_t argCount
+) {
+  assertNotNull(id, "Message ID cannot be NULL.");
+  assertNotNull(buffer, "Buffer cannot be NULL.");
+  assertTrue(bufferSize > 0, "Buffer size must be > 0.");
+  assertTrue(plural >= 0, "Plural cannot be negative.");
+  assertTrue(
+    argCount == 0 || args != NULL,
+    "Args cannot be NULL when argCount > 0."
+  );
+
+  char_t *format = memoryAllocate(bufferSize);
+  if(format == NULL) {
+    errorThrow("Failed to allocate format buffer.");
+  }
+
+  errorret_t ret = assetLocaleGetString(
+    file,
+    id,
+    plural,
+    format,
+    bufferSize
+  );
+  if(ret.code != ERROR_OK) {
+    memoryFree(format);
+    return ret;
+  }
+
+  size_t inIndex = 0;
+  size_t outIndex = 0;
+  size_t nextArg = 0;
+
+  buffer[0] = '\0';
+
+  while(format[inIndex] != '\0') {
+    if(format[inIndex] != '%') {
+      if(outIndex + 1 >= bufferSize) {
+        memoryFree(format);
+        errorThrow("Formatted locale string buffer overflow for ID: %s", id);
+      }
+
+      buffer[outIndex++] = format[inIndex++];
+      continue;
+    }
+
+    inIndex++;
+
+    /* Escaped percent */
+    if(format[inIndex] == '%') {
+      if(outIndex + 1 >= bufferSize) {
+        memoryFree(format);
+        errorThrow("Formatted locale string buffer overflow for ID: %s", id);
+      }
+
+      buffer[outIndex++] = '%';
+      inIndex++;
+      continue;
+    }
+
+    if(nextArg >= argCount) {
+      memoryFree(format);
+      errorThrow("Not enough locale arguments for ID: %s", id);
+    }
+
+    {
+      char_t specBuffer[32];
+      char_t valueBuffer[256];
+      size_t specLength = 0;
+      int written = 0;
+      char_t specifier;
+
+      specBuffer[specLength++] = '%';
+
+      /* Allow flags / width / precision */
+      while(format[inIndex] != '\0') {
+        char_t ch = format[inIndex];
+
+        if(
+          ch == '-' || ch == '+' || ch == ' ' || ch == '#' || ch == '0' ||
+          ch == '.' || (ch >= '0' && ch <= '9')
+        ) {
+          if(specLength + 1 >= sizeof(specBuffer)) {
+            memoryFree(format);
+            errorThrow("Format specifier too long for ID: %s", id);
+          }
+
+          specBuffer[specLength++] = ch;
+          inIndex++;
+          continue;
+        }
+
+        break;
+      }
+
+      if(format[inIndex] == '\0') {
+        memoryFree(format);
+        errorThrow("Incomplete format specifier for ID: %s", id);
+      }
+
+      specifier = format[inIndex++];
+
+      if(specifier != 's' && specifier != 'd' && specifier != 'f') {
+        memoryFree(format);
+        errorThrow(
+          "Unsupported format specifier '%%%c' for ID: %s",
+          specifier,
+          id
+        );
+      }
+
+      specBuffer[specLength++] = specifier;
+      specBuffer[specLength] = '\0';
+
+      switch(specifier) {
+        case 's':
+          if(args[nextArg].type != ASSET_LOCALE_ARG_STRING) {
+            memoryFree(format);
+            errorThrow("Expected string locale argument for ID: %s", id);
+          }
+
+          written = snprintf(
+            valueBuffer,
+            sizeof(valueBuffer),
+            specBuffer,
+            args[nextArg].stringValue ? args[nextArg].stringValue : ""
+          );
+          break;
+
+        case 'd':
+          if(args[nextArg].type != ASSET_LOCALE_ARG_INT) {
+            memoryFree(format);
+            errorThrow("Expected int locale argument for ID: %s", id);
+          }
+
+          written = snprintf(
+            valueBuffer,
+            sizeof(valueBuffer),
+            specBuffer,
+            args[nextArg].intValue
+          );
+          break;
+
+        case 'f':
+          if(
+            args[nextArg].type != ASSET_LOCALE_ARG_FLOAT &&
+            args[nextArg].type != ASSET_LOCALE_ARG_INT
+          ) {
+            memoryFree(format);
+            errorThrow("Expected float or int locale argument for ID: %s", id);
+          }
+
+          float_t floatValue = (
+            args[nextArg].type == ASSET_LOCALE_ARG_FLOAT ?
+            args[nextArg].floatValue :
+            (float_t)args[nextArg].intValue
+          );
+
+          written = snprintf(
+            valueBuffer,
+            sizeof(valueBuffer),
+            specBuffer,
+            floatValue
+          );
+          break;
+      }
+
+      nextArg++;
+
+      if(written < 0) {
+        memoryFree(format);
+        errorThrow("Failed to format locale string for ID: %s", id);
+      }
+
+      if(outIndex + (size_t)written >= bufferSize) {
+        memoryFree(format);
+        errorThrow("Formatted locale string buffer overflow for ID: %s", id);
+      }
+
+      memoryCopy(buffer + outIndex, valueBuffer, (size_t)written);
+      outIndex += (size_t)written;
+    }
+  }
+
+  buffer[outIndex] = '\0';
+  memoryFree(format);
+  errorOk();
+}

src/dusk/asset/loader/locale/assetlocaleloader.h

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/asset.h"
+
+#define ASSET_LOCALE_FILE_PLURAL_FORM_COUNT 6
+
+typedef enum {
+  ASSET_LOCALE_PLURAL_OP_EQUAL,
+  ASSET_LOCALE_PLURAL_OP_NOT_EQUAL,
+  ASSET_LOCALE_PLURAL_OP_LESS,
+  ASSET_LOCALE_PLURAL_OP_LESS_EQUAL,
+  ASSET_LOCALE_PLURAL_OP_GREATER,
+  ASSET_LOCALE_PLURAL_OP_GREATER_EQUAL
+} assetlocalepluraloperation_t;
+
+typedef enum {
+  ASSET_LOCALE_ARG_STRING,
+  ASSET_LOCALE_ARG_INT,
+  ASSET_LOCALE_ARG_FLOAT
+} assetlocaleargtype_t;
+
+typedef struct {
+  assetlocaleargtype_t type;
+  union {
+    const char_t *stringValue;
+    int32_t intValue;
+    float_t floatValue;
+  };
+} assetlocalearg_t;
+
+typedef struct {
+  assetfile_t file;
+  assetlocalepluraloperation_t pluralOps[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+  int32_t pluralValues[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+  int32_t pluralIndices[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+  uint8_t pluralStateCount;
+  uint8_t pluralDefaultIndex;
+} assetlocalefile_t;
+
+/**
+ * Initialize a locale asset file.
+ * 
+ * @param localeFile The locale file to initialize.
+ * @param path The path to the locale file.
+ * @return An error code if a failure occurs.
+ */
+errorret_t assetLocaleFileInit(
+  assetlocalefile_t *localeFile,
+  const char_t *path
+);
+
+/**
+ * Dispose of a locale asset file.
+ * 
+ * @param localeFile The locale file to dispose of.
+ * @return An error code if a failure occurs.
+ */
+errorret_t assetLocaleFileDispose(assetlocalefile_t *localeFile);
+
+errorret_t assetLocaleParseHeader(
+  assetlocalefile_t *localeFile,
+  char_t *headerBuffer,
+  const size_t headerBufferSize
+);
+
+/**
+ * Skips blank lines and comment lines in the line reader.
+ * 
+ * @param reader Line reader to read from.
+ * @param lineBuffer Buffer to use for reading lines.
+ * @return Any error that occurs during skipping.
+ */
+errorret_t assetLocaleLineSkipBlanks(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer
+);
+
+/**
+ * Unbuffers a potentially multi-line quoted string from the line reader.
+ * 
+ * This will read lines until it finds a line that starts with a quote, then
+ * read until the closing quote.
+ * 
+ * @param reader Line reader to read from.
+ * @param lineBuffer Buffer to use for reading lines.
+ * @param stringBuffer Buffer to write the unbuffered string to.
+ * @param stringBufferSize Size of the string buffer.
+ * @return Any error that occurs during unbuffering.
+ */
+errorret_t assetLocaleLineUnbuffer(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer,
+  uint8_t *stringBuffer,
+  const size_t stringBufferSize
+);
+
+/**
+ * Test function for locale asset loading.
+ * 
+ * @param file Asset file to test loading from.
+ * @param messageId The message ID to retrieve.
+ * @param pluralCount Count for formulating the plural variant.
+ * @param stringBuffer Buffer to write the retrieved string to.
+ * @param stringBufferSize Size of the string buffer.
+ * @return Any error that occurs during testing.
+ */
+errorret_t assetLocaleGetString(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *stringBuffer,
+  const size_t stringBufferSize
+);
+
+/**
+ * Test function for locale asset loading with a variable argument list.
+ * 
+ * @param file Asset file to test loading from.
+ * @param messageId The message ID to retrieve.
+ * @param pluralCount Count for formulating the plural variant.
+ * @param buffer Buffer to write the retrieved string to.
+ * @param bufferSize Size of the buffer.
+ * @param ... Additional arguments for formatting the string.
+ * @return Any error that occurs during testing.
+ */
+errorret_t assetLocaleGetStringWithVA(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *buffer,
+  const size_t bufferSize,
+  ...
+);
+
+/**
+ * Test function for locale asset loading with a list of arguments.
+ * 
+ * @param file Asset file to test loading from.
+ * @param messageId The message ID to retrieve.
+ * @param pluralCount Count for formulating the plural variant.
+ * @param buffer Buffer to write the retrieved string to.
+ * @param bufferSize Size of the buffer.
+ * @param args List of arguments for formatting the string.
+ * @param argCount Number of arguments in the list.
+ * @return Any error that occurs during testing.
+ */
+errorret_t assetLocaleGetStringWithArgs(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *buffer,
+  const size_t bufferSize,
+  const assetlocalearg_t *args,
+  const size_t argCount
+);

src/dusk/asset/loader/script/CMakeLists.txt

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

src/dusk/asset/loader/script/assetscriptloader.c

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetscriptloader.h"
+#include "assert/assert.h"
+
+errorret_t assetScriptLoader(assetfile_t *file) {
+  assertNotNull(file, "Asset file cannot be NULL");
+  assertNull(file->zipFile, "Asset file zip handle must be NULL");
+  assertNotNull(file->output, "Asset file output cannot be NULL");
+
+  assetscript_t *script = (assetscript_t *)file->output;
+
+  // Open the asset for buffering
+  errorChain(assetFileOpen(file));
+
+  // Request loading
+  if(!lua_load(
+    script->ctx->luaState,
+    assetScriptReader,
+    file,
+    file->filename,
+    NULL
+  ) == LUA_OK) {
+    const char_t *strErr = lua_tostring(script->ctx->luaState, -1);
+    lua_pop(script->ctx->luaState, 1);
+    errorThrow("Failed to load Lua script: %s", strErr);
+  }
+
+  // Now loaded, exec
+  if(lua_pcall(script->ctx->luaState, 0, LUA_MULTRET, 0) != LUA_OK) {
+    const char_t *strErr = lua_tostring(script->ctx->luaState, -1);
+    lua_pop(script->ctx->luaState, 1);
+    errorThrow("Failed to execute Lua script: %s", strErr);
+  }
+
+  // Close the file
+  return assetFileClose(file);
+}
+
+errorret_t assetScriptLoad(const char_t *path, scriptcontext_t *ctx) {
+  assertNotNull(path, "Script path cannot be NULL");
+  assertNotNull(ctx, "Script context cannot be NULL");
+  
+  assetscript_t script;
+  script.ctx = ctx;
+
+  return assetLoad(
+    path,
+    assetScriptLoader,
+    NULL,
+    &script
+  );
+}
+
+const char_t * assetScriptReader(lua_State* L, void* data, size_t* size) {
+  assetfile_t *file = (assetfile_t*)data;
+  assertNotNull(file, "Script asset file cannot be NULL");
+  assertNotNull(file->zipFile, "Script asset zip handle cannot be NULL");
+  assertNotNull(file->output, "Script asset output cannot be NULL");
+
+  assetscript_t *script = (assetscript_t *)file->output;
+  assertNotNull(script, "Script asset output cannot be NULL");
+
+  zip_int64_t read = zip_fread(
+    file->zipFile,
+    script->buffer,
+    sizeof(script->buffer)
+  );
+
+  if(read < 0) {
+    *size = 0;
+    return NULL;
+  }
+
+  *size = (size_t)read;
+  return script->buffer;
+}

src/dusk/asset/loader/script/assetscriptloader.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 "asset/asset.h"
+#include "script/scriptcontext.h"
+
+#define ASSET_SCRIPT_BUFFER_SIZE 1024
+
+typedef struct {
+  void *nothing;
+} assetscriptloaderparams_t;
+
+typedef struct {
+  scriptcontext_t *ctx;
+  char_t buffer[ASSET_SCRIPT_BUFFER_SIZE];
+} assetscript_t;
+
+/**
+ * Handler for script assets.
+ * 
+ * @param file Asset file to load the script from.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetScriptLoader(assetfile_t *file);
+
+/**
+ * Loads a script from the specified path.
+ * 
+ * @param path Path to the script asset.
+ * @param ctx Script context to load the script into.
+ * @return Any error that occurs during loading.
+ */
+errorret_t assetScriptLoad(const char_t *path, scriptcontext_t *ctx);
+
+/**
+ * Reader function for Lua to read script data from the asset.
+ * 
+ * @param L Lua state.
+ * @param data Pointer to the scriptcontext_t structure.
+ * @param size Pointer to store the size of the read data.
+ * @return Pointer to the read data buffer.
+ */
+const char_t * assetScriptReader(lua_State* L, void* data, size_t* size);

src/dusk/asset/type/assetmap.c

@@ -1,15 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "asset/asset.h"
-#include "assert/assert.h"
-#include "util/memory.h"
-
-errorret_t assetMapHandler(assetcustom_t custom) {
-  printf("Map Loaded from asset!\n");
-  errorOk();
-}

src/dusk/asset/type/assetmap.h

@@ -1,20 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-
-typedef struct assetcustom_s assetcustom_t;
-
-/**
- * Loads a map asset from the given data pointer into the output map structure.
- *
- * @param data Pointer to the raw assetmap_t data.
- * @param output Pointer to the map_t to load the map into.
- * @return An error code.
- */
-errorret_t assetMapHandler(assetcustom_t custom);

src/dusk/asset/type/assetmapchunk.c

@@ -1,185 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "asset/asset.h"
-#include "assert/assert.h"
-#include "map/mapchunk.h"
-#include "util/endian.h"
-
-#pragma pack(push, 1)
-typedef struct {
-  uint32_t tileCount;
-  uint8_t modelCount;
-  uint8_t entityCount;
-} assetchunkheader_t;
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  maptile_t tile;
-} assetchunktiledata_t;
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  uint32_t vertexCount;
-} assetchunkmodelheader_t;
-#pragma pack(pop)
-
-#pragma pack(push, 1)
-typedef struct {
-  uint8_t entityType;
-  uint8_t localX;
-  uint8_t localY;
-  uint8_t localZ;
-} assetchunkentityheader_t;
-#pragma pack(pop)
-
-errorret_t assetMapChunkHandler(assetcustom_t custom) {
-  assertNotNull(custom.output, "Output pointer cannot be NULL");
-  assertNotNull(custom.zipFile, "Zip file pointer cannot be NULL");
-
-  mapchunk_t *chunk = (mapchunk_t *)custom.output;
-  assertTrue(chunk->meshCount == 0, "Chunk is not in a good state");
-
-  // Read header
-  assetchunkheader_t header;
-  size_t bytesRead = zip_fread(
-    custom.zipFile, &header, sizeof(assetchunkheader_t)
-  );
-  if(bytesRead != sizeof(assetchunkheader_t)) {
-    zip_fclose(custom.zipFile);
-    errorThrow("Failed to read chunk asset header.");
-  }
-
-  // Fix endianess if necessary
-  header.tileCount = endianLittleToHost32(header.tileCount);
-
-  if(header.tileCount != CHUNK_TILE_COUNT) {
-    zip_fclose(custom.zipFile);
-    errorThrow(
-      "Chunk asset has invalid tile count: %d (expected %d).",
-      header.tileCount,
-      CHUNK_TILE_COUNT
-    );
-  }
-
-  if(header.modelCount > CHUNK_MESH_COUNT_MAX) {
-    zip_fclose(custom.zipFile);
-    errorThrow(
-      "Chunk asset has too many models: %d (max %d).",
-      header.modelCount,
-      CHUNK_MESH_COUNT_MAX
-    );
-  }
-
-  if(header.entityCount > CHUNK_ENTITY_COUNT_MAX) {
-    zip_fclose(custom.zipFile);
-    errorThrow(
-      "Chunk asset has too many entities: %d (max %d).",
-      header.entityCount,
-      CHUNK_ENTITY_COUNT_MAX
-    );
-  }
-
-  chunk->meshCount = header.modelCount;
-
-  // Read tile data
-  bytesRead = zip_fread(
-    custom.zipFile,
-    chunk->tiles,
-    sizeof(assetchunktiledata_t) * header.tileCount
-  );
-  if(bytesRead != sizeof(assetchunktiledata_t) * header.tileCount) {
-    zip_fclose(custom.zipFile);
-    errorThrow("Failed to read chunk tile data.");
-  }
-
-  // For each model...
-  uint32_t vertexIndex = 0;
-  for(uint8_t i = 0; i < header.modelCount; i++) {
-    assetchunkmodelheader_t modelHeader;
-    bytesRead = zip_fread(
-      custom.zipFile, &modelHeader, sizeof(assetchunkmodelheader_t)
-    );
-    if(bytesRead != sizeof(assetchunkmodelheader_t)) {
-      zip_fclose(custom.zipFile);
-      errorThrow("Failed to read chunk model header.");
-    }
-
-    // Fix endianess if necessary
-    modelHeader.vertexCount = endianLittleToHost32(modelHeader.vertexCount);
-
-    if(
-      vertexIndex + modelHeader.vertexCount >
-      CHUNK_VERTEX_COUNT_MAX
-    ) {
-      zip_fclose(custom.zipFile);
-      errorThrow("Chunk model vertex count exceeds maximum.");
-    }
-    
-    // Read vertex data.
-    bytesRead = zip_fread(
-      custom.zipFile,
-      &chunk->vertices[vertexIndex],
-      sizeof(meshvertex_t) * modelHeader.vertexCount
-    );
-    if(bytesRead != sizeof(meshvertex_t) * modelHeader.vertexCount) {
-      zip_fclose(custom.zipFile);
-      errorThrow("Failed to read chunk model vertex data.");
-    }
-
-    // Init the mesh
-    if(modelHeader.vertexCount > 0) {
-      mesh_t *mesh = &chunk->meshes[i];
-      meshInit(
-        mesh,
-        MESH_PRIMITIVE_TYPE_TRIANGLES,
-        modelHeader.vertexCount,
-        &chunk->vertices[vertexIndex]
-      );
-
-      vertexIndex += modelHeader.vertexCount;
-    } else {
-      // chunk->meshes[i].vertexCount = 0;
-    }
-  }
-
-  // Read entity data
-  // for(uint8_t i = 0; i < header.entityCount; i++) {
-  //   assetchunkentityheader_t entityHeader;
-  //   bytesRead = zip_fread(
-  //     custom.zipFile, &entityHeader, sizeof(assetchunkentityheader_t)
-  //   );
-  //   if(bytesRead != sizeof(assetchunkentityheader_t)) {
-  //     zip_fclose(custom.zipFile);
-  //     errorThrow("Failed to read chunk entity header.");
-  //   }
-
-  //   uint8_t entityIndex = entityGetAvailable();
-  //   if(entityIndex == 0xFF) {
-  //     zip_fclose(custom.zipFile);
-  //     errorThrow("No available entity slots.");
-  //   }
-
-  //   entity_t *entity = &ENTITIES[entityIndex];
-  //   entityInit(entity, (entitytype_t)entityHeader.entityType);
-  //   entity->position.x = (
-  //     (chunk->position.x * CHUNK_WIDTH) + entityHeader.localX
-  //   );
-  //   entity->position.y = (
-  //     (chunk->position.y * CHUNK_HEIGHT) + entityHeader.localY
-  //   );
-  //   entity->position.z = (
-  //     (chunk->position.z * CHUNK_DEPTH) + entityHeader.localZ
-  //   );
-
-  //   chunk->entities[i] = entityIndex;
-  // }
-
-  errorOk();
-}

src/dusk/asset/type/assetmapchunk.h

@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "error/error.h"
-
-typedef struct assetcustom_s assetcustom_t;
-
-/**
- * Handles loading of map chunk data from a map chunk asset file.
- * 
- * @param custom The custom asset loading parameters.
- * @return An error code.
- */
-errorret_t assetMapChunkHandler(assetcustom_t custom);

src/dusk/asset/type/assettexture.c

@@ -1,61 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#include "assettexture.h"
-#include "asset/assettype.h"
-#include "assert/assert.h"
-#include "display/texture/texture.h"
-#include "util/endian.h"
-
-errorret_t assetTextureLoad(assetentire_t entire) {
-  // assertNotNull(entire.data, "Data pointer cannot be NULL.");
-  // assertNotNull(entire.output, "Output pointer cannot be NULL.");
-
-  // assettexture_t *assetData = (assettexture_t *)entire.data;
-  // texture_t *texture = (texture_t *)entire.output;
-
-  // // Read header and version (first 4 bytes)
-  // if(
-  //   assetData->header[0] != 'D' || 
-  //   assetData->header[1] != 'P' ||
-  //   assetData->header[2] != 'T'
-  // ) {
-  //   errorThrow("Invalid texture header");
-  // }
-  
-  // // Version (can only be 1 atm)
-  // if(assetData->version != 0x01) {
-  //   errorThrow("Unsupported texture version");
-  // }
-
-  // // Fix endian
-  // assetData->width = endianLittleToHost32(assetData->width);
-  // assetData->height = endianLittleToHost32(assetData->height);
-
-  // // Check dimensions.
-  // if(
-  //   assetData->width == 0 || assetData->width > ASSET_TEXTURE_WIDTH_MAX ||
-  //   assetData->height == 0 || assetData->height > ASSET_TEXTURE_HEIGHT_MAX
-  // ) {
-  //   errorThrow("Invalid texture dimensions");
-  // }
-  
-  // textureInit(
-  //   texture,
-  //   assetData->width,
-  //   assetData->height,
-  //   TEXTURE_FORMAT_PALETTE,
-  //   (texturedata_t){
-  //     .paletted = {
-  //       .indices = NULL,
-  //       .palette = NULL
-  //     }
-  //   }
-  // );
-
-  // errorOk();
-}

src/dusk/display/camera/camera.c

@@ -35,9 +35,9 @@ void cameraInitOrthographic(camera_t *camera) {
   camera->projType = CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC;
   camera->orthographic.left = 0.0f;
   camera->orthographic.right = SCREEN.width;
-  camera->orthographic.top = 0.0f;
-  camera->orthographic.bottom = SCREEN.height;
-  camera->nearClip = -1.0f;
+  camera->orthographic.top = SCREEN.height;
+  camera->orthographic.bottom = 0.0f;
+  camera->nearClip = 0.1f;
   camera->farClip = 1.0f;
 
   camera->viewType = CAMERA_VIEW_TYPE_2D;
@@ -84,7 +84,7 @@ void cameraGetViewMatrix(camera_t *camera, mat4 dest) {
   assertNotNull(dest, "Destination matrix must not be null");
 
   if(camera->viewType == CAMERA_VIEW_TYPE_MATRIX) {
-    glm_mat4_copy(camera->view, dest);
+    glm_mat4_ucopy(camera->view, dest);
   } else if(camera->viewType == CAMERA_VIEW_TYPE_LOOKAT) {
     glm_mat4_identity(dest);
     glm_lookat(

src/dusk/display/color.csv

@@ -20,5 +20,4 @@ pink,1,0.75,0.8,1
 lime,0.75,1,0,1
 navy,0,0,0.5,1
 teal,0,0.5,0.5,1
-cornflower_blue,0.39,0.58,0.93,1
-salmon,1,0.5,0.5,1
+cornflower_blue,0.39,0.58,0.93,1

src/dusk/display/display.c

@@ -20,11 +20,27 @@
 #include "display/shader/shaderunlit.h"
 #include "time/time.h"
 
-display_t DISPLAY = { 0 };
+#include "script/module/display/moduleshader.h"
 
-texture_t PALETTE_TEXTURE;
-texture_t UNCOMPRESSED_TEXTURE;
-texture_t COMPRESSED_TEXTURE;
+display_t DISPLAY = { 0 };
+  mesh_t mesh;
+  meshvertex_t vertices[3] = {
+    {
+      .color = { 255, 0, 0, 255 },
+      .uv = { 0.0f, 0.0f },
+      .pos = { 0.0f, 0.5f, 0.0f }
+    },
+    {
+      .color = { 0, 255, 0, 255 },
+      .uv = { 0.5f, 1.0f },
+      .pos = { -0.5f, -0.5f, 0.0f }
+    },
+    {
+      .color = { 0, 0, 255, 255 },
+      .uv = { 1.0f, 0.0f },
+      .pos = { 0.5f, -0.5f, 0.0f }
+    }
+  };
 
 errorret_t displayInit(void) {
   memoryZero(&DISPLAY, sizeof(DISPLAY));
@@ -32,64 +48,27 @@ errorret_t displayInit(void) {
   #ifdef displayPlatformInit
     errorChain(displayPlatformInit());
   #endif
-
-  errorChain(shaderInit(&SHADER_UNLIT, &SHADER_UNLIT_DEFINITION));
   errorChain(quadInit());
   errorChain(frameBufferInitBackBuffer());
   errorChain(spriteBatchInit());
   errorChain(textInit());
   errorChain(screenInit());
 
-  // PALETTES[0].colors[0] = COLOR_RED;
-  // PALETTES[0].colors[1] = COLOR_GREEN;
-  // PALETTES[0].colors[2] = COLOR_BLUE;
-  // PALETTES[0].colors[3] = COLOR_WHITE;
-  // PALETTES[0].colors[4] = COLOR_MAGENTA;
-  // PALETTES[0].colors[5] = COLOR_CYAN;
-  // PALETTES[0].colors[6] = COLOR_YELLOW;
-  // PALETTES[0].colors[7] = COLOR_BLACK;
-  // PALETTES[0].count = 8;
+  // Setup initial shader with default values
+  errorChain(shaderInit(&SHADER_UNLIT, &SHADER_UNLIT_DEFINITION));
+  camera_t cam;
+  cameraInit(&cam);
+  mat4 mat;
+  cameraGetProjectionMatrix(&cam, mat);
+  errorChain(shaderBind(&SHADER_UNLIT));
+  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_PROJECTION, mat));
+  cameraGetViewMatrix(&cam, mat);
+  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_VIEW, mat));
+  glm_mat4_identity(mat);
+  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_MODEL, mat));
+  errorChain(shaderSetTexture(&SHADER_UNLIT, SHADER_UNLIT_TEXTURE, NULL));
 
-  // uint8_t indices[64] = {
-  //   0,0,0,0,0,0,0,0,
-  //   1,1,1,1,1,1,1,1,
-  //   2,2,2,2,2,2,2,2,
-  //   3,3,3,3,3,3,3,3,
-  //   4,4,4,4,4,4,4,4,
-  //   5,5,5,5,5,5,5,5,
-  //   6,6,6,6,6,6,6,6,
-  //   7,7,7,7,7,7,7,7
-  // };
-
-  // errorChain(textureInit(
-  //   &PALETTE_TEXTURE,
-  //   8, 8,
-  //   TEXTURE_FORMAT_PALETTE,
-  //   (texturedata_t){
-  //     .paletted = {
-  //       .indices = indices,
-  //       .palette = &PALETTES[0]
-  //     }
-  //   }
-  // ));
-
-  errorChain(textureInit(
-    &UNCOMPRESSED_TEXTURE,
-    8, 8,
-    TEXTURE_FORMAT_RGBA,
-    (texturedata_t){
-      .rgbaColors = (color_t[]){
-        COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK,
-        COLOR_GREEN, COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK, COLOR_RED,
-        COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK, COLOR_RED, COLOR_GREEN,
-        COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE,
-        COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE,
-        COLOR_CYAN, COLOR_YELLOW, COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA,
-        COLOR_YELLOW, COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN,
-        COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE, COLOR_MAGENTA, COLOR_CYAN, COLOR_YELLOW
-      }
-    }
-  ));
+  errorChain(meshInit(&mesh, MESH_PRIMITIVE_TYPE_TRIANGLES, 3, vertices));
 
   errorOk();
 }
@@ -110,38 +89,7 @@ errorret_t displayUpdate(void) {
     SCREEN.background
   );
 
-  camera_t camera;
-  // cameraInitOrthographic(&camera);
-  // camera.orthographic.left = 0.0f;
-  // camera.orthographic.right = SCREEN.width;
-  // camera.orthographic.top = SCREEN.height;
-  // camera.orthographic.bottom = 0.0f; 
-  cameraInitPerspective(&camera);
-  camera.lookat.position[0] = 3.0f;
-  camera.lookat.position[1] = 3.0f;
-  camera.lookat.position[2] = 3.0f;
-
-  mat4 proj, view, model;
-  cameraGetProjectionMatrix(&camera, proj);
-  cameraGetViewMatrix(&camera, view);
-  glm_mat4_identity(model);
-
-  errorChain(shaderBind(&SHADER_UNLIT));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_PROJECTION, proj));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_VIEW, view));
-  errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_MODEL, model));
-  // errorChain(shaderSetTexture(&SHADER_UNLIT, SHADER_UNLIT_TEXTURE, &PALETTE_TEXTURE));
-  errorChain(shaderSetTexture(&SHADER_UNLIT, SHADER_UNLIT_TEXTURE, &UNCOMPRESSED_TEXTURE));
-  errorChain(spriteBatchPush(
-    0.0f, 0.0f,
-    1.0f, 1.0f,
-    COLOR_WHITE,
-    0.0f, 0.0f,
-    1.0f, 1.0f
-  ));
-  errorChain(spriteBatchFlush());
-
-  // errorCatch(errorPrint(sceneRender()));
+  errorChain(sceneRender());
 
   // Render UI
   // uiRender();

src/dusk/display/shader/CMakeLists.txt

@@ -7,4 +7,5 @@
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     shader.c
+    shaderunlit.c
 )

src/dusk/display/shader/shader.c

@@ -8,15 +8,19 @@
 #include "shader.h"
 #include "assert/assert.h"
 
+shader_t *bound = NULL;
+
 errorret_t shaderInit(shader_t *shader, const shaderdefinition_t *def) {
   assertNotNull(shader, "Shader cannot be null");
   errorChain(shaderInitPlatform(shader, def));
+  bound = NULL;
   errorOk();
 }
 
 errorret_t shaderBind(shader_t *shader) {
   assertNotNull(shader, "Shader cannot be null");
   errorChain(shaderBindPlatform(shader));
+  bound = shader;
   errorOk();
 }
 
@@ -28,6 +32,7 @@ errorret_t shaderSetMatrix(
   assertNotNull(shader, "Shader cannot be null");
   assertStrLenMin(name, 1, "Uniform name cannot be empty");
   assertNotNull(matrix, "Matrix cannot be null");
+  assertTrue(bound == shader, "Shader must be bound.");
   errorChain(shaderSetMatrixPlatform(shader, name, matrix));
   errorOk();
 }
@@ -39,6 +44,7 @@ errorret_t shaderSetTexture(
 ) {
   assertNotNull(shader, "Shader cannot be null");
   assertStrLenMin(name, 1, "Uniform name cannot be empty");
+  assertTrue(bound == shader, "Shader must be bound.");
   errorChain(shaderSetTexturePlatform(shader, name, texture));
   errorOk();
 }
@@ -56,6 +62,7 @@ errorret_t shaderSetTexture(
 
 errorret_t shaderDispose(shader_t *shader) {
   assertNotNull(shader, "Shader cannot be null");
+  bound = NULL;
   errorChain(shaderDisposePlatform(shader));
   errorOk();
 }

src/dusk/display/shader/shaderunlit.c

@@ -5,9 +5,6 @@
  * https://opensource.org/licenses/MIT
  */
 
-#pragma once
-#include "dusk.h"
+#include "shaderunlit.h"
 
-typedef struct {
-  void *nothing;
-} dusklocale_t;
+shader_t SHADER_UNLIT = { 0 };

src/dusk/display/shader/shaderunlit.h

@@ -15,4 +15,4 @@
 // #define SHADER_UNLIT_COLOR "u_Color"
 
 extern shaderdefinition_t SHADER_UNLIT_DEFINITION;
-static shader_t SHADER_UNLIT;
+extern shader_t SHADER_UNLIT;

src/dusk/display/spritebatch/spritebatch.c

@@ -35,14 +35,13 @@ errorret_t spriteBatchPush(
   const float_t u1,
   const float_t v1
 ) {
-  errorChain(spriteBatchPush3D(
+  return spriteBatchPush3D(
     (vec3){ minX, minY, 0 },
     (vec3){ maxX, maxY, 0 },
     color,
     (vec2){ u0, v0 },
     (vec2){ u1, v1 }
-  ));
-  errorOk();
+  );
 }
 
 errorret_t spriteBatchPush3D(
@@ -53,11 +52,14 @@ errorret_t spriteBatchPush3D(
   const vec2 uv1
 ) {
   // Need to flush?
-  if(SPRITEBATCH.spriteCount >= SPRITEBATCH_SPRITES_MAX) {
+  if(SPRITEBATCH.spriteCount >= SPRITEBATCH_SPRITES_MAX_PER_FLUSH) {
     errorChain(spriteBatchFlush());
   }
 
-  size_t vertexOffset = SPRITEBATCH.spriteCount * QUAD_VERTEX_COUNT;
+  size_t vertexOffset = (
+    SPRITEBATCH.spriteCount +
+    (SPRITEBATCH.spriteFlush * SPRITEBATCH_SPRITES_MAX_PER_FLUSH)
+  ) * QUAD_VERTEX_COUNT;
   quadBuffer3D(
     &SPRITEBATCH_VERTICES[vertexOffset],
     min, max, color, uv0, uv1
@@ -68,6 +70,7 @@ errorret_t spriteBatchPush3D(
 
 void spriteBatchClear() {
   SPRITEBATCH.spriteCount = 0;
+  SPRITEBATCH.spriteFlush = 0;
 }
 
 errorret_t spriteBatchFlush() {
@@ -76,9 +79,19 @@ errorret_t spriteBatchFlush() {
   }
 
   size_t vertexCount = QUAD_VERTEX_COUNT * SPRITEBATCH.spriteCount;
-  errorChain(meshFlush(&SPRITEBATCH.mesh, 0, vertexCount));
-  errorChain(meshDraw(&SPRITEBATCH.mesh, 0, vertexCount));
-  spriteBatchClear();
+  size_t vertexOffset = (
+    SPRITEBATCH.spriteFlush * SPRITEBATCH_SPRITES_MAX_PER_FLUSH *
+    QUAD_VERTEX_COUNT
+  );
+  errorChain(meshFlush(&SPRITEBATCH.mesh, vertexOffset, vertexCount));
+  errorChain(meshDraw(&SPRITEBATCH.mesh, vertexOffset, vertexCount));
+
+  SPRITEBATCH.spriteFlush++;
+  if(SPRITEBATCH.spriteFlush >= SPRITEBATCH_FLUSH_COUNT) {
+    SPRITEBATCH.spriteFlush = 0;
+  }
+  SPRITEBATCH.spriteCount = 0;
+
   errorOk();
 }
 

src/dusk/display/spritebatch/spritebatch.h

@@ -8,12 +8,17 @@
 #pragma once
 #include "display/mesh/quad.h"
 
-#define SPRITEBATCH_SPRITES_MAX 16
+#define SPRITEBATCH_SPRITES_MAX 32
 #define SPRITEBATCH_VERTEX_COUNT (SPRITEBATCH_SPRITES_MAX * QUAD_VERTEX_COUNT) 
+#define SPRITEBATCH_FLUSH_COUNT 4
+#define SPRITEBATCH_SPRITES_MAX_PER_FLUSH (\
+  SPRITEBATCH_SPRITES_MAX / SPRITEBATCH_FLUSH_COUNT \
+)
 
 typedef struct {
   mesh_t mesh;
   int32_t spriteCount;
+  int32_t spriteFlush;
 } spritebatch_t;
 
 // Have to define these seperately because of alignment in certain platforms.

src/dusk/display/text/text.c

@@ -9,19 +9,23 @@
 #include "assert/assert.h"
 #include "util/memory.h"
 #include "display/spritebatch/spritebatch.h"
-#include "asset/asset.h"
+#include "asset/loader/display/assettextureloader.h"
+#include "asset/loader/display/assettilesetloader.h"
+#include "display/shader/shaderunlit.h"
 
 texture_t DEFAULT_FONT_TEXTURE;
 tileset_t DEFAULT_FONT_TILESET;
 
 errorret_t textInit(void) {
-  // errorChain(assetLoad("ui/minogram.dpt", &DEFAULT_FONT_TEXTURE));
-  // errorChain(assetLoad("ui/minogram.dtf", &DEFAULT_FONT_TILESET));
+  errorChain(assetTextureLoad(
+    "ui/minogram.png", &DEFAULT_FONT_TEXTURE, TEXTURE_FORMAT_RGBA
+  ));
+  errorChain(assetTilesetLoad("ui/minogram.dtf", &DEFAULT_FONT_TILESET));
   errorOk();
 }
 
 errorret_t textDispose(void) {
-  // errorChain(textureDispose(&DEFAULT_FONT_TEXTURE));
+  errorChain(textureDispose(&DEFAULT_FONT_TEXTURE));
   errorOk();
 }
 
@@ -45,6 +49,7 @@ errorret_t textDrawChar(
   vec4 uv;
   tilesetTileGetUV(tileset, tileIndex, uv);
 
+
   errorChain(spriteBatchPush(
     // texture,
     x, y,
@@ -70,6 +75,17 @@ errorret_t textDraw(
   float_t posX = x;
   float_t posY = y;
 
+  errorChain(shaderSetTexture(&SHADER_UNLIT, SHADER_UNLIT_TEXTURE, texture));
+
+  // errorChain(spriteBatchPush(
+  //   // texture,
+  //   posX, posY,
+  //   posX + texture->width * 1, posY + texture->height * 1,
+  //   color,
+  //   0.0f, 0.0f, 1.0f, 1.0f
+  // ));
+  // errorOk();
+
   char_t c;
   int32_t i = 0;
   while((c = text[i++]) != '\0') {

src/dusk/engine/engine.c

@@ -14,10 +14,11 @@
 #include "scene/scene.h"
 #include "asset/asset.h"
 #include "ui/ui.h"
-#include "map/map.h"
 #include "script/scriptmanager.h"
-#include "item/backpack.h"
 #include "assert/assert.h"
+#include "game/game.h"
+
+#include "asset/loader/json/assetjsonloader.h"
 
 engine_t ENGINE;
 
@@ -35,10 +36,9 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
   errorChain(scriptManagerInit());
   errorChain(displayInit());
   errorChain(uiInit());
-  errorChain(mapInit());
   errorChain(sceneInit());
-  backpackInit();
-  
+  errorChain(gameInit());
+
   // Run the initial script.
   scriptcontext_t ctx;
   errorChain(scriptContextInit(&ctx));
@@ -54,7 +54,7 @@ errorret_t engineUpdate(void) {
 
   uiUpdate();
   errorChain(sceneUpdate());
-  mapUpdate();
+  errorChain(gameUpdate());
   errorChain(displayUpdate());
 
   if(inputPressed(INPUT_ACTION_RAGEQUIT)) ENGINE.running = false;
@@ -68,7 +68,7 @@ void engineExit(void) {
 
 errorret_t engineDispose(void) {
   sceneDispose();
-  mapDispose();
+  errorChain(gameDispose());
   localeManagerDispose();
   uiDispose();
   errorChain(displayDispose());

src/dusk/locale/localeinfo.h

@@ -9,5 +9,11 @@
 #include "dusk.h"
 
 typedef struct {
+  const char_t *name;
   const char_t *file;
-} localeinfo_t;
+} localeinfo_t;
+
+static const localeinfo_t LOCALE_EN_US = {
+  .name = "en-US",
+  .file = "locale/en_US.po",
+};

src/dusk/locale/localemanager.c

@@ -7,32 +7,34 @@
 
 #include "localemanager.h"
 #include "util/memory.h"
-#include "asset/asset.h"
 #include "assert/assert.h"
 
 localemanager_t LOCALE;
 
 errorret_t localeManagerInit() {
   memoryZero(&LOCALE, sizeof(localemanager_t));
+
+  errorChain(localeManagerSetLocale(&LOCALE_EN_US));
+
   errorOk();
 }
 
-errorret_t localeManagerSetLocale(const dusklocale_t locale) {
-  errorThrow("Locale setting is not yet implemented.");
-  // assertTrue(locale < DUSK_LOCALE_COUNT, "Invalid locale.");
-  // assertTrue(locale != DUSK_LOCALE_NULL, "Cannot set locale to NULL.");
+errorret_t localeManagerSetLocale(const localeinfo_t *locale) {
+  if(LOCALE.fileOpen) {
+    errorChain(assetLocaleFileDispose(&LOCALE.file));
+    LOCALE.fileOpen = false;
+  }
 
-  // LOCALE.locale = locale;
-  // char_t languageFile[FILENAME_MAX];
-  // snprintf(
-  //   languageFile, FILENAME_MAX, "language/%s.dlf", LOCALE_INFOS[locale].file
-  // );
-  // assetLanguageDispose(&LOCALE.language);
-  // memoryZero(&LOCALE.language, sizeof(assetlanguage_t));
-  // errorChain(assetLoad(languageFile, &LOCALE.language));
-  // errorOk();
+  // Init the asset file
+  errorChain(assetLocaleFileInit(&LOCALE.file, locale->file));
+  LOCALE.fileOpen = true;
+
+  errorOk();
 }
 
 void localeManagerDispose() {
-  assetLanguageDispose(&LOCALE.language);
+  if(LOCALE.fileOpen) {
+    errorCatch(errorPrint(assetLocaleFileDispose(&LOCALE.file)));
+    LOCALE.fileOpen = false;
+  }
 }

src/dusk/locale/localemanager.h

@@ -6,13 +6,15 @@
  */
 
 #pragma once
-#include "asset/asset.h"
+#include "error/error.h"
 #include "localemanager.h"
-#include "locale/locale.h"
+#include "locale/localeinfo.h"
+#include "asset/loader/locale/assetlocaleloader.h"
 
 typedef struct {
-  dusklocale_t locale;
-  assetlanguage_t language;
+  const localeinfo_t *locale;
+  assetlocalefile_t file;
+  bool_t fileOpen;
 } localemanager_t;
 
 extern localemanager_t LOCALE;
@@ -30,7 +32,51 @@ errorret_t localeManagerInit();
  * @param locale The locale to set.
  * @return An error code if a failure occurs.
  */
-errorret_t localeManagerSetLocale(const dusklocale_t locale);
+errorret_t localeManagerSetLocale(const localeinfo_t *locale);
+
+/**
+ * Get a localized string for the given message ID.
+ * 
+ * @param id The message ID to retrieve.
+ * @param buffer Buffer to write the retrieved string to.
+ * @param bufferSize Size of the buffer.
+ * @param plural Plural index to retrieve.
+ * @param ... Additional arguments for formatting the string.
+ * @return An error code if a failure occurs.
+ */
+#define localeManagerGetText(id, buffer, bufferSize, plural, ...) \
+  assetLocaleGetStringWithVA( \
+    &LOCALE.file, \
+    id, \
+    plural, \
+    buffer, \
+    bufferSize, \
+    __VA_ARGS__ \
+  )
+
+/**
+ * Get a localized string for the given message ID with a list of arguments.
+ * 
+ * @param id The message ID to retrieve.
+ * @param buffer Buffer to write the retrieved string to.
+ * @param bufferSize Size of the buffer.
+ * @param plural Plural index to retrieve.
+ * @param args List of arguments for formatting the string.
+ * @param argCount Number of arguments in the list.
+ * @return An error code if a failure occurs.
+ */
+#define localeManagerGetTextArgs( \
+  id, buffer, bufferSize, plural, args, argCount \
+) \
+  assetLocaleGetStringWithArgs( \
+    &LOCALE.file, \
+    id, \
+    plural, \
+    buffer, \
+    bufferSize, \
+    args, \
+    argCount \
+  )
 
 /**
  * Dispose of the locale system.

src/dusk/scene/scene.c

@@ -22,7 +22,7 @@ errorret_t sceneInit(void) {
 
 errorret_t sceneUpdate(void) {
   #ifdef DUSK_TIME_DYNAMIC
-    if(!TIME.dynamicUpdate) {
+    if(TIME.dynamicUpdate) {
       errorOk();
     }
   #endif

src/dusk/script/module/CMakeLists.txt

@@ -7,11 +7,8 @@
 add_subdirectory(display)
 add_subdirectory(event)
 add_subdirectory(input)
-add_subdirectory(item)
 add_subdirectory(locale)
-add_subdirectory(map)
 add_subdirectory(system)
 add_subdirectory(scene)
-add_subdirectory(story)
 add_subdirectory(time)
 add_subdirectory(ui)

src/dusk/script/module/display/CMakeLists.txt

@@ -15,4 +15,5 @@ target_sources(${DUSK_LIBRARY_TARGET_NAME}
     modulescreen.c
     moduletileset.c
     moduletexture.c
+    moduleshader.c
 )

src/dusk/script/module/display/modulecamera.c

@@ -69,6 +69,16 @@ void moduleCamera(scriptcontext_t *context) {
 
   // Methods
   lua_register(context->luaState, "cameraCreate", moduleCameraCreate);
+  lua_register(
+    context->luaState,
+    "cameraGetProjectionMatrix",
+    moduleCameraGetProjectionMatrix
+  );
+  lua_register(
+    context->luaState,
+    "cameraGetViewMatrix",
+    moduleCameraGetViewMatrix
+  );
 }
 
 int moduleCameraCreate(lua_State *L) {
@@ -116,7 +126,7 @@ int moduleCameraCreate(lua_State *L) {
   return 1;
 }
 
-  int moduleCameraIndex(lua_State *l) {
+int moduleCameraIndex(lua_State *l) {
   assertNotNull(l, "Lua state cannot be NULL.");
 
   const char_t *key = luaL_checkstring(l, 2);
@@ -288,4 +298,36 @@ int moduleCameraNewIndex(lua_State *l) {
   }
 
   return 0;
+}
+
+int moduleCameraGetProjectionMatrix(lua_State *L) {
+  assertNotNull(L, "Lua state cannot be NULL.");
+
+  camera_t *cam = (camera_t *)luaL_checkudata(L, 1, "camera_mt");
+  assertNotNull(cam, "Camera pointer cannot be NULL.");
+
+  // Create mat4
+  mat4 test;
+  cameraGetProjectionMatrix(cam, test);
+
+  // Lua needs to own this matrix now
+  mat4 *m = (mat4 *)lua_newuserdata(L, sizeof(mat4));
+  memoryCopy(m, test, sizeof(mat4));
+  return 1;
+}
+
+int moduleCameraGetViewMatrix(lua_State *L) {
+  assertNotNull(L, "Lua state cannot be NULL.");
+
+  camera_t *cam = (camera_t *)luaL_checkudata(L, 1, "camera_mt");
+  assertNotNull(cam, "Camera pointer cannot be NULL.");
+
+  // Create mat4
+  mat4 test;
+  cameraGetViewMatrix(cam, test);
+
+  // Lua needs to own this matrix now
+  mat4 *m = (mat4 *)lua_newuserdata(L, sizeof(mat4));
+  memoryCopy(m, test, sizeof(mat4));
+  return 1;
 }

src/dusk/script/module/display/modulecamera.h

@@ -35,4 +35,20 @@ int moduleCameraIndex(lua_State *l);
  *
  * @param l The Lua state.
  */
-int moduleCameraNewIndex(lua_State *l);
+int moduleCameraNewIndex(lua_State *l);
+
+/**
+ * Script binding for getting a camera's projection matrix.
+ * 
+ * @param L The Lua state.
+ * @return Number of return values on the Lua stack.
+ */
+int moduleCameraGetProjectionMatrix(lua_State *L);
+
+/**
+ * Script binding for getting a camera's view matrix.
+ * 
+ * @param L The Lua state.
+ * @return Number of return values on the Lua stack.
+ */
+int moduleCameraGetViewMatrix(lua_State *L);

src/dusk/script/module/display/moduleshader.c

@@ -0,0 +1,120 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "moduleshader.h"
+#include "assert/assert.h"
+#include "display/shader/shader.h"
+#include "display/shader/shaderunlit.h"
+#include "display/camera/camera.h"
+
+void moduleShader(scriptcontext_t *context) {
+  assertNotNull(context, "Context cannot be NULL.");
+
+  // Shader unlit defs
+  lua_pushlightuserdata(context->luaState, &SHADER_UNLIT);
+  lua_setglobal(context->luaState, "SHADER_UNLIT");
+
+  lua_pushstring(context->luaState, SHADER_UNLIT_PROJECTION);
+  lua_setglobal(context->luaState, "SHADER_UNLIT_PROJECTION");
+  lua_pushstring(context->luaState, SHADER_UNLIT_VIEW);
+  lua_setglobal(context->luaState, "SHADER_UNLIT_VIEW");
+  lua_pushstring(context->luaState, SHADER_UNLIT_MODEL);
+  lua_setglobal(context->luaState, "SHADER_UNLIT_MODEL");
+  lua_pushstring(context->luaState, SHADER_UNLIT_TEXTURE);
+  lua_setglobal(context->luaState, "SHADER_UNLIT_TEXTURE");
+
+  // Shader methods
+  lua_register(context->luaState, "shaderBind", moduleShaderBind);
+  lua_register(context->luaState, "shaderSetMatrix", moduleShaderSetMatrix);
+  lua_register(context->luaState, "shaderSetTexture", moduleShaderSetTexture);
+}
+
+int moduleShaderBind(lua_State *l) {
+  assertNotNull(l, "Lua state cannot be NULL.");
+
+  // Should be passed a shader userdata pointer only.
+  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
+  assertNotNull(shader, "Shader pointer cannot be NULL.");
+
+  errorret_t ret = shaderBind(shader);
+  if(ret.code != ERROR_OK) {
+    luaL_error(l, "Failed to bind shader: %s", ret.state->message);
+    errorCatch(errorPrint(ret));
+    return 0;
+  }
+
+  return 0;
+}
+
+int moduleShaderSetMatrix(lua_State *l) {
+  assertNotNull(l, "Lua state cannot be NULL.");
+
+  // Expect shader, string and matrix.
+  if(!lua_isuserdata(l, 1)) {
+    luaL_error(l, "First argument must be a shader_mt userdata.");
+    return 0;
+  }
+
+  if(!lua_isstring(l, 2)) {
+    luaL_error(l, "Second argument must be a string.");
+    return 0;
+  }
+
+  if(!lua_isuserdata(l, 3)) {
+    luaL_error(l, "Third argument must be a mat4_mt userdata.");
+    return 0;
+  }
+
+  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
+  assertNotNull(shader, "Shader pointer cannot be NULL.");
+
+  const char_t *uniformName = luaL_checkstring(l, 2);
+  assertStrLenMin(uniformName, 1, "Uniform name cannot be empty.");
+
+  mat4 *mat = (mat4 *)lua_touserdata(l, 3);
+  assertNotNull(mat, "Matrix pointer cannot be NULL.");
+
+  errorret_t ret = shaderSetMatrix(shader, uniformName, *mat);
+  if(ret.code != ERROR_OK) {
+    luaL_error(l, "Failed to set shader matrix: %s", ret.state->message);
+    errorCatch(errorPrint(ret));
+    return 0;
+  }
+
+  return 0;
+}
+
+int moduleShaderSetTexture(lua_State *l) {
+  assertNotNull(l, "Lua state cannot be NULL.");
+
+  shader_t *shader = (shader_t *)lua_touserdata(l, 1);
+  assertNotNull(shader, "Shader pointer cannot be NULL.");
+
+  const char_t *uniformName = luaL_checkstring(l, 2);
+  assertStrLenMin(uniformName, 1, "Uniform name cannot be empty.");
+
+  texture_t *texture;
+  // Texture can be Nil or a pointer, if not nil it must be a texture pointer.
+  if(lua_isnil(l, 3)) {
+    texture = NULL;
+  } else if(lua_isuserdata(l, 3)) {
+    texture = (texture_t *)lua_touserdata(l, 3);
+    assertNotNull(texture, "Texture pointer cannot be NULL.");
+  } else {
+    luaL_error(l, "Third argument must be a texture_mt userdata or nil.");
+    return 0;
+  }
+
+  errorret_t ret = shaderSetTexture(shader, uniformName, texture);
+  if(ret.code != ERROR_OK) {
+    luaL_error(l, "Failed to set shader texture: %s", ret.state->message);
+    errorCatch(errorPrint(ret));
+    return 0;
+  }
+
+  return 0;
+}

src/dusk/script/module/display/moduleshader.h

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "script/scriptcontext.h"
+
+/**
+ * Register shader functions to the given script context.
+ * 
+ * @param context The script context to register shader functions to.
+ */
+void moduleShader(scriptcontext_t *context);
+
+/**
+ * Script binding for binding a shader.
+ * 
+ * @param l The Lua state.
+ * @return Number of return values on the Lua stack.
+ */
+int moduleShaderBind(lua_State *l);
+
+/**
+ * Script binding for setting a matrix uniform in a shader.
+ * 
+ * @param l The Lua state.
+ * @return Number of return values on the Lua stack.
+ */
+int moduleShaderSetMatrix(lua_State *l);
+
+/**
+ * Script binding for setting a texture uniform in a shader.
+ * 
+ * @param l The Lua state.
+ * @return Number of return values on the Lua stack.
+ */
+int moduleShaderSetTexture(lua_State *l);
+
+errorret_t doThing();

src/dusk/script/module/display/moduletexture.c

@@ -6,9 +6,9 @@
  */
 
 #include "moduletexture.h"
-#include "asset/asset.h"
-#include "display/texture/texture.h"
 #include "assert/assert.h"
+#include "display/texture/texture.h"
+#include "asset/loader/display/assettextureloader.h"
 #include "util/memory.h"
 #include "util/string.h"
 
@@ -83,6 +83,11 @@ int moduleTextureLoad(lua_State *l) {
     luaL_error(l, "First argument must be a string filename.");
     return 0;
   }
+
+  if(!lua_isnumber(l, 2)) {
+    luaL_error(l, "Second argument must be a number format.");
+    return 0;
+  }
   
   const char_t *filename = lua_tostring(l, 1);
   assertNotNull(filename, "Filename cannot be NULL.");
@@ -92,7 +97,9 @@ int moduleTextureLoad(lua_State *l) {
   texture_t *tex = (texture_t *)lua_newuserdata(l, sizeof(texture_t));
   memoryZero(tex, sizeof(texture_t));
 
-  errorret_t ret = assetLoad(filename, tex);
+  textureformat_t format = (textureformat_t)lua_tonumber(l, 2);
+
+  errorret_t ret = assetTextureLoad(filename, tex, format);
   if(ret.code != ERROR_OK) {
     errorCatch(errorPrint(ret));
     luaL_error(l, "Failed to load texture asset: %s", filename);

src/dusk/script/module/locale/modulelocale.c

@@ -13,66 +13,87 @@ void moduleLocale(scriptcontext_t *context) {
   assertNotNull(context, "Script context cannot be NULL");
 
   // Execute the locale script definitions.
-  // scriptContextExec(context, LOCALE_SCRIPT);
-
-  // lua_register(context->luaState, "localeGet", moduleLocaleGet);
-  // lua_register(context->luaState, "localeSet", moduleLocaleSet);
-  // lua_register(context->luaState, "localeGetName", moduleLocaleGetName);
+  lua_register(context->luaState, "localeGetText", moduleLocaleGetText);
 }
 
-// int moduleLocaleGet(lua_State *L) {
-//   assertNotNull(L, "Lua state cannot be NULL");
+int moduleLocaleGetText(lua_State *L) {
+  // Expect string param for the id
+  if(!lua_isstring(L, 1)) {
+    luaL_error(L, "Expected message ID as first argument");
+    return 0;
+  }
 
-//   // No arguments expected
-//   dusklocale_t locale = LOCALE.locale;
-//   lua_pushnumber(L, (lua_Number)locale);
-//   return 1;
-// }
+  const char_t *id = lua_tostring(L, 1);
+  if(id == NULL || strlen(id) == 0) {
+    luaL_error(L, "Message ID cannot be NULL or empty");
+    return 0;
+  }
 
-// int moduleLocaleSet(lua_State *L) {
-//   assertNotNull(L, "Lua state cannot be NULL");
+  // Optional plural param, default to 0
+  int32_t plural = 0;
+  int top = lua_gettop(L);
+  int argStart = 2;
 
-//   // Requires locale ID
-//   if(!lua_isnumber(L, 1)) {
-//     luaL_error(L, "localeSet: Expected locale ID as first argument");
-//     return 0;
-//   }
+  if(top >= 2 && !lua_isnil(L, 2)) {
+    if(!lua_isnumber(L, 2)) {
+      luaL_error(L, "Expected plural as second argument");
+      return 0;
+    }
 
-//   errorret_t err;
-//   dusklocale_t locale = (dusklocale_t)lua_tonumber(L, 1);
-//   if(locale >= DUSK_LOCALE_COUNT || locale == DUSK_LOCALE_NULL) {
-//     luaL_error(L, "localeSet: Invalid locale ID");
-//     return 0;
-//   }
+    plural = (int32_t)lua_tointeger(L, 2);
+    if(plural < 0) {
+      luaL_error(L, "Plural cannot be negative");
+      return 0;
+    }
 
-//   err = localeManagerSetLocale(locale);
-//   if(err.code != ERROR_OK) {
-//     luaL_error(L, "localeSet: Failed to set locale");
-//     errorCatch(errorPrint(err));
-//     return 0;
-//   }
+    argStart = 3;
+  }
 
-//   return 0;
-// }
+  // Build structured arg list from remaining Lua args
+  size_t argCount = (top >= argStart) ? (size_t)(top - argStart + 1) : 0;
+  #define MODULE_LOCALE_MAX_ARGS 16
+  assetlocalearg_t argsStack[MODULE_LOCALE_MAX_ARGS];
+  assetlocalearg_t *args = argsStack;
 
-// int moduleLocaleGetName(lua_State *L) {
-//   assertNotNull(L, "Lua state cannot be NULL");
+  if(argCount > MODULE_LOCALE_MAX_ARGS) {
+    luaL_error(L, "Too many args (max %d)", MODULE_LOCALE_MAX_ARGS);
+    return 0;
+  }
 
-//   // Optional ID, otherwise return current locale name
-//   dusklocale_t locale = LOCALE.locale;
-//   if(lua_gettop(L) >= 1) {
-//     if(!lua_isnumber(L, 1)) {
-//       luaL_error(L, "localeGetName: Expected locale ID as first argument");
-//       return 0;
-//     }
-//     locale = (dusklocale_t)lua_tonumber(L, 1);
-//     if(locale >= DUSK_LOCALE_COUNT || locale == DUSK_LOCALE_NULL) {
-//       luaL_error(L, "localeGetName: Invalid locale ID");
-//       return 0;
-//     }
-//   }
+  for(size_t i = 0; i < argCount; ++i) {
+    int luaIndex = argStart + (int)i;
 
-//   const char_t *localeName = LOCALE_INFOS[locale].file;
-//   lua_pushstring(L, localeName);
-//   return 1;
-// }
+    if(lua_isinteger(L, luaIndex)) {
+      args[i].type = ASSET_LOCALE_ARG_INT;
+      args[i].intValue = (int32_t)lua_tonumber(L, luaIndex);
+    } else if(lua_isnumber(L, luaIndex)) {
+      args[i].type = ASSET_LOCALE_ARG_FLOAT;
+      args[i].floatValue = lua_tonumber(L, luaIndex);
+    } else if(lua_isstring(L, luaIndex)) {
+      args[i].type = ASSET_LOCALE_ARG_STRING;
+      args[i].stringValue = lua_tostring(L, luaIndex);
+    } else {
+      luaL_error(L, "Unsupported localization argument type");
+      return 0;
+    }
+  }
+
+  char_t buffer[1024];
+  errorret_t err = localeManagerGetTextArgs(
+    id,
+    buffer,
+    sizeof(buffer),
+    plural,
+    args,
+    argCount
+  );
+
+  if(err.code != ERROR_OK) {
+    errorCatch(errorPrint(err));
+    luaL_error(L, "Failed to get localized text for ID '%s'", id);
+    return 0;
+  }
+
+  lua_pushstring(L, buffer);
+  return 1;
+}

src/dusk/script/module/locale/modulelocale.h

@@ -16,25 +16,9 @@
 void moduleLocale(scriptcontext_t *context);
 
 /**
- * Script binding for getting the current locale ID.
+ * Script binding for getting a localized string.
  * 
  * @param L The Lua state.
- * @return Number of return values on the Lua stack.
+ * @return The number of return values on the Lua stack.
  */
-int moduleLocaleGet(lua_State *L);
-
-/**
- * Script binding for setting the current locale ID.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleLocaleSet(lua_State *L);
-
-/**
- * Script binding for getting the name of a locale by its ID.
- * 
- * @param L The Lua state.
- * @return Number of return values on the Lua stack.
- */
-int moduleLocaleGetName(lua_State *L);
+int moduleLocaleGetText(lua_State *L);

src/dusk/script/scriptcontext.c

@@ -11,6 +11,7 @@
 #include "util/memory.h"
 #include "script/scriptmodule.h"
 #include "event/event.h"
+#include "asset/loader/script/assetscriptloader.h"
 
 errorret_t scriptContextInit(scriptcontext_t *context) {
   assertNotNull(context, "Script context cannot be NULL");
@@ -53,26 +54,7 @@ errorret_t scriptContextExec(scriptcontext_t *context, const char_t *script) {
 errorret_t scriptContextExecFile(scriptcontext_t *ctx, const char_t *fname) {
   assertNotNull(ctx, "Script context cannot be NULL");
   assertNotNull(fname, "Filename cannot be NULL");
-  
-  assetscript_t script;
-  errorChain(assetLoad(fname, &script));
-
-  if(lua_load(
-    ctx->luaState, assetScriptReader, &script, fname, NULL
-  ) != LUA_OK) {
-    const char_t *strErr = lua_tostring(ctx->luaState, -1);
-    lua_pop(ctx->luaState, 1);
-    errorThrow("Failed to load Lua script: %s", strErr);
-  }
-
-  if(lua_pcall(ctx->luaState, 0, LUA_MULTRET, 0) != LUA_OK) {
-    const char_t *strErr = lua_tostring(ctx->luaState, -1);
-    lua_pop(ctx->luaState, 1);
-    errorThrow("Failed to execute Lua script: %s", strErr);
-  }
-
-  errorChain(assetScriptDispose(&script));
-  errorOk();
+  return assetScriptLoad(fname, ctx);
 }
 
 void scriptContextDispose(scriptcontext_t *context) {

src/dusk/script/scriptmodule.c

@@ -10,7 +10,6 @@
 #include "script/module/input/moduleinput.h"
 #include "script/module/moduleplatform.h"
 #include "script/module/scene/modulescene.h"
-#include "script/module/item/moduleitem.h"
 #include "script/module/locale/modulelocale.h"
 #include "script/module/time/moduletime.h"
 #include "script/module/event/moduleevent.h"
@@ -18,13 +17,13 @@
 #include "script/module/display/modulespritebatch.h"
 #include "script/module/display/modulecamera.h"
 #include "script/module/display/moduleglm.h"
+#include "script/module/display/moduleshader.h"
 #include "script/module/ui/moduleui.h"
 #include "script/module/display/moduletext.h"
 #include "script/module/display/modulescreen.h"
-#include "script/module/story/modulestoryflag.h"
-#include "script/module/map/modulemap.h"
 #include "script/module/display/moduletexture.h"
 #include "script/module/display/moduletileset.h"
+#include "script/scriptgame.h"
 #include "util/string.h"
 
 const scriptmodule_t SCRIPT_MODULE_LIST[] = {
@@ -33,7 +32,6 @@ const scriptmodule_t SCRIPT_MODULE_LIST[] = {
   { .name = "platform", .callback = modulePlatform },
   { .name = "color", .callback = moduleColor },
   { .name = "scene", .callback = moduleScene },
-  { .name = "item", .callback = moduleItem },
   { .name = "locale", .callback = moduleLocale },
   { .name = "time", .callback = moduleTime },
   { .name = "event", .callback = moduleEvent },
@@ -43,10 +41,13 @@ const scriptmodule_t SCRIPT_MODULE_LIST[] = {
   { .name = "ui", .callback = moduleUi },
   { .name = "text", .callback = moduleText },
   { .name = "screen", .callback = moduleScreen },
-  { .name = "storyflag", .callback = moduleStoryFlag },
-  { .name = "map", .callback = moduleMap },
   { .name = "texture", .callback = moduleTexture },
   { .name = "tileset", .callback = moduleTileset },
+  { .name = "shader", .callback = moduleShader },
+
+  #ifdef SCRIPT_GAME_LIST
+    SCRIPT_GAME_LIST
+  #endif
 };
 
 #define SCRIPT_MODULE_COUNT ( \

src/dusk/util/memory.c

@@ -82,7 +82,7 @@ int_t memoryCompare(
 ) {
   assertNotNull(a, "Cannot compare NULL memory.");
   assertNotNull(b, "Cannot compare NULL memory.");
-  assertTrue(size > 0, "Cannot compare 0 bytes of memory.");
+  assertTrue(size >= 0, "Cannot compare negative bytes of memory.");
   return memcmp(a, b, size);
 }
 

src/duskdolphin/display/camera/cameradolphin.c

@@ -11,6 +11,10 @@
 
 void cameraPushMatrixDolphin(camera_t *camera) {
   assertNotNull(camera, "Camera cannot be null");
+  assertTrue(
+    camera->nearClip > 0.0f,
+    "Camera near clip must be greater than 0 for Dolphin"
+  );
 
   Mtx44 guProjection;
   Mtx guView;

src/duskdolphin/display/displaydolphin.c

@@ -77,7 +77,8 @@ errorret_t displayInitDolphin(void) {
 
   // Setup cull modes
   GX_SetCullMode(GX_CULL_NONE);
-  GX_SetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
+  GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+  GX_SetZMode(GX_TRUE, GX_ALWAYS, GX_FALSE);
   GX_SetDispCopyGamma(GX_GM_1_0);
   GX_SetColorUpdate(GX_TRUE);
 

src/duskdolphin/display/mesh/meshdolphin.c

@@ -60,6 +60,8 @@ errorret_t meshDrawDolphin(
   GX_SetArray(GX_VA_CLR0, (void*)&mesh->vertices[vertexOffset].color.r, stride);
   GX_SetArray(GX_VA_TEX0, (void*)&mesh->vertices[vertexOffset].uv[0], stride);
   
+  GX_InvVtxCache();
+  
   GX_Begin(mesh->primitiveType, GX_VTXFMT0, (uint16_t)vertexCount);
   for(uint16_t i = 0; i < (uint16_t)vertexCount; ++i) {
     GX_Position1x16(i);

src/duskgl/display/camera/cameragl.c

@@ -59,7 +59,7 @@ void cameraPushMatrixGL(camera_t *camera) {
 
   switch(camera->viewType) {
     case CAMERA_VIEW_TYPE_MATRIX:
-      glm_mat4_copy(camera->view, view);
+      glm_mat4_ucopy(camera->view, view);
       break;
 
     case CAMERA_VIEW_TYPE_LOOKAT:

src/duskgl/display/displaygl.c

@@ -11,13 +11,6 @@ errorret_t displayOpenGLInit(void) {
   glDisable(GL_CULL_FACE);
   errorChain(errorGLCheck());
 
-  #if DUSK_OPENGL_LEGACY
-    glDisable(GL_LIGHTING);// PSP defaults this on?
-    errorChain(errorGLCheck());
-    glShadeModel(GL_SMOOTH); // Fixes color on PSP?
-    errorChain(errorGLCheck());
-  #endif
-
   glEnable(GL_DEPTH_TEST);
   errorChain(errorGLCheck());
   glDepthFunc(GL_LEQUAL);
@@ -32,5 +25,12 @@ errorret_t displayOpenGLInit(void) {
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   errorChain(errorGLCheck());
 
+  #if DUSK_OPENGL_LEGACY
+    glDisable(GL_LIGHTING);// PSP defaults this on?
+    errorChain(errorGLCheck());
+    glShadeModel(GL_SMOOTH); // Fixes color on PSP?
+    errorChain(errorGLCheck());
+  #endif
+
   errorOk();
 }

src/duskgl/display/mesh/meshgl.c

@@ -113,8 +113,10 @@ errorret_t meshFlushGL(
     errorChain(errorGLCheck());
     glBufferData(
       GL_ARRAY_BUFFER,
-      vertCount * sizeof(meshvertex_t),
-      &mesh->vertices[vertOffset],
+      mesh->vertexCount * sizeof(meshvertex_t),
+      mesh->vertices,
+      // vertCount * sizeof(meshvertex_t),
+      // &mesh->vertices[vertOffset],
       GL_DYNAMIC_DRAW
     );
     errorChain(errorGLCheck());

src/duskgl/display/shader/shadergl.c

@@ -157,11 +157,10 @@ errorret_t shaderParamGetLocationGL(
   #ifdef DUSK_OPENGL_LEGACY
     assertUnreachable("Cannot get uniform locations on legacy opengl.");
   #else
-    shadergl_t *shaderGL = (shadergl_t *)shader;
-    *location = glGetUniformLocation(shaderGL->shaderProgramId, name);
-    errorret_t err = errorGLCheck();
-    if(err.code != ERROR_OK) {
-      errorChain(err);
+    *location = glGetUniformLocation(shader->shaderProgramId, name);
+    errorChain(errorGLCheck());
+    if(*location == -1) {
+      errorThrow("Uniform '%s' not found in shader.", name);
     }
   #endif
   
@@ -174,25 +173,26 @@ errorret_t shaderSetMatrixGL(
   mat4 mat
 ) {
   assertNotNull(shader, "Shader cannot be null");
-  assertNotNull(mat, "Matrix data cannot be null");
   assertStrLenMin(name, 1, "Uniform name cannot be empty");
+  assertNotNull(mat, "Matrix data cannot be null");
 
   #ifdef DUSK_OPENGL_LEGACY
     assertTrue(
       SHADER_LEGACY.boundShader == shader,
       "Shader must be bound to set legacy matrices."
     );
+    // Use unaligned copy to safely handle possibly unaligned input matrices
     if(stringCompare(name, SHADER_UNLIT_PROJECTION) == 0) {
       SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_PROJ;
-      glm_mat4_copy(mat, shader->proj);
+      glm_mat4_ucopy(mat, shader->proj);
 
     } else if(stringCompare(name, SHADER_UNLIT_VIEW) == 0) {
       SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_VIEW;
-      glm_mat4_copy(mat, shader->view);
+      glm_mat4_ucopy(mat, shader->view);
 
     } else if(stringCompare(name, SHADER_UNLIT_MODEL) == 0) {
       SHADER_LEGACY.dirty |= SHADER_LEGACY_DIRTY_MODEL;
-      glm_mat4_copy(mat, shader->model);
+      glm_mat4_ucopy(mat, shader->model);
       
     } else {
       assertUnreachable("Cannot use a custom matrix on legacy opengl.");
@@ -233,6 +233,8 @@ errorret_t shaderSetTextureGL(
     errorChain(errorGLCheck());
     glBindTexture(GL_TEXTURE_2D, texture->id);
     errorChain(errorGLCheck());
+    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+    errorChain(errorGLCheck());
 
   #else
     if(shader->setTexture == NULL) {

src/duskgl/display/shader/shaderunlitgl.c

@@ -122,7 +122,7 @@
         // Uniforms
         "uniform sampler2D u_Texture;\n"
         "uniform int u_TextureType;\n"
-        "uniform vec4 u_Colors[256];\n"// For paletted textures.
+        "uniform uint u_Colors[256];\n"// For paletted textures.
         "uniform int u_ColorCount;\n"
         // Fragment shader inputs
         "in vec4 v_Color;\n"
@@ -140,8 +140,13 @@
         "  }\n"
         "  if(u_TextureType == 2) {\n"// Paletted texture
         "    vec4 texColor = texture(u_Texture, v_TexCoord);\n"
-        "    int index = int(floor(texColor.r * 255.0));\n"
-        "    vec4 paletteColor = u_Colors[index];\n"
+        "    uint index = uint(floor(texColor.r * 255.0));\n"
+        "    uint palColor = u_Colors[index];\n"
+        "    float r = float((palColor >> 24) & 0xFFu) / 255.0;\n"
+        "    float g = float((palColor >> 16) & 0xFFu) / 255.0;\n"
+        "    float b = float((palColor >> 8)  & 0xFFu) / 255.0;\n"
+        "    float a = float((palColor >> 0)  & 0xFFu) / 255.0;\n"
+        "    vec4 paletteColor = vec4(r, g, b, a);\n"
         "    FragColor = paletteColor;\n"
         "    return;\n"
         "  }\n"

src/duskgl/display/texture/texturegl.c

@@ -77,10 +77,6 @@ errorret_t textureInitGL(
   errorChain(errorGLCheck());
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   errorChain(errorGLCheck());
-
-  #ifdef DUSK_OPENGL_LEGACY
-    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
-  #endif
   
   glBindTexture(GL_TEXTURE_2D, 0);
   errorChain(errorGLCheck());

src/duskgl/duskgl.h

@@ -20,9 +20,6 @@
   #define glClearDepth(depth) glClearDepthf(depth)
 #else
   #define GL_GLEXT_PROTOTYPES
-  #include <vitaGL.h>
-
-  #define GL_COLOR_INDEX8_EXT 0x80E5
-
-  // #include <GL/glext.h>
+  #include <GL/gl.h>
+  #include <GL/glext.h>
 #endif

src/duskrpg/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Includes
+target_include_directories(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Subdirs
+add_subdirectory(item)
+add_subdirectory(map)
+add_subdirectory(story)
+add_subdirectory(script)