Add some script modules

This reverts commit efd31237be.

.github/workflows/build.yml

@@ -53,6 +53,22 @@ jobs:
           path: ./git-artifcats/Dusk
           if-no-files-found: error
 
+  # build-vita:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - name: Checkout repository
+  #       uses: actions/checkout@v6
+  #     - name: Set up Docker
+  #       uses: docker/setup-docker-action@v5
+  #     - name: Build Vita
+  #       run: ./scripts/build-vita-docker.sh
+  #     - name: Upload Vita binary
+  #       uses: actions/upload-artifact@v6
+  #       with:
+  #         name: dusk-vita
+  #         path: build-vita/Dusk.vpk
+  #         if-no-files-found: error
+
   build-knulli:
     runs-on: ubuntu-latest
     steps:
@@ -94,6 +110,28 @@ jobs:
           path: ./git-artifcats/Dusk
           if-no-files-found: error
 
+  build-gamecube-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build GameCube ISO
+        run: ./scripts/build-gamecube-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-gamecube-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-gamecube-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-gamecube-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload GameCube ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-gamecube-iso
+          path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
   build-wii:
     runs-on: ubuntu-latest
     steps:
@@ -106,12 +144,34 @@ jobs:
       - name: Copy output files.
         run: |
           mkdir -p ./git-artifcats/Dusk/apps/Dusk
-          cp build-wii/Dusk.dol ./git-artifcats/Dusk/apps/Dusk/boot.dol
+          cp build-wii/boot.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
+          cp build-wii/meta.xml ./git-artifcats/Dusk/apps/Dusk/meta.xml
       - name: Upload Wii binary
         uses: actions/upload-artifact@v6
         with:
           name: dusk-wii
           path: ./git-artifcats/Dusk
+          if-no-files-found: error
+
+  build-wii-iso:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+      - name: Set up Docker
+        uses: docker/setup-docker-action@v5
+      - name: Build Wii ISO
+        run: ./scripts/build-wii-iso-docker.sh
+      - name: Copy output files.
+        run: |
+          mkdir -p ./git-artifcats/Dusk
+          cp build-wii-iso/Dusk-NTSC-J.iso ./git-artifcats/Dusk/Dusk-NTSC-J.iso
+          cp build-wii-iso/Dusk-NTSC-U.iso ./git-artifcats/Dusk/Dusk-NTSC-U.iso
+          cp build-wii-iso/Dusk-PAL.iso    ./git-artifcats/Dusk/Dusk-PAL.iso
+      - name: Upload Wii ISO
+        uses: actions/upload-artifact@v6
+        with:
+          name: dusk-wii-iso
+          path: ./git-artifcats/Dusk
           if-no-files-found: error

.gitignore

@@ -83,7 +83,6 @@ assets/borrowed
 .VSCode*
 
 /vita
-
 ._*
 
 *~
@@ -104,4 +103,7 @@ yarn.lock
 .venv
 
 /build2
-/build*
+/build*
+/assets/test
+/tools_old
+/assets/test.png

CMakeLists.txt

@@ -4,14 +4,22 @@
 # https://opensource.org/licenses/MIT
 
 # Setup
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.13)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
+cmake_policy(SET CMP0079 NEW)
+# set(FETCHCONTENT_UPDATES_DISCONNECTED ON)
 
 option(DUSK_BUILD_TESTS "Enable tests" OFF)
 
+# Game identity — override these per-project
+set(DUSK_GAME_NAME              "Dusk"               CACHE STRING "Game display name")
+set(DUSK_GAME_AUTHOR            "YouWish"             CACHE STRING "Game author / coder")
+set(DUSK_GAME_SHORT_DESCRIPTION "Dusk game"           CACHE STRING "One-line description")
+set(DUSK_GAME_LONG_DESCRIPTION  "No description yet." CACHE STRING "Full description")
+
 # Prep cache
 set(DUSK_CACHE_TARGET "dusk-target")
 
@@ -68,10 +76,19 @@ else()
   set(DUSK_LIBRARY_TARGET_NAME "${DUSK_BINARY_TARGET_NAME}" CACHE INTERNAL ${DUSK_CACHE_TARGET})
 endif()
 
+if(NOT DEFINED DUSK_VERSION)
+  string(TIMESTAMP DUSK_VERSION "debug-%y%m%d%H%M%S")
+endif()
+
 # Definitions
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
     DUSK_TARGET_SYSTEM="${DUSK_TARGET_SYSTEM}"
+    DUSK_GAME_NAME="${DUSK_GAME_NAME}"
+    DUSK_GAME_AUTHOR="${DUSK_GAME_AUTHOR}"
+    DUSK_GAME_SHORT_DESCRIPTION="${DUSK_GAME_SHORT_DESCRIPTION}"
+    DUSK_GAME_LONG_DESCRIPTION="${DUSK_GAME_LONG_DESCRIPTION}"
+    DUSK_VERSION="${DUSK_VERSION}"
 )
 
 # Toolchains

archive/camera/camera.c

@@ -35,8 +35,8 @@ 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->orthographic.top = SCREEN.height;
+  camera->orthographic.bottom = 0.0f;
   camera->nearClip = 0.1f;
   camera->farClip = 1.0f;
 

archive/camera/camera.h

@@ -14,11 +14,6 @@
   #error "cameraPushMatrixPlatform must be defined"
 #endif
 
-typedef enum {
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE,
-  CAMERA_PROJECTION_TYPE_PERSPECTIVE_FLIPPED,
-  CAMERA_PROJECTION_TYPE_ORTHOGRAPHIC
-} cameraprojectiontype_t;
 
 typedef enum {
   CAMERA_VIEW_TYPE_MATRIX,

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/rpg/item/inventory.h

@@ -1,13 +0,0 @@
-/**
- * Copyright (c) 2025 Dominic Masters
- * 
- * This software is released under the MIT License.
- * https://opensource.org/licenses/MIT
- */
-
-#pragma once
-#include "dusk.h"
-
-typedef struct {
-  void *nothing;
-} inventory_t;

assets/init.js

@@ -0,0 +1,12 @@
+Console.print('This is called from JavaScript');
+
+const platformNames = {
+  [System.PLATFORM_LINUX]:    'Linux',
+  [System.PLATFORM_KNULLI]:   'Knulli',
+  [System.PLATFORM_PSP]:      'PSP',
+  [System.PLATFORM_GAMECUBE]: 'GameCube',
+  [System.PLATFORM_WII]:      'Wii',
+};
+
+const platformName = platformNames[System.platform] || 'Unknown';
+Console.print('Platform: ' + platformName);

assets/init.lua

@@ -1,78 +0,0 @@
-module('input')
-module('platform')
-module('scene')
-module('locale')
-
--- Default Input bindings.
-if PSP then
-  inputBind("up", INPUT_ACTION_UP)
-  inputBind("down", INPUT_ACTION_DOWN)
-  inputBind("left", INPUT_ACTION_LEFT)
-  inputBind("right", INPUT_ACTION_RIGHT)
-  inputBind("circle", INPUT_ACTION_CANCEL)
-  inputBind("cross", INPUT_ACTION_ACCEPT)
-  inputBind("select", INPUT_ACTION_RAGEQUIT)
-  inputBind("lstick_up", INPUT_ACTION_UP)
-  inputBind("lstick_down", INPUT_ACTION_DOWN)
-  inputBind("lstick_left", INPUT_ACTION_LEFT)
-  inputBind("lstick_right", INPUT_ACTION_RIGHT)
-
-elseif DOLPHIN then
-  inputBind("up", INPUT_ACTION_UP)
-  inputBind("down", INPUT_ACTION_DOWN)
-  inputBind("left", INPUT_ACTION_LEFT)
-  inputBind("right", INPUT_ACTION_RIGHT)
-  inputBind("b", INPUT_ACTION_CANCEL)
-  inputBind("a", INPUT_ACTION_ACCEPT)
-  inputBind("z", INPUT_ACTION_RAGEQUIT)
-  inputBind("lstick_up", INPUT_ACTION_UP)
-  inputBind("lstick_down", INPUT_ACTION_DOWN)
-  inputBind("lstick_left", INPUT_ACTION_LEFT)
-  inputBind("lstick_right", INPUT_ACTION_RIGHT)
-
-elseif LINUX then
-  if INPUT_KEYBOARD then
-    inputBind("w", INPUT_ACTION_UP)
-    inputBind("s", INPUT_ACTION_DOWN)
-    inputBind("a", INPUT_ACTION_LEFT)
-    inputBind("d", INPUT_ACTION_RIGHT)
-
-    inputBind("left", INPUT_ACTION_LEFT)
-    inputBind("right", INPUT_ACTION_RIGHT)
-    inputBind("up", INPUT_ACTION_UP)
-    inputBind("down", INPUT_ACTION_DOWN)
-
-    inputBind("enter", INPUT_ACTION_ACCEPT)
-    inputBind("e", INPUT_ACTION_ACCEPT)
-    
-    inputBind("q", INPUT_ACTION_CANCEL)
-    
-    inputBind("escape", INPUT_ACTION_RAGEQUIT)
-  end
-
-  if INPUT_GAMEPAD then
-    inputBind("gamepad_up", INPUT_ACTION_UP)
-    inputBind("gamepad_down", INPUT_ACTION_DOWN)
-    inputBind("gamepad_left", INPUT_ACTION_LEFT)
-    inputBind("gamepad_right", INPUT_ACTION_RIGHT)
-
-    inputBind("gamepad_a", INPUT_ACTION_ACCEPT)
-    inputBind("gamepad_b", INPUT_ACTION_CANCEL)
-    inputBind("gamepad_back", INPUT_ACTION_RAGEQUIT)
-
-    inputBind("gamepad_lstick_up", INPUT_ACTION_UP)
-    inputBind("gamepad_lstick_down", INPUT_ACTION_DOWN)
-    inputBind("gamepad_lstick_left", INPUT_ACTION_LEFT)
-    inputBind("gamepad_lstick_right", INPUT_ACTION_RIGHT)
-  end
-
-  if INPUT_POINTER 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')

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/minesweeper.lua

@@ -1,264 +0,0 @@
-module('spritebatch')
-module('camera')
-module('color')
-module('ui')
-module('screen')
-module('time')
-module('glm')
-module('text')
-module('tileset')
-module('texture')
-module('input')
-module('shader')
-
-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(
-    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
-  camera.bottom = 0
-  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(
-    x, y,
-    x + 32, y + 32,
-    colorWhite()
-  )
-  spriteBatchFlush()
-
-  textDraw(10, 10, "Hello World\nHow are you?", colorRed())
-  spriteBatchFlush()
-
-  -- 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
-end

assets/testentity.js

@@ -0,0 +1,24 @@
+// Load rosa.
+Console.print('Asset time');
+const entry = Asset.lock('test.png', Asset.TYPE_TEXTURE, Texture.FORMAT_RGBA);
+Asset.requireLoaded(entry);
+Console.print('Asset loaded');
+
+// Camera at (3,3,3) looking at origin
+const cam = Entity.create();
+const camPos = cam.add(Component.POSITION);
+cam.add(Component.CAMERA);
+camPos.localPosition = new Vec3(3, 3, 3);
+camPos.lookAt(new Vec3(0, 0, 0));
+
+// Test entity at origin
+const testEntity = Entity.create();
+const testPos = testEntity.add(Component.POSITION);
+
+/** @type {RenderableSpritebatch} */
+const testRenderable = testEntity.add(Component.RENDERABLE);
+testRenderable.texture = entry.texture;
+testRenderable.sprites = [
+  [0, 0, 1, 1, 0, 1, 1, 0]
+];
+testPos.localPosition = new Vec3(0, 0, 0);

assets/ui/test.js

@@ -0,0 +1,6 @@
+module = {
+  render() {
+    Text.draw(0, 0, "Hello World");
+    SpriteBatch.flush();
+  }
+};

cmake/modules/Findjerryscript.cmake

@@ -0,0 +1,96 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Turn things off we don't need
+set(JERRY_CMDLINE OFF CACHE BOOL "" FORCE)
+set(JERRY_EXT ON CACHE BOOL "" FORCE)
+set(JERRY_DEBUGGER OFF CACHE BOOL "" FORCE)
+set(JERRY_BUILTIN_DATE OFF CACHE BOOL "" FORCE)
+set(ENABLE_LTO OFF CACHE BOOL "" FORCE)
+
+# Fetch Jerry
+include(FetchContent)
+FetchContent_Declare(
+  jerryscript
+  GIT_REPOSITORY https://git.wish.moe/YourWishes/jerryscript
+  GIT_TAG float32-fix
+)
+FetchContent_MakeAvailable(jerryscript)
+
+# Mark found
+set(jerryscript_FOUND ON)
+
+# Define targets
+if(TARGET jerryscript-core)
+  set(JERRY_CORE_TARGET jerryscript-core)
+elseif(TARGET jerry-core)
+  set(JERRY_CORE_TARGET jerry-core)
+endif()
+
+if(TARGET jerryscript-ext)
+  set(JERRY_EXT_TARGET jerryscript-ext)
+elseif(TARGET jerry-ext)
+  set(JERRY_EXT_TARGET jerry-ext)
+endif()
+
+if(TARGET jerryscript-port-default)
+  set(JERRY_PORT_TARGET jerryscript-port-default)
+elseif(TARGET jerry-port-default)
+  set(JERRY_PORT_TARGET jerry-port-default)
+elseif(TARGET jerryscript-port)
+  set(JERRY_PORT_TARGET jerryscript-port)
+elseif(TARGET jerry-port)
+  set(JERRY_PORT_TARGET jerry-port)
+endif()
+
+if(NOT JERRY_CORE_TARGET)
+  message(FATAL_ERROR "JerryScript core target not found")
+endif()
+
+if(NOT JERRY_EXT_TARGET)
+  message(FATAL_ERROR "JerryScript ext target not found")
+endif()
+
+if(NOT JERRY_PORT_TARGET)
+  message(FATAL_ERROR "JerryScript port target not found")
+endif()
+
+foreach(tgt IN ITEMS
+  ${JERRY_CORE_TARGET}
+  ${JERRY_EXT_TARGET}
+  ${JERRY_PORT_TARGET}
+)
+  if(TARGET ${tgt})
+    set_property(TARGET ${tgt} PROPERTY INTERPROCEDURAL_OPTIMIZATION OFF)
+    target_compile_definitions(${JERRY_CORE_TARGET} PRIVATE
+      JERRY_NUMBER_TYPE_FLOAT64=0
+      JERRY_BUILTIN_DATE=0
+    )
+  endif()
+endforeach()
+
+# Export include dirs through the targets
+target_include_directories(${JERRY_CORE_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-core/include
+)
+
+target_include_directories(${JERRY_EXT_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-ext/include
+)
+
+target_include_directories(${JERRY_PORT_TARGET} INTERFACE
+  ${jerryscript_SOURCE_DIR}/jerry-port/default/include
+)
+
+# Suppress JerryScript-only warning
+if(CMAKE_C_COMPILER_ID MATCHES "GNU|Clang")
+  target_compile_options(${JERRY_CORE_TARGET} PRIVATE
+    -Wno-error
+  )
+endif()
+
+add_library(jerryscript::core ALIAS ${JERRY_CORE_TARGET})
+add_library(jerryscript::ext ALIAS ${JERRY_EXT_TARGET})
+add_library(jerryscript::port ALIAS ${JERRY_PORT_TARGET})

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

@@ -1,61 +1,70 @@
+# Build type: FAT (SD/USB via libfat) or ISO (DVD disc via libogc DVD driver)
+set(DUSK_DOLPHIN_BUILD_TYPE "FAT" CACHE STRING "Dolphin asset source: FAT (SD/USB) or ISO (DVD disc)")
+set_property(CACHE DUSK_DOLPHIN_BUILD_TYPE PROPERTY STRINGS "FAT" "ISO")
+
 # Target definitions
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_DOLPHIN
   DUSK_INPUT_GAMEPAD
   DUSK_DISPLAY_WIDTH=640
   DUSK_DISPLAY_HEIGHT=480
+  DUSK_THREAD_PTHREAD
+  DUSK_DOLPHIN_BUILD_TYPE="${DUSK_DOLPHIN_BUILD_TYPE}"
 )
 
 # Custom compiler flags
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti -fno-exceptions")
 
-# Need PkgConfig
-find_package(PkgConfig REQUIRED)
-pkg_check_modules(zip IMPORTED_TARGET libzip)
-
 # Disable all warnings
 target_compile_options(${DUSK_LIBRARY_TARGET_NAME} PRIVATE -w)
 
-# Custom flags for cglm
-set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
-set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
+# cglm: fetched at source level via Findcglm.cmake (FetchContent, headers only)
 find_package(cglm REQUIRED)
 
-# 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)
+# Pre-create ZLIB::ZLIB so any downstream cmake module that resolves it
+# (FindZLIB, pkg-config IMPORTED_TARGET Requires processing) gets plain -lz
+# rather than an unresolvable IMPORTED target that the PPC linker rejects.
+if(NOT TARGET ZLIB::ZLIB)
+  add_library(ZLIB::ZLIB INTERFACE IMPORTED GLOBAL)
+  set_target_properties(ZLIB::ZLIB PROPERTIES INTERFACE_LINK_LIBRARIES "z")
+endif()
 
-# Link libraries
+# Mark libzip as found so src/dusk/CMakeLists.txt skips Findlibzip.cmake.
+# Findlibzip.cmake calls find_package(ZLIB) which can recreate a broken
+# ZLIB::ZLIB IMPORTED target, bypassing the shim above.
+set(libzip_FOUND TRUE CACHE BOOL "libzip found (devkitpro portlibs)" FORCE)
+
+# Locate zip.h in the devkitpro sysroot (respects CMAKE_FIND_ROOT_PATH).
+find_path(_dusk_zip_inc NAMES zip.h)
+if(_dusk_zip_inc)
+  target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE "${_dusk_zip_inc}")
+endif()
+
+# Link libraries.
+# zip/z/lzma use target_link_options (raw flags) to bypass cmake target
+# resolution — pkg-config-generated targets for these carry ZLIB::ZLIB in
+# INTERFACE_LINK_LIBRARIES which breaks the PPC link step.
 target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
   cglm
-  liblua
   m
-  fat
-  PkgConfig::zip
+  zip
+  bz2
+  zstd
+  z
+  lzma
 )
 
-# Postbuild
+if(DUSK_DOLPHIN_BUILD_TYPE STREQUAL "ISO")
+  target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC DUSK_DOLPHIN_BUILD_ISO)
+else()
+  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE fat)
+endif()
+
+# Postbuild: ELF -> DOL
 set(DUSK_BINARY_TARGET_NAME_DOL "${DUSK_BUILD_DIR}/Dusk.dol")
 add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
   COMMAND elf2dol
           "$<TARGET_FILE:${DUSK_BINARY_TARGET_NAME}>"
           "${DUSK_BINARY_TARGET_NAME_DOL}"
   COMMENT "Generating ${DUSK_BINARY_TARGET_NAME_DOL} from ${DUSK_BINARY_TARGET_NAME}"
-)
+)

cmake/targets/gamecube.cmake

@@ -2,4 +2,23 @@ include(cmake/targets/dolphin.cmake)
 
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_GAMECUBE
-)
+)
+
+# Link libraries
+target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
+  # bba
+)
+
+# ISO post-build: produce NTSC-J, NTSC-U and PAL disc images
+if(DUSK_DOLPHIN_BUILD_TYPE STREQUAL "ISO")
+  add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
+    COMMAND ${Python3_EXECUTABLE}
+            "${CMAKE_SOURCE_DIR}/tools/makedolphiniso.py"
+            "GCN"
+            "${DUSK_BINARY_TARGET_NAME_DOL}"
+            "${DUSK_ASSETS_ZIP}"
+            "${DUSK_GAME_NAME}"
+            "${DUSK_BUILD_DIR}"
+    COMMENT "Building GameCube ISO images (NTSC-J, NTSC-U, PAL)"
+  )
+endif()

cmake/targets/knulli.cmake

@@ -34,6 +34,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_OPENGL
   DUSK_OPENGL_ES
   DUSK_LINUX
+  DUSK_KNULLI
   DUSK_DISPLAY_SIZE_DYNAMIC
   DUSK_DISPLAY_WIDTH_DEFAULT=640
   DUSK_DISPLAY_HEIGHT_DEFAULT=480

cmake/targets/linux.cmake

@@ -1,6 +1,7 @@
 # Find link platform-specific libraries
 find_package(SDL2 REQUIRED)
 find_package(OpenGL REQUIRED)
+# find_package(CURL REQUIRED)
 
 # Setup endianess at compile time to optimize.
 include(TestBigEndian)
@@ -16,18 +17,22 @@ else()
 endif()
 
 # Link required libraries.
-target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC 
+target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   SDL2
   pthread
   OpenGL::GL
   GL
   m
+  # CURL::libcurl
 )
 
+set(DUSK_BACKTRACE ON CACHE BOOL "Enable backtrace support for assert failures.")
+
 # Define platform-specific macros.
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_SDL2
   DUSK_OPENGL
+  DUSK_CONSOLE_POSIX
   # DUSK_OPENGL_LEGACY
   DUSK_LINUX
   DUSK_DISPLAY_SIZE_DYNAMIC
@@ -38,4 +43,6 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_INPUT_POINTER
   DUSK_INPUT_GAMEPAD
   DUSK_TIME_DYNAMIC
+  DUSK_NETWORK_IPV6
+  DUSK_THREAD_PTHREAD
 )

cmake/targets/psp.cmake

@@ -1,6 +1,16 @@
+set(CMAKE_AR "$ENV{PSPDEV}/bin/psp-ar" CACHE FILEPATH "" FORCE)
+set(CMAKE_RANLIB "$ENV{PSPDEV}/bin/psp-ranlib" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_COMPILER_AR "$ENV{PSPDEV}/bin/psp-ar" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_COMPILER_RANLIB "$ENV{PSPDEV}/bin/psp-ranlib" CACHE FILEPATH "" FORCE)
+set(CMAKE_C_ARCHIVE_CREATE "$ENV{PSPDEV}/bin/psp-ar qc <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_C_ARCHIVE_APPEND "$ENV{PSPDEV}/bin/psp-ar q <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_C_ARCHIVE_FINISH "$ENV{PSPDEV}/bin/psp-ranlib <TARGET>")
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF CACHE BOOL "" FORCE)
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_C OFF CACHE BOOL "" FORCE)
+
 find_package(SDL2 REQUIRED)
 find_package(OpenGL REQUIRED)
-target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+target_link_libraries(${DUSK_BINARY_TARGET_NAME} PUBLIC
   ${SDL2_LIBRARIES}
   SDL2
   pthread
@@ -24,13 +34,18 @@ target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   pspvfpu
   pspvram
   psphprm
+  pspnet
+  pspnet_inet
+  pspnet_apctl
+  psphttp
+  pspssl
 )
 
-target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
+target_include_directories(${DUSK_BINARY_TARGET_NAME} PRIVATE
   ${SDL2_INCLUDE_DIRS}
 )
 
-target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
   DUSK_SDL2
   DUSK_OPENGL
   DUSK_PSP
@@ -39,6 +54,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_OPENGL_LEGACY
   DUSK_DISPLAY_WIDTH=480
   DUSK_DISPLAY_HEIGHT=272
+  DUSK_THREAD_PTHREAD
 )
 
 # Postbuild, create .pbp file for PSP.

cmake/targets/vita.cmake

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Dominic Masters
+#
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+if(NOT DEFINED ENV{VITASDK})
+  message(FATAL_ERROR "VITASDK environment variable is not set.")
+endif()
+
+include("$ENV{VITASDK}/share/vita.cmake" REQUIRED)
+
+set(VITA_APP_NAME "Dusk")
+set(VITA_TITLEID "DUSK00001")
+set(VITA_VERSION "01.00")
+
+find_package(SDL2 REQUIRED)
+
+# Custom flags for cglm
+set(CGLM_SHARED OFF CACHE BOOL "Build cglm shared" FORCE)
+set(CGLM_STATIC ON  CACHE BOOL "Build cglm static" FORCE)
+find_package(cglm REQUIRED)
+
+# Link libraries
+target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+  ${SDL2_LIBRARIES}
+  cglm
+  SDL2
+  SDL2main
+  zip
+  bz2
+  z
+  zstd
+  crypto
+  lzma
+  m
+  pthread
+  stdc++
+  vitaGL
+  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
+  libtaihen_stub.a
+
+
+  # SceKernel_stub
+  SceAppUtil_stub
+  SceHid_stub
+  SceRtc_stub
+)
+
+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_OPENGL_LEGACY
+  DUSK_DISPLAY_WIDTH=960
+  DUSK_DISPLAY_HEIGHT=544
+)
+
+# Post-build: create SELF from the ELF binary (UNSAFE = homebrew, no signing)
+vita_create_self(${DUSK_BINARY_TARGET_NAME}.self ${DUSK_BINARY_TARGET_NAME} UNSAFE)
+
+# Post-build: package SELF + assets into a .vpk installable on the Vita
+vita_create_vpk(${DUSK_BINARY_TARGET_NAME}.vpk ${VITA_TITLEID} ${DUSK_BINARY_TARGET_NAME}.self
+  VERSION ${VITA_VERSION}
+  NAME ${VITA_APP_NAME}
+  FILE ${DUSK_ASSETS_ZIP} dusk.dsk
+)

cmake/targets/wii.cmake

@@ -2,4 +2,26 @@ include(cmake/targets/dolphin.cmake)
 
 target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
   DUSK_WII
-)
+)
+
+# Generate Homebrew Channel meta.xml from project identity variables
+string(TIMESTAMP DUSK_BUILD_DATE "%Y%m%d000000" UTC)
+configure_file(
+  "${CMAKE_SOURCE_DIR}/docker/dolphin/meta.xml.in"
+  "${DUSK_BUILD_DIR}/meta.xml"
+  @ONLY
+)
+
+# ISO post-build: produce NTSC-J, NTSC-U and PAL disc images
+if(DUSK_DOLPHIN_BUILD_TYPE STREQUAL "ISO")
+  add_custom_command(TARGET ${DUSK_BINARY_TARGET_NAME} POST_BUILD
+    COMMAND ${Python3_EXECUTABLE}
+            "${CMAKE_SOURCE_DIR}/tools/makedolphiniso.py"
+            "WII"
+            "${DUSK_BINARY_TARGET_NAME_DOL}"
+            "${DUSK_ASSETS_ZIP}"
+            "${DUSK_GAME_NAME}"
+            "${DUSK_BUILD_DIR}"
+    COMMENT "Building Wii ISO images (NTSC-J, NTSC-U, PAL)"
+  )
+endif()

docker/dolphin/Dockerfile

@@ -1,6 +1,7 @@
-FROM devkitpro/devkitppc
+FROM ghcr.io/extremscorner/libogc2
 WORKDIR /workdir
 RUN apt update && \
-    apt install -y python3 python3-pip python3-polib python3-pil python3-dotenv python3-pyqt5 python3-opengl && \
-    dkp-pacman -S --needed --noconfirm gamecube-sdl2 ppc-liblzma ppc-libzip
+    dkp-pacman -Syu --noconfirm && \
+    apt install -y python3 python3-pip python3-polib python3-pil python3-dotenv python3-pyqt5 python3-opengl xorriso && \
+    dkp-pacman -S --needed --noconfirm gamecube-sdl2 ppc-liblzma ppc-libzip libogc2 gamecube-tools ppc-libmad ppc-zlib-ng ppc-liblzma ppc-bzip2 ppc-zstd
 VOLUME ["/workdir"]

docker/dolphin/meta.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<app version="1">
-	<name>Dusk</name>
-	<version>1.00</version>
-	<release_date></release_date>
-	<coder>YouWish</coder>
-	<short_description>Dusk game</short_description>
-	<long_description>No description yet.</long_description>
-  <ahb_access/>
-</app>

docker/dolphin/meta.xml.in

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<app version="1">
+	<name>@DUSK_GAME_NAME@</name>
+	<version>@PROJECT_VERSION@</version>
+	<release_date>@DUSK_BUILD_DATE@</release_date>
+	<coder>@DUSK_GAME_AUTHOR@</coder>
+	<short_description>@DUSK_GAME_SHORT_DESCRIPTION@</short_description>
+	<long_description>@DUSK_GAME_LONG_DESCRIPTION@</long_description>
+	<ahb_access/>
+</app>

docker/linux/Dockerfile

@@ -14,8 +14,8 @@ RUN apt-get install -y \
   python3-dotenv \
   python3-pyqt5 \
   python3-opengl \
-  liblua5.3-dev \
   xz-utils \
+  liblzma-dev \
   libbz2-dev \
   zlib1g-dev \
   libzip-dev \

docker/vita/Dockerfile

@@ -0,0 +1,13 @@
+FROM vitasdk/vitasdk:latest
+WORKDIR /workdir
+
+# Install vitaGL and its dependencies (vitashark, SceShaccCg) via vdpm
+RUN which vdpm
+
+# Install Python (needed for Dusk code generation tools)
+RUN apk add --no-cache \
+  python3 \
+  py3-pip \
+  py3-dotenv
+
+VOLUME ["/workdir"]

scripts/build-gamecube-docker.sh

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

scripts/build-gamecube-iso-docker.sh

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

scripts/build-gamecube-iso.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+if [ -z "$DEVKITPRO" ]; then
+  echo "DEVKITPRO environment variable is not set. Please set it to the path of your DEVKITPRO installation."
+  exit 1
+fi
+
+mkdir -p build-gamecube-iso
+cmake -S. -Bbuild-gamecube-iso \
+  -DDUSK_TARGET_SYSTEM=gamecube \
+  -DDUSK_DOLPHIN_BUILD_TYPE=ISO \
+  -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake"
+cd build-gamecube-iso
+make -j$(nproc) VERBOSE=1

scripts/build-gamecube.sh

@@ -5,6 +5,9 @@ if [ -z "$DEVKITPRO" ]; then
 fi
 
 mkdir -p build-gamecube
-cmake -S. -Bbuild-gamecube -DDUSK_TARGET_SYSTEM=gamecube -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake"
+cmake -S. -Bbuild-gamecube \
+  -DDUSK_TARGET_SYSTEM=gamecube \
+  -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/GameCube.cmake" \
+  -DDKP_OGC_PLATFORM_LIBRARY=libogc2
 cd build-gamecube
 make -j$(nproc) VERBOSE=1

scripts/build-knulli-docker.sh

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

scripts/build-linux-docker.sh

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

scripts/build-psp-docker.sh

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

scripts/build-vita-docker.sh

@@ -0,0 +1,3 @@
+#!/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

@@ -0,0 +1,13 @@
+#!/bin/bash
+if [ -z "$VITASDK" ]; then
+  echo "VITASDK environment variable is not set. Please set it to the path of your VitaSDK installation."
+  exit 1
+fi
+
+mkdir -p build-vita
+cd build-vita
+cmake \
+  -DCMAKE_TOOLCHAIN_FILE=$VITASDK/share/vita.toolchain.cmake \
+  -DDUSK_TARGET_SYSTEM=vita \
+  ..
+make -j$(nproc)

scripts/build-wii-docker.sh

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

scripts/build-wii-iso-docker.sh

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

scripts/build-wii-iso.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+if [ -z "$DEVKITPRO" ]; then
+  echo "DEVKITPRO environment variable is not set. Please set it to the path of your DEVKITPRO installation."
+  exit 1
+fi
+
+mkdir -p build-wii-iso
+cmake -S. -Bbuild-wii-iso \
+  -DDUSK_TARGET_SYSTEM=wii \
+  -DDUSK_DOLPHIN_BUILD_TYPE=ISO \
+  -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake"
+cd build-wii-iso
+make -j$(nproc) VERBOSE=1

scripts/build-wii.sh

@@ -7,4 +7,5 @@ fi
 mkdir -p build-wii
 cmake -S. -Bbuild-wii -DDUSK_TARGET_SYSTEM=wii -DCMAKE_TOOLCHAIN_FILE="$DEVKITPRO/cmake/Wii.cmake"
 cd build-wii
-make -j$(nproc) VERBOSE=1
+make -j$(nproc) VERBOSE=1
+mv Dusk.dol boot.dol

scripts/test-linux-docker.sh

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

scripts/test-linux.sh

@@ -1,4 +1,6 @@
 #!/bin/bash
+set -e
+rm -rf build-tests
 cmake -S . -B build-tests -DDUSK_BUILD_TESTS=ON -DDUSK_TARGET_SYSTEM=linux
 cmake --build build-tests -- -j$(nproc)
 ctest --output-on-failure --test-dir build-tests

src/CMakeLists.txt

@@ -4,7 +4,6 @@
 # https://opensource.org/licenses/MIT
 
 add_subdirectory(dusk)
-add_subdirectory(duskrpg)
 
 if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "knulli")
   add_subdirectory(dusklinux)
@@ -16,7 +15,12 @@ elseif(DUSK_TARGET_SYSTEM STREQUAL "psp")
   add_subdirectory(dusksdl2)
   add_subdirectory(duskgl)
 
-elseif(DUSK_TARGET_SYSTEM STREQUAL "gamecube" OR DUSK_TARGET_SYSTEM STREQUAL "wii")
+elseif(DUSK_TARGET_SYSTEM STREQUAL "vita")
+  add_subdirectory(duskvita)
+  add_subdirectory(dusksdl2)
+  add_subdirectory(duskgl)
+
+elseif(DUSK_TARGET_SYSTEM STREQUAL "wii" OR DUSK_TARGET_SYSTEM STREQUAL "gamecube")
   add_subdirectory(duskdolphin)
   
 endif()

src/dusk/CMakeLists.txt

@@ -14,18 +14,38 @@ if(NOT libzip_FOUND)
   target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC zip)
 endif()
 
-if(NOT Lua_FOUND)
-  find_package(Lua REQUIRED)
-  if(Lua_FOUND AND NOT TARGET Lua::Lua)
-    add_library(Lua::Lua INTERFACE IMPORTED)
-    set_target_properties(
-      Lua::Lua
-      PROPERTIES
-        INTERFACE_INCLUDE_DIRECTORIES "${LUA_INCLUDE_DIR}"
-        INTERFACE_LINK_LIBRARIES "${LUA_LIBRARIES}"
-    )
+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()
-  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC Lua::Lua)
+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 jerryscript_FOUND)
+  find_package(jerryscript REQUIRED)
+  target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
+    jerryscript::core
+    jerryscript::ext
+    jerryscript::port
+  )
+endif()
+
+if(DUSK_BACKTRACE)
+  target_link_options(${DUSK_LIBRARY_TARGET_NAME} PUBLIC -rdynamic)
+  target_compile_definitions(${DUSK_BINARY_TARGET_NAME} PUBLIC
+    DUSK_BACKTRACE
+  )
 endif()
 
 # Includes
@@ -40,25 +60,30 @@ target_sources(${DUSK_BINARY_TARGET_NAME}
     main.c
 )
 
-# Defs
-dusk_env_to_h(duskdefs.env duskdefs.h)
-
 # Subdirs
+add_subdirectory(animation)
+add_subdirectory(event)
 add_subdirectory(assert)
 add_subdirectory(asset)
-add_subdirectory(log)
+add_subdirectory(cutscene)
+add_subdirectory(item)
+add_subdirectory(story)
+add_subdirectory(console)
 add_subdirectory(display)
+add_subdirectory(log)
 add_subdirectory(engine)
+add_subdirectory(entity)
 add_subdirectory(error)
-add_subdirectory(event)
 add_subdirectory(input)
 add_subdirectory(locale)
+add_subdirectory(physics)
 add_subdirectory(scene)
 add_subdirectory(script)
+add_subdirectory(system)
 add_subdirectory(time)
 add_subdirectory(ui)
+add_subdirectory(network)
+add_subdirectory(overworld)
+add_subdirectory(save)
 add_subdirectory(util)
-
-# if(DUSK_TARGET_SYSTEM STREQUAL "linux" OR DUSK_TARGET_SYSTEM STREQUAL "psp")
-#   add_subdirectory(thread)
-# endif()
+add_subdirectory(thread)

src/dusk/animation/CMakeLists.txt

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

src/dusk/animation/animation.c

@@ -0,0 +1,52 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "animation.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/math.h"
+
+void animationInit(
+  animation_t *anim,
+  keyframe_t *keyframes,
+  uint16_t keyframeCount
+) {
+  assertNotNull(anim, "Animation pointer cannot be null.");
+  assertNotNull(keyframes, "Keyframes pointer cannot be null.");
+  assertTrue(keyframeCount > 0, "Keyframe count must be more than 0.");
+
+  anim->keyframes = keyframes;
+  anim->keyframeCount = keyframeCount;
+}
+
+float_t animationGetValue(animation_t *anim, const float_t time) {
+  assertNotNull(anim, "Animation pointer cannot be null.");
+  assertNotNull(anim->keyframes, "Keyframes pointer cannot be null.");
+  assertTrue(anim->keyframeCount > 0, "Keyframe count invalid.");
+  assertTrue(time >= 0, "Time must be non-negative.");
+  
+  keyframe_t *start;
+  keyframe_t *end;
+  keyframe_t *last = anim->keyframes + anim->keyframeCount - 1;
+  keyframe_t *current = anim->keyframes;
+  start = current;
+
+  do {
+    if(current->time > time) {
+      end = current;
+      break;
+    }
+    start = current;
+    current++;
+
+    if(current > last) {
+      end = start;
+      break;
+    }
+  } while(true);
+
+  float_t t = (time - start->time) / (end->time - start->time);
+  return mathLerp(start->value, end->value, easingApply(start->easing, t));
+}

src/dusk/animation/animation.h

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "keyframe.h"
+
+typedef struct {
+  keyframe_t *keyframes;
+  uint16_t keyframeCount;
+} animation_t;
+
+/**
+ * Initializes an animation.
+ * 
+ * @param anim The animation to initialize.
+ * @param keyframes The keyframes to use for the animation.
+ * @param keyframeCount The number of keyframes in the animation.
+ */
+void animationInit(
+  animation_t *anim,
+  keyframe_t *keyframes,
+  uint16_t keyframeCount
+);
+
+/**
+ * Gets the value of the animation at a given time.
+ * 
+ * @param anim The animation to get the value from.
+ * @param time The time at which to get the value, in seconds.
+ * @return The value of the animation at the given time.
+ */
+float_t animationGetValue(animation_t *anim, const float_t time);

src/dusk/animation/easing.c

@@ -0,0 +1,111 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "easing.h"
+#include "assert/assert.h"
+#include <math.h>
+
+const easingfn_t EASING_FUNCTIONS[EASING_COUNT] = {
+  easingLinear,
+  easingInSine,
+  easingOutSine,
+  easingInOutSine,
+  easingInQuad,
+  easingOutQuad,
+  easingInOutQuad,
+  easingInCubic,
+  easingOutCubic,
+  easingInOutCubic,
+  easingInQuart,
+  easingOutQuart,
+  easingInOutQuart,
+  easingInBack,
+  easingOutBack,
+  easingInOutBack,
+};
+
+float_t easingApply(const easingtype_t type, const float_t t) {
+  assertTrue(type < EASING_COUNT, "Invalid easing type");
+  return EASING_FUNCTIONS[type](t);
+}
+
+float_t easingLinear(const float_t t) {
+  return t;
+}
+
+float_t easingInSine(const float_t t) {
+  return 1.0f - cosf(t * EASING_PI * 0.5f);
+}
+
+float_t easingOutSine(const float_t t) {
+  return sinf(t * EASING_PI * 0.5f);
+}
+
+float_t easingInOutSine(const float_t t) {
+  return -(cosf(EASING_PI * t) - 1.0f) * 0.5f;
+}
+
+float_t easingInQuad(const float_t t) {
+  return t * t;
+}
+
+float_t easingOutQuad(const float_t t) {
+  float_t u = 1.0f - t;
+  return 1.0f - u * u;
+}
+
+float_t easingInOutQuad(const float_t t) {
+  if(t < 0.5f) return 2.0f * t * t;
+  float_t u = -2.0f * t + 2.0f;
+  return 1.0f - u * u * 0.5f;
+}
+
+float_t easingInCubic(const float_t t) {
+  return t * t * t;
+}
+
+float_t easingOutCubic(const float_t t) {
+  float_t u = 1.0f - t;
+  return 1.0f - u * u * u;
+}
+
+float_t easingInOutCubic(const float_t t) {
+  if(t < 0.5f) return 4.0f * t * t * t;
+  float_t u = -2.0f * t + 2.0f;
+  return 1.0f - u * u * u * 0.5f;
+}
+
+float_t easingInQuart(const float_t t) {
+  return t * t * t * t;
+}
+
+float_t easingOutQuart(const float_t t) {
+  float_t u = 1.0f - t;
+  return 1.0f - u * u * u * u;
+}
+
+float_t easingInOutQuart(const float_t t) {
+  if(t < 0.5f) return 8.0f * t * t * t * t;
+  float_t u = -2.0f * t + 2.0f;
+  return 1.0f - u * u * u * u * 0.5f;
+}
+
+float_t easingInBack(const float_t t) {
+  return EASING_C3 * t * t * t - EASING_C1 * t * t;
+}
+
+float_t easingOutBack(const float_t t) {
+  float_t u = t - 1.0f;
+  return 1.0f + EASING_C3 * u * u * u + EASING_C1 * u * u;
+}
+
+float_t easingInOutBack(const float_t t) {
+  if(t < 0.5f) {
+    float_t u = 2.0f * t;
+    return u * u * ((EASING_C2 + 1.0f) * u - EASING_C2) * 0.5f;
+  }
+  float_t u = 2.0f * t - 2.0f;
+  return (u * u * ((EASING_C2 + 1.0f) * u + EASING_C2) + 2.0f) * 0.5f;
+}

src/dusk/animation/easing.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dusk.h"
+
+#define EASING_PI 3.14159265358979323846f
+#define EASING_C1 1.70158f
+#define EASING_C2 (EASING_C1 * 1.525f)
+#define EASING_C3 (EASING_C1 + 1.0f)
+
+typedef enum {
+  EASING_LINEAR,
+  EASING_IN_SINE,
+  EASING_OUT_SINE,
+  EASING_IN_OUT_SINE,
+  EASING_IN_QUAD,
+  EASING_OUT_QUAD,
+  EASING_IN_OUT_QUAD,
+  EASING_IN_CUBIC,
+  EASING_OUT_CUBIC,
+  EASING_IN_OUT_CUBIC,
+  EASING_IN_QUART,
+  EASING_OUT_QUART,
+  EASING_IN_OUT_QUART,
+  EASING_IN_BACK,
+  EASING_OUT_BACK,
+  EASING_IN_OUT_BACK,
+
+  EASING_COUNT
+} easingtype_t;
+
+typedef float_t (*easingfn_t)(const float_t t);
+
+extern const easingfn_t EASING_FUNCTIONS[EASING_COUNT];
+
+/**
+ * Applies the specified easing function to t.
+ * 
+ * @param type The easing type to apply.
+ * @param t The input time, in the range [0, 1].
+ * @return The eased value, in the range [0, 1].
+ */
+float_t easingApply(const easingtype_t type, const float_t t);
+
+float_t easingLinear(const float_t t);
+float_t easingInSine(const float_t t);
+float_t easingOutSine(const float_t t);
+float_t easingInOutSine(const float_t t);
+float_t easingInQuad(const float_t t);
+float_t easingOutQuad(const float_t t);
+float_t easingInOutQuad(const float_t t);
+float_t easingInCubic(const float_t t);
+float_t easingOutCubic(const float_t t);
+float_t easingInOutCubic(const float_t t);
+float_t easingInQuart(const float_t t);
+float_t easingOutQuart(const float_t t);
+float_t easingInOutQuart(const float_t t);
+float_t easingInBack(const float_t t);
+float_t easingOutBack(const float_t t);
+float_t easingInOutBack(const float_t t);

src/dusk/animation/keyframe.h

@@ -0,0 +1,13 @@
+// Copyright (c) 2026 Dominic Masters
+//
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "easing.h"
+
+typedef struct {
+  float_t time;
+  float_t value;
+  easingtype_t easing;
+} keyframe_t;

src/dusk/assert/assert.c

@@ -8,6 +8,7 @@
 #include "assert.h"
 #include "log/log.h"
 #include "util/string.h"
+#include "util/memory.h"
 
 #ifndef DUSK_ASSERTIONS_FAKED
   #ifdef DUSK_TEST_ASSERT
@@ -25,6 +26,25 @@
       );
     }
   #else
+    #ifdef DUSK_BACKTRACE
+      #include <execinfo.h>
+      #include <stdlib.h>
+
+      static void assertLogBacktrace(void) {
+        void *frames[64];
+        int count = backtrace(frames, 64);
+        char **symbols = backtrace_symbols(frames, count);
+        memoryTrack(symbols);
+        logError("Stack trace:\n");
+        if(symbols) {
+          for(int i = 0; i < count; i++) {
+            logError("  %s\n", symbols[i]);
+          }
+          memoryFree(symbols);
+        }
+      }
+    #endif
+
     void assertTrueImpl(
       const char *file,
       const int32_t line,
@@ -33,11 +53,14 @@
     ) {
       if(x != true) {
         logError(
-          "Assertion Failed in %s:%i\n\n%s\n",
+          "Assertion Failed in %s:%i\n\n%s\n\n",
           file,
           line,
           message
         );
+        #ifdef DUSK_BACKTRACE
+          assertLogBacktrace();
+        #endif
         abort();
       }
     }

src/dusk/assert/assert.h

@@ -216,4 +216,11 @@
   #define assertStrLenMax(str, len, message) ((void)0)
   #define assertStrLenMin(str, len, message) ((void)0)
 
-#endif
+#endif
+
+// Static Assertions
+
+#define assertStructSize(struct, size) \
+  _Static_assert(sizeof(struct) == size, "Size of " #struct " must be " #size)
+
+// EOF

src/dusk/asset/CMakeLists.txt

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

src/dusk/asset/asset.c

@@ -9,142 +9,355 @@
 #include "util/memory.h"
 #include "util/string.h"
 #include "assert/assert.h"
-#include "asset/assettype.h"
 #include "engine/engine.h"
 #include "util/string.h"
+#include "console/console.h"
+#include <unistd.h>
 
 asset_t ASSET;
 
 errorret_t assetInit(void) {
   memoryZero(&ASSET, sizeof(asset_t));
-  
+
+  for(size_t i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
+    threadMutexInit(&ASSET.loading[i].mutex);
+  }
+
   // assetInitPlatform must either define ASSET.zip or throw an error.
   errorChain(assetInitPlatform());
   assertNotNull(ASSET.zip, "Asset zip null without error.");
+  threadInit(&ASSET.loadThread, assetUpdateAsync);
+  threadStart(&ASSET.loadThread);
 
   errorOk();
 }
 
 bool_t assetFileExists(const char_t *filename) {
-  assertStrLenMax(filename, FILENAME_MAX, "Filename too long.");
+  assertStrLenMax(filename, ASSET_FILE_NAME_MAX, "Filename too long.");
 
   zip_int64_t idx = zip_name_locate(ASSET.zip, filename, 0);
   if(idx < 0) return false;
   return true;
 }
 
-errorret_t assetLoad(const char_t *filename, void *output) {
-  assertStrLenMax(filename, FILENAME_MAX, "Filename too long.");
-  assertNotNull(output, "Output pointer cannot be NULL.");
+assetentry_t * assetGetEntry(
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+) {
+  // Is there an existing asset?
+  assetentry_t *entry = ASSET.entries;
+  do {
+    if(entry->type == ASSET_LOADER_TYPE_NULL) {
+      entry++;
+      continue;
+    }
+    if(stringEquals(entry->name, name)) {
+      assertTrue(entry->type == type, "Asset entry type mismatch.");
+      return entry;
+    }
+    entry++;
+  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
+  
+  // We did not find one existing, Find first available slot.
+  entry = ASSET.entries;
+  do {
+    if(entry->type != ASSET_LOADER_TYPE_NULL) {
+      entry++;
+      continue;
+    }
 
-  // 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);
+    if(entry->state == ASSET_ENTRY_STATE_NOT_STARTED) {
+      assetEntryInit(entry, name, type, input);
+      return entry;
+    }
+    entry++;
+  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
+
+  assertUnreachable("No available asset entry slots.");
+  return NULL;
+}
+
+errorret_t assetRequireLoaded(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL.");
+  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+
+  if(entry->state == ASSET_ENTRY_STATE_LOADED) {
+    errorOk();
   }
 
-  // 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);
+  // Lock to prevent the reaper from collecting the entry mid-spin.
+  assetEntryLock(entry);
 
+  while(entry->state != ASSET_ENTRY_STATE_LOADED) {
+    usleep(1000);
+    errorret_t ret = assetUpdate();
+    if(errorIsNotOk(ret)) {
+      assetEntryUnlock(entry);
       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.");
+    }
   }
 
+  assetEntryUnlock(entry);
+  errorOk();
+}
+
+assetentry_t * assetLock(
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+) {
+  assetentry_t *entry = assetGetEntry(name, type, input);
+  assetEntryLock(entry);
+  return entry;
+}
+
+void assetUnlock(const char_t *name) {
+  assertNotNull(name, "Name cannot be NULL.");
+  assetentry_t *entry = ASSET.entries;
+  do {
+    if(entry->type != ASSET_LOADER_TYPE_NULL && stringEquals(entry->name, name)) {
+      assetEntryUnlock(entry);
+      return;
+    }
+    entry++;
+  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
+  assertUnreachable("Asset entry not found for unlock.");
+}
+
+void assetUnlockEntry(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL.");
+  assetEntryUnlock(entry);
+}
+
+errorret_t assetUpdate(void) {
+  // Determine how many available loading slots we have.
+  assetloading_t *availableLoading[ASSET_LOADING_COUNT_MAX];
+  uint8_t availableLoadingCount = 0;
+  assetloading_t *loading = ASSET.loading;
+  assetentry_t *entry;
+
+
+  do {
+    // We only care about NULL entry references. Nothing async touches this so
+    // it's fine to use raw here.
+    if(loading->entry != NULL) {
+      loading++;
+      continue;
+    }
+    availableLoading[availableLoadingCount++] = loading;
+    loading++;
+  } while(loading < ASSET.loading + ASSET_LOADING_COUNT_MAX);
+
+
+  // Now we can check for pending asset entries, we can't do anything if there
+  // is no available slots though.
+  if(availableLoadingCount > 0) {
+    entry = ASSET.entries;
+    do {
+      // Is this asset "ready to start loading" ?
+      if(entry->type == ASSET_LOADER_TYPE_NULL) {
+        entry++;
+        continue;
+      }
+
+      // We only care about assets not started.
+      if(entry->state != ASSET_ENTRY_STATE_NOT_STARTED) {
+        entry++;
+        continue;
+      }
+
+      // Pop a loading slot for this asset entry.
+      loading = availableLoading[--availableLoadingCount];
+
+      // Start loading this asset.
+      assetEntryStartLoading(entry, loading);
+      entry++;
+
+      // Did we run out of loading slots?
+      if(availableLoadingCount == 0) {
+        break;
+      }
+    } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
+  }
+
+  // Now walk over all the loading slots and see what needs to be done.
+  loading = ASSET.loading;
+  do {
+    // Is the loading slot in use? Entry can only be modified synchronously.
+    if(loading->entry == NULL) {
+      loading++;
+      continue;
+    }
+
+    // Lock the loading slot. This will prevent any async modifications.
+    threadMutexLock(&loading->mutex);
+
+    // Check the state of the entry.
+    switch(loading->entry->state) {
+      // This thing is pending synchronous loading.
+      case ASSET_ENTRY_STATE_PENDING_SYNC:
+        loading->entry->state = ASSET_ENTRY_STATE_LOADING_SYNC;
+        // Unlock before calling loadSync. The sync loader may re-enter
+        // assetUpdate (e.g. a script loading another asset), and the async
+        // thread never touches LOADING_SYNC entries, so this is safe.
+        threadMutexUnlock(&loading->mutex);
+
+        errorret_t ret = (
+          ASSET_LOADER_CALLBACKS[loading->type].loadSync(loading)
+        );
+
+        // After a sync load, these are the only valid states.
+        assertTrue(
+          loading->entry->state == ASSET_ENTRY_STATE_LOADED ||
+          loading->entry->state == ASSET_ENTRY_STATE_ERROR ||
+          loading->entry->state == ASSET_ENTRY_STATE_PENDING_SYNC ||
+          loading->entry->state == ASSET_ENTRY_STATE_PENDING_ASYNC,
+          "Loader did not set entry state to loaded or error on finished load."
+        );
+
+        if(errorIsNotOk(ret)) {
+          errorCatch(errorPrint(ret));
+          assertTrue(
+            loading->entry->state == ASSET_ENTRY_STATE_ERROR,
+            "Loader did not set entry state to error on failed load."
+          );
+        }
+
+        loading++;
+        break;
+
+      case ASSET_ENTRY_STATE_LOADING_SYNC:
+        // A re-entrant assetUpdate call (e.g. from a script loading another
+        // asset) will see this entry mid-sync-load. Skip it.
+        threadMutexUnlock(&loading->mutex);
+        loading++;
+        continue;
+
+      // Done loading, we can just free it up.
+      case ASSET_ENTRY_STATE_LOADED:
+        loading->entry = NULL;
+        threadMutexUnlock(&loading->mutex);
+        loading++;
+        break;
+
+      case ASSET_ENTRY_STATE_ERROR:
+        threadMutexUnlock(&loading->mutex);
+        errorThrow("Failed to load asset asynchronously.");
+        break;
+
+      default:
+        threadMutexUnlock(&loading->mutex);
+        loading++;
+        continue;
+    }
+  } while(loading < ASSET.loading + ASSET_LOADING_COUNT_MAX);
+
+
+  // Reap entries that have no external locks (refs.count == 0) AND have been
+  // explicitly locked at least once. Entries that were never locked are left
+  // alone — raw-pointer callers hold no ref but should not lose the entry.
+  entry = ASSET.entries;
+  do {
+    if(entry->state != ASSET_ENTRY_STATE_LOADED) {
+      entry++;
+      continue;
+    }
+
+    if(entry->type == ASSET_LOADER_TYPE_NULL) {
+      entry++;
+      continue;
+    }
+
+    if(!entry->wasLocked) {
+      entry++;
+      continue;
+    }
+
+    if(entry->refs.count > 0) {
+      entry++;
+      continue;
+    }
+
+    consolePrint("Reaping asset %s", entry->name);
+    errorChain(assetEntryDispose(entry));
+    entry++;
+  } while(entry < ASSET.entries + ASSET_ENTRY_COUNT_MAX);
+
   errorOk();
 }
 
+void assetUpdateAsync(thread_t *thread) {
+  while(!threadShouldStop(thread)) {
+    // Walk over each asset
+    assetloading_t *loading;
+    loading = ASSET.loading;
+    
+    do {
+      threadMutexLock(&loading->mutex);
+
+      if(loading->entry == NULL) {
+        threadMutexUnlock(&loading->mutex);
+        loading++;
+        continue;
+      }
+
+      switch(loading->entry->state) {
+        case ASSET_ENTRY_STATE_PENDING_ASYNC:
+          loading->entry->state = ASSET_ENTRY_STATE_LOADING_ASYNC;
+          assertNotNull(
+            ASSET_LOADER_CALLBACKS[loading->type].loadAsync,
+            "Loader does not support async loading."
+          );
+          errorret_t ret = (
+            ASSET_LOADER_CALLBACKS[loading->type].loadAsync(loading)
+          );
+
+          if(errorIsNotOk(ret)) {
+            errorCatch(errorPrint(ret));
+            assertTrue(
+              loading->entry->state == ASSET_ENTRY_STATE_ERROR,
+              "Loader did not set entry state to error on failed load."
+            );
+          }
+
+          threadMutexUnlock(&loading->mutex);
+          loading++;
+          break;
+
+        case ASSET_ENTRY_STATE_LOADING_ASYNC:
+          assertUnreachable(
+            "Entry is in a pending async state still?"
+          );
+          break;
+
+        default:
+          threadMutexUnlock(&loading->mutex);
+          loading++;
+          continue;
+      }
+    } while(loading < ASSET.loading + ASSET_LOADING_COUNT_MAX);
+
+    if(threadShouldStop(thread)) break;
+    usleep(1000);
+  }
+}
+
 errorret_t assetDispose(void) {
+  threadStop(&ASSET.loadThread);
+
+  for(size_t i = 0; i < ASSET_LOADING_COUNT_MAX; i++) {
+    threadMutexDispose(&ASSET.loading[i].mutex);
+  }
+
+  // Cleanup zip file.
   if(ASSET.zip != NULL) {
     if(zip_close(ASSET.zip) != 0) {
       errorThrow("Failed to close asset zip archive.");
     }
     ASSET.zip = NULL;
   }
-  
+
   errorChain(assetDisposePlatform());
   errorOk();
 }

src/dusk/asset/asset.h

@@ -7,8 +7,11 @@
 
 #pragma once
 #include "error/error.h"
-#include "assettype.h"
 #include "asset/assetplatform.h"
+#include "assetfile.h"
+#include "thread/thread.h"
+#include "asset/loader/assetentry.h"
+#include "asset/loader/assetloading.h"
 
 #ifndef assetInitPlatform
   #error "Platform must define assetInitPlatform function."
@@ -20,15 +23,27 @@
 #define ASSET_FILE_NAME "dusk.dsk"
 #define ASSET_HEADER_SIZE 3
 
-typedef struct {
+#define ASSET_LOADING_COUNT_MAX 4
+#define ASSET_ENTRY_COUNT_MAX 128
+
+typedef struct asset_s {
   zip_t *zip;
   assetplatform_t platform;
+
+  // Background loading thread.
+  thread_t loadThread;
+
+  // Assets that are mid loading.
+  assetloading_t loading[ASSET_LOADING_COUNT_MAX];
+  assetentry_t entries[ASSET_ENTRY_COUNT_MAX];
 } asset_t;
 
 extern asset_t ASSET;
 
 /**
  * Initializes the asset system.
+ * 
+ * @return An error code if the asset system could not be initialized properly.
  */
 errorret_t assetInit(void);
 
@@ -41,13 +56,73 @@ 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.
- * 
- * @param filename The filename of the asset to retrieve.
- * @param output The output pointer to store the loaded asset data.
- * @return An error code if the asset could not be loaded.
+ * Gets, or creates, a new asset entry. Internal — prefer assetLock.
+ *
+ * @param name Filename of the asset.
+ * @param type Type of the asset.
+ * @param input Loader-specific parameters.
  */
-errorret_t assetLoad(const char_t *filename, void *output);
+assetentry_t * assetGetEntry(
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+);
+
+/**
+ * Gets, creates, and locks an asset entry. The asset will begin loading on
+ * the next assetUpdate. Call assetUnlock when done to allow the entry to be
+ * reclaimed.
+ *
+ * @param name Filename of the asset.
+ * @param type Type of the asset.
+ * @param input Loader-specific parameters.
+ * @return The locked asset entry.
+ */
+assetentry_t * assetLock(
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+);
+
+/**
+ * Releases a lock on an asset entry by name. When all locks are released the
+ * entry will be reclaimed at the start of the next assetUpdate.
+ *
+ * @param name Filename of the asset to unlock.
+ */
+void assetUnlock(const char_t *name);
+
+/**
+ * Releases a lock on an asset entry by pointer. When all locks are released
+ * the entry will be reclaimed at the start of the next assetUpdate.
+ *
+ * @param entry The asset entry to unlock.
+ */
+void assetUnlockEntry(assetentry_t *entry);
+
+/**
+ * Requires an asset entry to be loaded. This will block until the asset entry
+ * is fully loaded.
+ * 
+ * @param entry The asset entry to require.
+ * @return An error code if the asset entry could not be loaded properly.
+ */
+errorret_t assetRequireLoaded(assetentry_t *entry);
+
+/**
+ * Updates the asset system.
+ *
+ * @return An error code if the asset system could not be updated properly.
+ */
+errorret_t assetUpdate(void);
+
+/**
+ * Starts the background asset loading thread. The thread runs assetUpdate
+ * in a loop with a short sleep until stopped.
+ * 
+ * @param thread The thread runner.
+ */
+void assetUpdateAsync(thread_t *thread);
 
 /**
  * Disposes/cleans up the asset system.

src/dusk/asset/assetbatch.c

@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetbatch.h"
+#include "asset.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include <unistd.h>
+
+void assetBatchInit(
+  assetbatch_t *batch,
+  const uint16_t count,
+  const assetbatchdesc_t *descs
+) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  assertNotNull(descs, "Descs cannot be NULL.");
+  assertTrue(count > 0, "Count must be greater than 0.");
+  assertTrue(count <= ASSET_BATCH_COUNT_MAX, "Count exceeds ASSET_BATCH_COUNT_MAX.");
+
+  memoryZero(batch, sizeof(assetbatch_t));
+  batch->count = count;
+
+  for(uint16_t i = 0; i < count; i++) {
+    // Copy input into batch-owned storage so the descriptor need not persist.
+    batch->inputs[i] = descs[i].input;
+    batch->entries[i] = assetLock(descs[i].path, descs[i].type, &batch->inputs[i]);
+  }
+}
+
+void assetBatchLock(assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  for(uint16_t i = 0; i < batch->count; i++) {
+    assetEntryLock(batch->entries[i]);
+  }
+}
+
+void assetBatchUnlock(assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  for(uint16_t i = 0; i < batch->count; i++) {
+    assetEntryUnlock(batch->entries[i]);
+  }
+}
+
+bool_t assetBatchIsLoaded(const assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  for(uint16_t i = 0; i < batch->count; i++) {
+    if(batch->entries[i]->state != ASSET_ENTRY_STATE_LOADED) return false;
+  }
+  return true;
+}
+
+bool_t assetBatchHasError(const assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  for(uint16_t i = 0; i < batch->count; i++) {
+    if(batch->entries[i]->state == ASSET_ENTRY_STATE_ERROR) return true;
+  }
+  return false;
+}
+
+errorret_t assetBatchRequireLoaded(assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+
+  bool_t allDone;
+  do {
+    allDone = true;
+    for(uint16_t i = 0; i < batch->count; i++) {
+      const assetentrystate_t state = batch->entries[i]->state;
+      if(state == ASSET_ENTRY_STATE_ERROR) {
+        errorThrow("Asset '%s' failed to load.", batch->entries[i]->name);
+      }
+      if(state != ASSET_ENTRY_STATE_LOADED) {
+        allDone = false;
+      }
+    }
+    if(!allDone) {
+      usleep(1000);
+      errorChain(assetUpdate());
+    }
+  } while(!allDone);
+
+  errorOk();
+}
+
+void assetBatchDispose(assetbatch_t *batch) {
+  assertNotNull(batch, "Batch cannot be NULL.");
+  for(uint16_t i = 0; i < batch->count; i++) {
+    assetUnlockEntry(batch->entries[i]);
+  }
+  memoryZero(batch, sizeof(assetbatch_t));
+}

src/dusk/asset/assetbatch.h

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/loader/assetentry.h"
+#include "asset/loader/assetloader.h"
+
+#define ASSET_BATCH_COUNT_MAX 64
+
+typedef struct {
+  const char_t *path;
+  assetloadertype_t type;
+  assetloaderinput_t input;
+} assetbatchdesc_t;
+
+typedef struct {
+  assetentry_t *entries[ASSET_BATCH_COUNT_MAX];
+  assetloaderinput_t inputs[ASSET_BATCH_COUNT_MAX];
+  uint16_t count;
+} assetbatch_t;
+
+/**
+ * Initialises the batch from an array of descriptors. Each entry is locked
+ * and queued for loading immediately.
+ *
+ * @param batch  Batch to initialise.
+ * @param descs  Array of entry descriptors (need not outlive this call).
+ * @param count  Number of descriptors (must be <= ASSET_BATCH_COUNT_MAX).
+ */
+void assetBatchInit(
+  assetbatch_t *batch,
+  uint16_t count,
+  const assetbatchdesc_t *descs
+);
+
+/**
+ * Acquires one additional lock on every entry in the batch.
+ *
+ * @param batch Batch to lock.
+ */
+void assetBatchLock(assetbatch_t *batch);
+
+/**
+ * Releases one lock from every entry in the batch. When an entry's lock
+ * count reaches zero it will be reaped on the next assetUpdate.
+ *
+ * @param batch Batch to unlock.
+ */
+void assetBatchUnlock(assetbatch_t *batch);
+
+/**
+ * Returns true if every entry in the batch has finished loading.
+ *
+ * @param batch Batch to query.
+ */
+bool_t assetBatchIsLoaded(const assetbatch_t *batch);
+
+/**
+ * Returns true if any entry in the batch is in an error state.
+ *
+ * @param batch Batch to query.
+ */
+bool_t assetBatchHasError(const assetbatch_t *batch);
+
+/**
+ * Blocks until every entry is loaded. Returns an error if any entry fails.
+ *
+ * @param batch Batch to wait on.
+ */
+errorret_t assetBatchRequireLoaded(assetbatch_t *batch);
+
+/**
+ * Releases the batch's lock on every entry and clears the batch. After this
+ * call the batch struct may be reused with assetBatchInit.
+ *
+ * @param batch Batch to dispose.
+ */
+void assetBatchDispose(assetbatch_t *batch);

src/dusk/asset/assetfile.c

@@ -0,0 +1,335 @@
+/**
+ * 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"
+#include "util/math.h"
+
+errorret_t assetFileInit(
+  assetfile_t *file,
+  const char_t *filename,
+  void *params,
+  void *output
+) {
+  assertNotNull(file, "Asset file cannot be NULL.");
+  assertStrLenMax(filename, ASSET_FILE_NAME_MAX, "Filename too long.");
+
+  memoryZero(file, sizeof(assetfile_t));
+  memoryCopy(file->filename, filename, ASSET_FILE_NAME_MAX);
+  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.");
+  
+  if(buffer == NULL) {
+    size_t bytesRemaining = bufferSize;
+    uint8_t tempBuffer[256];
+    while(bytesRemaining > 0) {
+      size_t chunkSize = mathMin(bytesRemaining, sizeof(tempBuffer));
+      errorChain(assetFileRead(file, tempBuffer, chunkSize));
+      file->position += chunkSize;
+      bytesRemaining -= chunkSize;
+    }
+    file->lastRead = bufferSize;
+    errorOk();
+  }
+
+  // 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,141 @@
+/**
+ * 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>
+
+#define ASSET_FILE_NAME_MAX 48
+
+typedef struct assetfile_s assetfile_t;
+
+typedef errorret_t (*assetfileloader_t)(assetfile_t *file);
+
+// Describes a file not yet loaded.
+typedef struct assetfile_s {
+  char_t filename[ASSET_FILE_NAME_MAX];
+  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,84 +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_TILESET,
-  ASSET_TYPE_LANGUAGE,
-  ASSET_TYPE_SCRIPT,
-
-  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 = "DTX",
-    .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
-    .dataSize = sizeof(assettexture_t),
-    .entire = assetTextureLoad
-  },
-
-  [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
-  },
-};

src/dusk/asset/loader/CMakeLists.txt

@@ -0,0 +1,18 @@
+# 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
+    assetentry.c
+    assetloader.c
+)
+
+
+# Subdirs
+add_subdirectory(display)
+add_subdirectory(locale)
+add_subdirectory(json)
+add_subdirectory(script)

src/dusk/asset/loader/assetentry.c

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetentry.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/string.h"
+
+void assetEntryInit(
+  assetentry_t *entry,
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+) {
+  assertNotNull(entry, "Entry cannot be NULL");
+  assertStrLenMin(name, 1, "Name cannot be empty");
+  assertStrLenMax(name, ASSET_FILE_NAME_MAX - 1, "Name too long");
+  assertTrue(type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+  assertTrue(type < ASSET_LOADER_TYPE_COUNT, "Invalid loader type.");
+
+  memoryZero(entry, sizeof(assetentry_t));
+  stringCopy(entry->name, name, ASSET_FILE_NAME_MAX);
+  entry->type = type;
+  entry->state = ASSET_ENTRY_STATE_NOT_STARTED;
+  if(input) {
+    entry->inputData = *input;
+    entry->input = &entry->inputData;
+  }
+  refInit(&entry->refs, entry, NULL, NULL, NULL);
+}
+
+void assetEntryLock(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL");
+  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+  entry->wasLocked = true;
+  refLock(&entry->refs);
+}
+
+void assetEntryUnlock(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL");
+  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+  refUnlock(&entry->refs);
+}
+
+void assetEntryStartLoading(
+  assetentry_t *entry,
+  assetloading_t *loading
+) {
+  assertNotNull(entry, "Entry cannot be NULL");
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+  assertTrue(
+    entry->state == ASSET_ENTRY_STATE_NOT_STARTED,
+    "Can only start loading from NOT_STARTED state."
+  );
+
+  entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  memoryZero(&loading->loading, sizeof(assetloaderloading_t));
+  loading->type = entry->type;
+  loading->entry = entry;
+  // At this point the asset manager will manage this thing's loading
+}
+
+errorret_t assetEntryDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL");
+
+  assertTrue(entry->type != ASSET_LOADER_TYPE_NULL, "Invalid loader type.");
+  assertTrue(entry->type < ASSET_LOADER_TYPE_COUNT, "Invalid loader type.");
+  
+  errorChain(ASSET_LOADER_CALLBACKS[entry->type].dispose(entry));
+  memoryZero(entry, sizeof(assetentry_t));
+  errorOk();
+}

src/dusk/asset/loader/assetentry.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/loader/assetloading.h"
+#include "util/ref.h"
+
+typedef enum {
+  ASSET_ENTRY_STATE_NOT_STARTED,
+  ASSET_ENTRY_STATE_PENDING_ASYNC,
+  ASSET_ENTRY_STATE_LOADING_ASYNC,
+  ASSET_ENTRY_STATE_PENDING_SYNC,
+  ASSET_ENTRY_STATE_LOADING_SYNC,
+  ASSET_ENTRY_STATE_LOADED,
+  ASSET_ENTRY_STATE_ERROR
+} assetentrystate_t;
+
+typedef struct assetentry_s {
+  // Filename and cache key
+  char_t name[ASSET_FILE_NAME_MAX];
+  // What type of asset is this?
+  assetloadertype_t type;
+  // Data
+  assetloaderoutput_t data;
+  // What state is this asset entry in currently?
+  assetentrystate_t state;
+  // What is referencing this asset entry.
+  ref_t refs;
+  // True once assetEntryLock has been called at least once. The reaper only
+  // collects entries that have been explicitly locked (and later unlocked to
+  // zero). Entries that nobody has ever locked are left alone so raw-pointer
+  // callers (tests, requireLoaded before locking) are not surprised.
+  bool_t wasLocked;
+  // Owned copy of the loader input. input points here when non-NULL.
+  assetloaderinput_t inputData;
+  // Pointer to inputData, or NULL if no input was provided.
+  assetloaderinput_t *input;
+} assetentry_t;
+
+/**
+ * Initializes an asset entry with the given name and type. This does not load
+ * the asset.
+ * 
+ * @param entry The asset entry to initialize.
+ * @param name The name of the asset, used as a key for loading and caching.
+ * @param type The type of asset this entry represents.
+ * @param input Data that will be passed to the loader about how it should load.
+ */
+void assetEntryInit(
+  assetentry_t *entry,
+  const char_t *name,
+  const assetloadertype_t type,
+  assetloaderinput_t *input
+);
+
+/**
+ * Locks an asset entry, preventing it from being freed until it is unlocked.
+ * 
+ * @param entry The asset entry to lock.
+ */
+void assetEntryLock(assetentry_t *entry);
+
+/**
+ * Unlocks an asset entry, allowing it to be freed if there are no more locks.
+ * 
+ * @param entry The asset entry to unlock.
+ */
+void assetEntryUnlock(assetentry_t *entry);
+
+/**
+ * Starts loading the given asset entry using an assetloading slot. This will
+ * be called by the asset manager when it deems it's a good time to begin the
+ * loading of this asset entry.
+ * 
+ * Currently we return the error but in future this will not be returned.
+ * 
+ * @param entry The asset entry to start loading.
+ * @param loading The assetloading slot to use for loading this asset entry.
+ * @return Any error that occurs during loading.
+ */
+void assetEntryStartLoading(assetentry_t *entry, assetloading_t *loading);
+
+/**
+ * Disposes an asset entry, freeing any resources it holds.
+ * 
+ * @param entry The asset entry to dispose.
+ * @return Any error that occurs during disposal.
+ */
+errorret_t assetEntryDispose(assetentry_t *entry);

src/dusk/asset/loader/assetloader.c

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetloader.h"
+
+assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT] = {
+  [ASSET_LOADER_TYPE_NULL] = { 0 },
+
+  [ASSET_LOADER_TYPE_MESH] = {
+    .loadSync = assetMeshLoaderSync,
+    .loadAsync = assetMeshLoaderAsync,
+    .dispose = assetMeshDispose
+  },
+
+  [ASSET_LOADER_TYPE_TEXTURE] = {
+    .loadSync = assetTextureLoaderSync,
+    .loadAsync = assetTextureLoaderAsync,
+    .dispose = assetTextureDispose
+  },
+
+  [ASSET_LOADER_TYPE_TILESET] = {
+    .loadSync = assetTilesetLoaderSync,
+    .loadAsync = assetTilesetLoaderAsync,
+    .dispose = assetTilesetDispose
+  },
+
+  [ASSET_LOADER_TYPE_LOCALE] = {
+    .loadSync = assetLocaleLoaderSync,
+    .loadAsync = assetLocaleLoaderAsync,
+    .dispose = assetLocaleDispose
+  },
+
+  [ASSET_LOADER_TYPE_JSON] = {
+    .loadSync = assetJsonLoaderSync,
+    .loadAsync = assetJsonLoaderAsync,
+    .dispose = assetJsonDispose
+  },
+
+  [ASSET_LOADER_TYPE_SCRIPT] = {
+    .loadSync = assetScriptLoaderSync,
+    .loadAsync = assetScriptLoaderAsync,
+    .dispose = assetScriptDispose
+  },
+};

src/dusk/asset/loader/assetloader.h

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/loader/display/assetmeshloader.h"
+#include "asset/loader/display/assettextureloader.h"
+#include "asset/loader/display/assettilesetloader.h"
+#include "asset/loader/locale/assetlocaleloader.h"
+#include "asset/loader/json/assetjsonloader.h"
+#include "asset/loader/script/assetscriptloader.h"
+
+typedef enum {
+  ASSET_LOADER_TYPE_NULL,
+
+  ASSET_LOADER_TYPE_MESH,
+  ASSET_LOADER_TYPE_TEXTURE,
+  ASSET_LOADER_TYPE_TILESET,
+  ASSET_LOADER_TYPE_LOCALE,
+  ASSET_LOADER_TYPE_JSON,
+  ASSET_LOADER_TYPE_SCRIPT,
+
+  ASSET_LOADER_TYPE_COUNT
+} assetloadertype_t;
+
+typedef union {
+  assetmeshloaderinput_t mesh;
+  assettextureloaderinput_t texture;
+  assettilesetloaderinput_t tileset;
+  assetlocaleloaderinput_t locale;
+  assetjsonloaderinput_t json;
+  assetscriptloaderinput_t script;
+} assetloaderinput_t;
+
+typedef union {
+  assetmeshloaderloading_t mesh;
+  assettextureloaderloading_t texture;
+  assettilesetloaderloading_t tileset;
+  assetlocaleloaderloading_t locale;
+  assetjsonloaderloading_t json;
+  assetscriptloaderloading_t script;
+} assetloaderloading_t;
+
+typedef union {
+  assetmeshoutput_t mesh;
+  assettextureoutput_t texture;
+  assettilesetoutput_t tileset;
+  assetlocaleoutput_t locale;
+  assetjsonoutput_t json;
+  assetscriptoutput_t script;
+} assetloaderoutput_t;
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+typedef errorret_t (assetloadersynccallback_t)(assetloading_t *loading);
+typedef errorret_t (assetloaderasynccallback_t)(assetloading_t *loading);
+typedef errorret_t (assetloaderdisposecallback_t)(assetentry_t *entry);
+
+typedef struct {
+  assetloadersynccallback_t *loadSync;
+  assetloaderasynccallback_t *loadAsync;
+  assetloaderdisposecallback_t *dispose;
+} assetloadercallbacks_t;
+
+extern assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT];
+
+/**
+ * Shorthand method to both chain an error (against the loader state) and to
+ * set the asset entry state to error.
+ * 
+ * @param loading The asset loading slot.
+ * @param ret The error return value to check and chain if it's an error.
+ */
+#define assetLoaderErrorChain(loading, _expr) {\
+  errorret_t _alec = (_expr); \
+  if(errorIsNotOk(_alec)) { \
+    (loading)->entry->state = ASSET_ENTRY_STATE_ERROR; \
+    errorChain(_alec); \
+  } \
+}
+
+/**
+ * Shorthand method to both throw an error (against the loader state) and to
+ * set the asset entry state to error.
+ * 
+ * @param loading The asset loading slot.
+ * @param ... Format string and arguments for the error message.
+ */
+#define assetLoaderErrorThrow(loading, ...) {\
+  loading->entry->state = ASSET_ENTRY_STATE_ERROR; \
+  errorThrow(__VA_ARGS__); \
+}

src/dusk/asset/loader/assetloading.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 "assetloader.h"
+#include "asset/assetfile.h"
+#include "thread/threadmutex.h"
+
+typedef struct assetentry_s assetentry_t;
+
+typedef struct assetloading_s {
+  // Protects entry pointer and entry->state from concurrent access.
+  threadmutex_t mutex;
+  // What type of asset is being loaded.
+  assetloadertype_t type;
+  // Referral back to the asset entry that will be kept alive after load done.
+  assetentry_t *entry;
+  // Information used during the load operation only.
+  assetloaderloading_t loading;
+} assetloading_t;
+
+typedef errorret_t (assetloadingcallback_t)(assetloading_t *loading);
+
+typedef struct {
+  assetloadingcallback_t *loadSync;
+} assetloadingcallbacks_t;

src/dusk/asset/loader/display/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
+target_sources(${DUSK_LIBRARY_TARGET_NAME}
+  PUBLIC
+    assetmeshloader.c
+    assettextureloader.c
+    assettilesetloader.c
+)

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

@@ -0,0 +1,174 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetmeshloader.h"
+#include "assert/assert.h"
+#include "util/endian.h"
+#include "util/memory.h"
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.h"
+
+errorret_t assetMeshLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  if(loading->loading.mesh.state != ASSET_MESH_LOADING_STATE_READ_FILE) {
+    errorOk();
+  }
+
+  assetmeshoutput_t *out = &loading->entry->data.mesh;
+  assetfile_t *file = &loading->loading.mesh.file;
+  assetmeshinputaxis_t axis = loading->entry->input->mesh;
+
+  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading, assetFileOpen(file));
+
+  // Skip the 80-byte STL header.
+  assetLoaderErrorChain(loading, assetFileRead(file, NULL, 80));
+  if(file->lastRead != 80) {
+    assetLoaderErrorThrow(loading, "Failed to skip STL header.");
+  }
+
+  uint32_t triangleCount;
+  assetLoaderErrorChain(loading, assetFileRead(file, &triangleCount, sizeof(uint32_t)));
+  if(file->lastRead != sizeof(uint32_t)) {
+    assetLoaderErrorThrow(loading, "Failed to read tri count");
+  }
+  triangleCount = endianLittleToHost32(triangleCount);
+
+  out->vertices = memoryAllocate(sizeof(meshvertex_t) * triangleCount * 3);
+  meshvertex_t *verts = out->vertices;
+
+  errorret_t ret;
+  for(uint32_t i = 0; i < triangleCount; i++) {
+    assetmeshstltriangle_t triData;
+    ret = assetFileRead(file, &triData, sizeof(triData));
+    if(errorIsNotOk(ret)) {
+      memoryFree(verts);
+      out->vertices = NULL;
+      assetLoaderErrorChain(loading, ret);
+    }
+    if(file->lastRead != sizeof(triData)) {
+      memoryFree(verts);
+      out->vertices = NULL;
+      assetLoaderErrorThrow(loading, "Failed to read triangle data");
+    }
+
+    for(uint8_t j = 0; j < 3; j++) {
+      #if MESH_ENABLE_COLOR
+        verts[i * 3 + j].color.r = (
+          (uint8_t)(endianLittleToHostFloat(triData.normal[0]) * 255.0f)
+        );
+        verts[i * 3 + j].color.g = (
+          (uint8_t)(endianLittleToHostFloat(triData.normal[1]) * 255.0f)
+        );
+        verts[i * 3 + j].color.b = (
+          (uint8_t)(endianLittleToHostFloat(triData.normal[2]) * 255.0f)
+        );
+        verts[i * 3 + j].color.a = 0xFF;
+      #endif
+
+      verts[i * 3 + j].uv[0] = 0.0f;
+      verts[i * 3 + j].uv[1] = 0.0f;
+
+      for(uint8_t k = 0; k < 3; k++) {
+        verts[i * 3 + j].pos[k] = endianLittleToHostFloat(triData.positions[j][k]);
+      }
+
+      switch(axis) {
+        case MESH_INPUT_AXIS_Z_UP: {
+          float_t temp = verts[i * 3 + j].pos[1];
+          verts[i * 3 + j].pos[1] = verts[i * 3 + j].pos[2];
+          verts[i * 3 + j].pos[2] = temp;
+          break;
+        }
+        case MESH_INPUT_AXIS_X_UP: {
+          float_t temp = verts[i * 3 + j].pos[0];
+          verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
+          verts[i * 3 + j].pos[1] = temp;
+          break;
+        }
+        case MESH_INPUT_AXIS_Y_DOWN:
+          verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[1];
+          break;
+        case MESH_INPUT_AXIS_Z_DOWN: {
+          float_t temp = verts[i * 3 + j].pos[1];
+          verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[2];
+          verts[i * 3 + j].pos[2] = temp;
+          break;
+        }
+        case MESH_INPUT_AXIS_X_DOWN: {
+          float_t temp = verts[i * 3 + j].pos[0];
+          verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
+          verts[i * 3 + j].pos[1] = -temp;
+          break;
+        }
+        case MESH_INPUT_AXIS_Y_UP:
+        default:
+          break;
+      }
+    }
+  }
+
+  ret = assetFileClose(file);
+  if(errorIsNotOk(ret)) {
+    memoryFree(verts);
+    out->vertices = NULL;
+    assetLoaderErrorChain(loading, ret);
+  }
+  assetFileDispose(file);
+
+  loading->loading.mesh.triangleCount = triangleCount;
+  loading->loading.mesh.state = ASSET_MESH_LOADING_STATE_CREATE_MESH;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetMeshLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(loading->type == ASSET_LOADER_TYPE_MESH, "Invalid type.");
+
+  switch(loading->loading.mesh.state) {
+    case ASSET_MESH_LOADING_STATE_INITIAL:
+      loading->loading.mesh.state = ASSET_MESH_LOADING_STATE_READ_FILE;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+
+    case ASSET_MESH_LOADING_STATE_CREATE_MESH:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  assetmeshoutput_t *out = &loading->entry->data.mesh;
+  assertNotNull(out->vertices, "Mesh vertices should have been loaded by now.");
+
+  errorret_t ret = meshInit(
+    &out->mesh,
+    MESH_PRIMITIVE_TYPE_TRIANGLES,
+    loading->loading.mesh.triangleCount * 3,
+    out->vertices
+  );
+  if(errorIsNotOk(ret)) {
+    loading->entry->state = ASSET_ENTRY_STATE_ERROR;
+    memoryFree(out->vertices);
+    out->vertices = NULL;
+    assetLoaderErrorChain(loading, ret);
+  }
+
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetMeshDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Asset entry cannot be NULL");
+  assertTrue(entry->type == ASSET_LOADER_TYPE_MESH, "Invalid type.");
+  errorChain(meshDispose(&entry->data.mesh.mesh));
+  memoryFree(entry->data.mesh.vertices);
+  errorOk();
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+#include "display/mesh/mesh.h"
+#include "assert/assert.h"
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+typedef enum {
+  MESH_INPUT_AXIS_Y_UP,
+  MESH_INPUT_AXIS_Z_UP,
+  MESH_INPUT_AXIS_X_UP,
+
+  MESH_INPUT_AXIS_Y_DOWN,
+  MESH_INPUT_AXIS_Z_DOWN,
+  MESH_INPUT_AXIS_X_DOWN,
+} assetmeshinputaxis_t;
+
+typedef assetmeshinputaxis_t assetmeshloaderinput_t;
+
+typedef enum {
+  ASSET_MESH_LOADING_STATE_INITIAL,
+  ASSET_MESH_LOADING_STATE_READ_FILE,
+  ASSET_MESH_LOADING_STATE_CREATE_MESH,
+  ASSET_MESH_LOADING_STATE_DONE
+} assetmeshloadingstate_t;
+
+typedef struct {
+  assetfile_t file;
+  assetmeshloadingstate_t state;
+  uint32_t triangleCount;
+} assetmeshloaderloading_t;
+
+typedef struct {
+  mesh_t mesh;
+  meshvertex_t *vertices;
+} assetmeshoutput_t;
+
+#pragma pack(push, 1)
+typedef struct {
+  vec3 normal;
+  float_t positions[3][3];
+  uint16_t attributeByteCount;
+} assetmeshstltriangle_t;
+#pragma pack(pop)
+
+assertStructSize(assetmeshstltriangle_t, 50);
+
+errorret_t assetMeshLoaderAsync(assetloading_t *loading);
+errorret_t assetMeshLoaderSync(assetloading_t *loading);
+errorret_t assetMeshDispose(assetentry_t *entry);

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

@@ -0,0 +1,165 @@
+/**
+ * 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"
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.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(errorIsNotOk(ret)) {
+    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(errorIsNotOk(ret)) {
+    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 assetTextureLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  // Only care about loading pixels.
+  if(loading->loading.texture.state != ASSET_TEXTURE_LOADING_STATE_LOAD_PIXELS){
+    errorOk();
+  }
+
+  // Init the file
+  assertNull(
+    loading->loading.texture.data, "Pixels already defined?"
+  );
+
+  assetfile_t *file = &loading->loading.texture.file;
+  assetLoaderErrorChain(loading, assetFileInit(
+    file,
+    loading->entry->name,
+    NULL,
+    &loading->entry->data.texture
+  ));
+  assetLoaderErrorChain(loading, assetFileOpen(file));
+
+  // Determine channels
+  int channelsDesired;
+  switch(loading->entry->input->texture) {
+    case TEXTURE_FORMAT_RGBA:
+      channelsDesired = 4;
+      break;
+
+    default:
+      assetLoaderErrorThrow(loading, "Bad texture format.");
+  }
+
+  // Load image pixels.
+  loading->loading.texture.data = stbi_load_from_callbacks(
+    &ASSET_TEXTURE_STB_CALLBACKS,
+    file,
+    &loading->loading.texture.width,
+    &loading->loading.texture.height,
+    &loading->loading.texture.channels,
+    channelsDesired
+  );
+
+  // Close out the file.
+  assetLoaderErrorChain(loading, assetFileClose(file));
+  assetLoaderErrorChain(loading, assetFileDispose(file));
+
+  // Ensure we loaded correctly.
+  if(loading->loading.texture.data == NULL) {
+    const char_t *errorStr = stbi_failure_reason();
+    assetLoaderErrorThrow(loading, "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(
+      loading->loading.texture.data,
+      loading->loading.texture.width,
+      loading->loading.texture.height,
+      loading->loading.texture.channels
+    );
+  }
+
+  loading->loading.texture.state = ASSET_TEXTURE_LOADING_STATE_CREATE_TEXTURE;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetTextureLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  switch(loading->loading.texture.state) {
+    case ASSET_TEXTURE_LOADING_STATE_INITIAL:
+      loading->loading.texture.state = ASSET_TEXTURE_LOADING_STATE_LOAD_PIXELS;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+      
+    case ASSET_TEXTURE_LOADING_STATE_CREATE_TEXTURE:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  // Create the texture.
+  assertNotNull(
+    loading->loading.texture.data, "Pixels should have been loaded by now."
+  );
+
+  assetLoaderErrorChain(loading, textureInit(
+    (texture_t*)&loading->entry->data.texture,
+    loading->loading.texture.width,
+    loading->loading.texture.height,
+    loading->entry->input->texture,
+    (texturedata_t){
+      .rgbaColors = (color_t*)loading->loading.texture.data
+    }
+  ));
+
+  // Free the pixels.
+  stbi_image_free(loading->loading.texture.data);
+
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetTextureDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Asset entry cannot be NULL");
+  return textureDispose(&entry->data.texture);
+}

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

@@ -0,0 +1,81 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+#include "display/texture/texture.h"
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+typedef textureformat_t assettextureloaderinput_t;
+
+typedef enum {
+  ASSET_TEXTURE_LOADING_STATE_INITIAL,
+  ASSET_TEXTURE_LOADING_STATE_LOAD_PIXELS,
+  ASSET_TEXTURE_LOADING_STATE_CREATE_TEXTURE,
+  ASSET_TEXTURE_LOADING_STATE_DONE
+} assettextureloadingstate_t;
+
+typedef struct {
+  assetfile_t file;
+  assettextureloadingstate_t state;
+
+  int channels, width, height;
+  uint8_t *data;
+} assettextureloaderloading_t;
+
+typedef texture_t assettextureoutput_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);
+
+/**
+ * STB image skip callback for asset files.
+ * 
+ * @param user User data passed to the callback, should be an assetfile_t*.
+ * @param n Number of bytes to skip in the file.
+ */
+void assetTextureSkipper(void *user, int n);
+
+/**
+ * STB image EOF callback for asset files.
+ * 
+ * @param user User data passed to the callback, should be an assetfile_t*.
+ * @return Non-zero if end of file has been reached, zero otherwise.
+ */
+int assetTextureEOF(void *user);
+
+/**
+ * Synchronous loader for texture assets.
+ * 
+ * @param loading Loading information for the asset being loaded.
+ * @return Error code indicating success or failure of the load operation.
+ */
+errorret_t assetTextureLoaderAsync(assetloading_t *loading);
+
+/**
+ * Synchronous loader for texture assets.
+ * 
+ * @param loading Loading information for the asset being loaded.
+ * @return Error code indicating success or failure of the load operation.
+ */
+errorret_t assetTextureLoaderSync(assetloading_t *loading);
+
+/**
+ * Disposer for texture assets.
+ * 
+ * @param entry Asset entry containing the texture to dispose.
+ * @return Error code indicating success or failure of the dispose operation.
+ */
+errorret_t assetTextureDispose(assetentry_t *entry);

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

@@ -0,0 +1,115 @@
+/**
+ * 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"
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.h"
+
+errorret_t assetTilesetLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  if(loading->loading.tileset.state != ASSET_TILESET_LOADING_STATE_READ_FILE) {
+    errorOk();
+  }
+
+  assertNull(loading->loading.tileset.data, "Data already defined?");
+
+  assetfile_t *file = &loading->loading.tileset.file;
+  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+
+  uint8_t *data = memoryAllocate(file->size);
+  assetLoaderErrorChain(loading, assetFileOpen(file));
+  assetLoaderErrorChain(loading, assetFileRead(file, data, file->size));
+  assetLoaderErrorChain(loading, assetFileClose(file));
+  assetLoaderErrorChain(loading, assetFileDispose(file));
+  assertTrue(file->lastRead == file->size, "Failed to read entire tileset file.");
+
+  loading->loading.tileset.data = data;
+  loading->loading.tileset.state = ASSET_TILESET_LOADING_STATE_PARSE;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetTilesetLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(loading->type == ASSET_LOADER_TYPE_TILESET, "Invalid type.");
+
+  switch(loading->loading.tileset.state) {
+    case ASSET_TILESET_LOADING_STATE_INITIAL:
+      loading->loading.tileset.state = ASSET_TILESET_LOADING_STATE_READ_FILE;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+
+    case ASSET_TILESET_LOADING_STATE_PARSE:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  uint8_t *data = loading->loading.tileset.data;
+  assertNotNull(data, "Tileset data should have been loaded by now.");
+
+  tileset_t *out = &loading->entry->data.tileset;
+
+  if(data[0] != 'D' || data[1] != 'T' || data[2] != 'F') {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Invalid tileset header");
+  }
+
+  if(data[3] != 0x00) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Unsupported tileset version");
+  }
+
+  out->tileWidth = endianLittleToHost16(*(uint16_t *)(data + 4));
+  out->tileHeight = endianLittleToHost16(*(uint16_t *)(data + 6));
+  out->columns = endianLittleToHost16(*(uint16_t *)(data + 8));
+  out->rows = endianLittleToHost16(*(uint16_t *)(data + 10));
+
+  if(out->tileWidth == 0) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Tile width cannot be 0");
+  }
+  if(out->tileHeight == 0) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Tile height cannot be 0");
+  }
+  if(out->columns == 0) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Column count cannot be 0");
+  }
+  if(out->rows == 0) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Row count cannot be 0");
+  }
+
+  out->uv[0] = endianLittleToHostFloat(*(float *)(data + 16));
+  out->uv[1] = endianLittleToHostFloat(*(float *)(data + 20));
+
+  if(out->uv[1] < 0.0f || out->uv[1] > 1.0f) {
+    memoryFree(data);
+    assetLoaderErrorThrow(loading, "Invalid v0 value in tileset");
+  }
+
+  out->tileCount = out->columns * out->rows;
+  memoryFree(data);
+  loading->loading.tileset.data = NULL;
+
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetTilesetDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Entry cannot be NULL");
+  assertTrue(entry->type == ASSET_LOADER_TYPE_TILESET, "Invalid type.");
+  errorOk();
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+#include "display/texture/tileset.h"
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+typedef struct {
+  void *nothing;
+} assettilesetloaderinput_t;
+
+typedef enum {
+  ASSET_TILESET_LOADING_STATE_INITIAL,
+  ASSET_TILESET_LOADING_STATE_READ_FILE,
+  ASSET_TILESET_LOADING_STATE_PARSE,
+  ASSET_TILESET_LOADING_STATE_DONE
+} assettilesetloadingstate_t;
+
+typedef struct {
+  assetfile_t file;
+  assettilesetloadingstate_t state;
+
+  uint8_t *data;
+} assettilesetloaderloading_t;
+
+typedef tileset_t assettilesetoutput_t;
+
+/**
+ * Asynchronous loader for tileset assets. Reads the raw DTF file bytes into
+ * the loading buffer so the sync phase can parse without blocking the main
+ * thread on I/O.
+ *
+ * @param loading Loading information for the asset being loaded.
+ * @return Error code indicating success or failure of the load operation.
+ */
+errorret_t assetTilesetLoaderAsync(assetloading_t *loading);
+
+/**
+ * Synchronous loader for tileset assets. Parses the DTF binary previously
+ * read by the async phase and populates the output tileset_t.
+ *
+ * @param loading Loading information for the asset being loaded.
+ * @return Error code indicating success or failure of the load operation.
+ */
+errorret_t assetTilesetLoaderSync(assetloading_t *loading);
+
+/**
+ * Disposer for tileset assets.
+ *
+ * @param entry Asset entry containing the tileset to dispose.
+ * @return Error code indicating success or failure of the dispose operation.
+ */
+errorret_t assetTilesetDispose(assetentry_t *entry);

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

@@ -6,5 +6,5 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    moduletime.c
+    assetjsonloader.c
 )

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

@@ -0,0 +1,88 @@
+/**
+ * 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"
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.h"
+
+errorret_t assetJsonLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  if(loading->loading.json.state != ASSET_JSON_LOADING_STATE_READ_FILE) {
+    errorOk();
+  }
+
+  assertNull(loading->loading.json.buffer, "Buffer already defined?");
+
+  assetfile_t *file = &loading->loading.json.file;
+  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+
+  if(file->size > ASSET_JSON_FILE_SIZE_MAX) {
+    assetLoaderErrorThrow(loading, "JSON exceeds maximum allowed size");
+  }
+
+  size_t fileSize = (size_t)file->size;
+  uint8_t *buffer = memoryAllocate(fileSize);
+  assetLoaderErrorChain(loading, assetFileOpen(file));
+  assetLoaderErrorChain(loading, assetFileRead(file, buffer, fileSize));
+  assertTrue(file->lastRead == file->size, "Failed to read entire JSON file.");
+  assetLoaderErrorChain(loading, assetFileClose(file));
+  assetLoaderErrorChain(loading, assetFileDispose(file));
+
+  loading->loading.json.buffer = buffer;
+  loading->loading.json.size = fileSize;
+  loading->loading.json.state = ASSET_JSON_LOADING_STATE_PARSE;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetJsonLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(loading->type == ASSET_LOADER_TYPE_JSON, "Invalid type.");
+
+  switch(loading->loading.json.state) {
+    case ASSET_JSON_LOADING_STATE_INITIAL:
+      loading->loading.json.state = ASSET_JSON_LOADING_STATE_READ_FILE;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+
+    case ASSET_JSON_LOADING_STATE_PARSE:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  uint8_t *buffer = loading->loading.json.buffer;
+  assertNotNull(buffer, "JSON buffer should have been loaded by now.");
+
+  loading->entry->data.json = yyjson_read(
+    (char *)buffer,
+    loading->loading.json.size,
+    YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS
+  );
+  memoryFree(buffer);
+  loading->loading.json.buffer = NULL;
+
+  if(!loading->entry->data.json) {
+    assetLoaderErrorThrow(loading, "Failed to parse JSON");
+  }
+
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetJsonDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Asset entry cannot be NULL");
+  assertTrue(entry->type == ASSET_LOADER_TYPE_JSON, "Invalid type.");
+  yyjson_doc_free(entry->data.json);
+  entry->data.json = NULL;
+  errorOk();
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+#include "yyjson.h"
+
+#define ASSET_JSON_FILE_SIZE_MAX 1024*256
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+typedef struct { void *nothing; } assetjsonloaderinput_t;
+
+typedef enum {
+  ASSET_JSON_LOADING_STATE_INITIAL,
+  ASSET_JSON_LOADING_STATE_READ_FILE,
+  ASSET_JSON_LOADING_STATE_PARSE,
+  ASSET_JSON_LOADING_STATE_DONE
+} assetjsonloadingstate_t;
+
+typedef struct {
+  assetfile_t file;
+  assetjsonloadingstate_t state;
+  uint8_t *buffer;
+  size_t size;
+} assetjsonloaderloading_t;
+
+typedef yyjson_doc * assetjsonoutput_t;
+
+errorret_t assetJsonLoaderAsync(assetloading_t *loading);
+errorret_t assetJsonLoaderSync(assetloading_t *loading);
+errorret_t assetJsonDispose(assetentry_t *entry);

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

@@ -6,5 +6,5 @@
 # Sources
 target_sources(${DUSK_LIBRARY_TARGET_NAME}
   PUBLIC
-    modulelocale.c
+    assetlocaleloader.c
 )

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

@@ -0,0 +1,849 @@
+/**
+ * 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"
+
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.h"
+
+errorret_t assetLocaleLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  if(loading->loading.locale.state != ASSET_LOCALE_LOADER_STATE_LOAD_HEADER) {
+    errorOk();
+  }
+
+  assetlocalefile_t *localeFile = &loading->entry->data.locale;
+  memoryZero(localeFile, sizeof(assetlocalefile_t));
+  assetLoaderErrorChain(loading, assetFileInit(&localeFile->file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading, assetFileOpen(&localeFile->file));
+
+  char_t buffer[1024];
+  assetLoaderErrorChain(loading, assetLocaleGetString(localeFile, "", 0, buffer, sizeof(buffer)));
+  assetLoaderErrorChain(loading, assetLocaleParseHeader(localeFile, buffer, sizeof(buffer)));
+
+  loading->loading.locale.state = ASSET_LOCALE_LOADER_STATE_DONE;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetLocaleLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(loading->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type.");
+
+  switch(loading->loading.locale.state) {
+    case ASSET_LOCALE_LOADER_STATE_INITIAL:
+      loading->loading.locale.state = ASSET_LOCALE_LOADER_STATE_LOAD_HEADER;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+
+    case ASSET_LOCALE_LOADER_STATE_DONE:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetLocaleDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Asset entry cannot be NULL");
+  assertTrue(entry->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type.");
+  assetlocalefile_t *localeFile = &entry->data.locale;
+  errorChain(assetFileClose(&localeFile->file));
+  return assetFileDispose(&localeFile->file);
+}
+
+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 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') {
+      errorret_t r = assetFileLineReaderNext(reader);
+      if(errorIsNotOk(r)) {
+        errorCatch(r);
+        break;
+      }
+      continue;
+    }
+
+    // Skip comment lines
+    if(lineBuffer[0] == '#') {
+      errorret_t r = assetFileLineReaderNext(reader);
+      if(errorIsNotOk(r)) {
+        errorCatch(r);
+        break;
+      }
+      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) {
+      errorret_t r = assetFileLineReaderNext(reader);
+      if(errorIsNotOk(r)) {
+        errorCatch(r);
+        break;
+      }
+      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) {
+    errorret_t r = assetFileLineReaderNext(reader);
+    if(errorIsNotOk(r)) {
+      errorCatch(r);
+      break;
+    }
+
+    // Skip blank lines
+    r = assetLocaleLineSkipBlanks(reader, lineBuffer);
+    if(errorIsNotOk(r)) {
+      errorCatch(r);
+      break;
+    }
+    
+    // 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(errorIsNotOk(ret)) {
+    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(errorIsNotOk(ret)) {
+    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,281 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+/** Input passed to the locale loader — currently unused. */
+typedef struct { void *nothing; } assetlocaleloaderinput_t;
+
+typedef enum {
+  ASSET_LOCALE_LOADER_STATE_INITIAL,
+  ASSET_LOCALE_LOADER_STATE_LOAD_HEADER,
+  ASSET_LOCALE_LOADER_STATE_DONE
+} assetlocaleloaderstate_t;
+
+/** Per-slot scratch data used while the locale file is loading. */
+typedef struct {
+  assetlocaleloaderstate_t state;
+} assetlocaleloaderloading_t;
+
+/** Maximum number of distinct plural forms a locale file may declare. */
+#define ASSET_LOCALE_FILE_PLURAL_FORM_COUNT 6
+
+/**
+ * Comparison operator used in a plural-form expression.
+ *
+ * Each condition in the plural-form header is evaluated as
+ *   `n <op> value`
+ * where `n` is the runtime plural count.
+ */
+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;
+
+/**
+ * Discriminator tag for a locale string argument.
+ * @see assetlocalearg_t
+ */
+typedef enum {
+  ASSET_LOCALE_ARG_STRING,
+  ASSET_LOCALE_ARG_INT,
+  ASSET_LOCALE_ARG_FLOAT
+} assetlocaleargtype_t;
+
+/**
+ * A single typed argument for locale string substitution.
+ *
+ * Used with @ref assetLocaleGetStringWithArgs to fill `%s`, `%d`, or `%f`
+ * placeholders inside a translated string.
+ */
+typedef struct {
+  /** Which union member is active. */
+  assetlocaleargtype_t type;
+  union {
+    const char_t *stringValue;
+    int32_t intValue;
+    float_t floatValue;
+  };
+} assetlocalearg_t;
+
+/**
+ * Runtime state for an open locale file.
+ *
+ * Loaded once by @ref assetLocaleLoaderSync and kept alive for the lifetime
+ * of the asset entry. The plural-form fields are populated from the PO header
+ * by @ref assetLocaleParseHeader.
+ *
+ * Plural evaluation works as a linear scan over `pluralStateCount - 1`
+ * conditions; if none match, `pluralDefaultIndex` is returned.
+ */
+typedef struct {
+  /** Underlying file handle used to rewind and re-read the PO data. */
+  assetfile_t file;
+
+  /** Comparison operator for each conditional plural clause. */
+  assetlocalepluraloperation_t pluralOps[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+
+  /** Right-hand value for each conditional plural clause. */
+  int32_t pluralValues[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+
+  /** Form index returned when the corresponding condition is true. */
+  int32_t pluralIndices[ASSET_LOCALE_FILE_PLURAL_FORM_COUNT];
+
+  /** Total number of plural forms declared by `nplurals=`. */
+  uint8_t pluralStateCount;
+
+  /** Form index used when no conditional clause matches. */
+  uint8_t pluralDefaultIndex;
+} assetlocalefile_t;
+
+/** Convenience alias — the loaded output type of a locale asset entry. */
+typedef assetlocalefile_t assetlocaleoutput_t;
+
+/**
+ * Asynchronous loader callback. Opens the locale file, reads the PO header,
+ * and parses plural-form rules. All I/O happens here so the main thread is
+ * not blocked. Sets entry state to `ASSET_ENTRY_STATE_PENDING_SYNC` on
+ * success or `ASSET_ENTRY_STATE_ERROR` on failure.
+ *
+ * @param loading The loading slot for this asset entry.
+ * @return OK on success, error otherwise.
+ */
+errorret_t assetLocaleLoaderAsync(assetloading_t *loading);
+
+/**
+ * Synchronous loader callback. Confirms the async phase completed and marks
+ * the entry as `ASSET_ENTRY_STATE_LOADED`.
+ *
+ * @param loading The loading slot for this asset entry.
+ * @return OK on success, error otherwise.
+ */
+errorret_t assetLocaleLoaderSync(assetloading_t *loading);
+
+/**
+ * Dispose callback. Closes the open file handle and zeros the locale data.
+ *
+ * @param entry The asset entry to dispose.
+ * @return OK on success, error otherwise.
+ */
+errorret_t assetLocaleDispose(assetentry_t *entry);
+
+/**
+ * Parses the `Plural-Forms:` line from a PO header string and populates the
+ * plural-form fields of `localeFile`. If no `Plural-Forms:` key is present
+ * the function returns OK without modifying the struct.
+ *
+ * Supports the `nplurals=N; plural=(<expr>);` syntax where `<expr>` is a
+ * chain of `n <op> value ? index : ...` ternary conditions ending with a
+ * fallback index.
+ *
+ * @param localeFile  Struct whose plural fields will be filled in.
+ * @param headerBuffer  The raw PO header string (msgstr of msgid "").
+ * @param headerBufferSize  Size of `headerBuffer` in bytes.
+ * @return OK on success, error if the plural expression is malformed.
+ */
+errorret_t assetLocaleParseHeader(
+  assetlocalefile_t *localeFile,
+  char_t *headerBuffer,
+  const size_t headerBufferSize
+);
+
+/**
+ * Evaluates which plural form index to use for a given count.
+ *
+ * Walks the conditions stored in `file` in order; returns the index for the
+ * first condition that matches `pluralCount`. Falls back to
+ * `file->pluralDefaultIndex` if none match.
+ *
+ * @param file  Locale file with parsed plural rules.
+ * @param pluralCount  The runtime count (e.g. number of items).
+ * @return Zero-based plural form index.
+ */
+uint8_t assetLocaleEvaluatePlural(
+  assetlocalefile_t *file,
+  const int32_t pluralCount
+);
+
+/**
+ * Advances the line reader past blank lines, comment lines (starting with
+ * `#`), and lines containing only spaces. Stops at the first content line or
+ * end of file.
+ *
+ * @param reader  Line reader positioned at the current line.
+ * @param lineBuffer  Output buffer that the reader writes each line into.
+ * @return OK on success, error if reading fails.
+ */
+errorret_t assetLocaleLineSkipBlanks(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer
+);
+
+/**
+ * Reads a PO quoted string value from the current line and any immediately
+ * following continuation lines that begin with `"`.
+ *
+ * Handles standard C escape sequences (`\n`, `\t`, `\\`, `\"`).
+ *
+ * @param reader  Line reader positioned at the line containing the opening
+ *                quote (e.g. `msgstr "..."`).
+ * @param lineBuffer  Buffer the reader fills on each @ref assetFileLineReaderNext
+ *                    call; also used to detect continuation lines.
+ * @param stringBuffer  Destination for the unescaped string content.
+ * @param stringBufferSize  Capacity of `stringBuffer` in bytes.
+ * @return OK on success, error if a quote or escape sequence is malformed or
+ *         the buffer would overflow.
+ */
+errorret_t assetLocaleLineUnbuffer(
+  assetfilelinereader_t *reader,
+  uint8_t *lineBuffer,
+  uint8_t *stringBuffer,
+  const size_t stringBufferSize
+);
+
+/**
+ * Looks up a translated string by message ID from the open locale file.
+ *
+ * Rewinds the file and scans from the beginning on every call. For plural
+ * entries (`msgid_plural`) the `pluralCount` is evaluated against the loaded
+ * plural rules to select the correct `msgstr[N]` form.
+ *
+ * @param file  Locale file to search. Must be open.
+ * @param messageId  PO message ID to find (`""` retrieves the header entry).
+ * @param pluralCount  Count used to select the plural form (ignored for
+ *                     singular entries).
+ * @param stringBuffer  Buffer to receive the translated string.
+ * @param stringBufferSize  Capacity of `stringBuffer` in bytes.
+ * @return OK on success, error if the message ID is not found or I/O fails.
+ */
+errorret_t assetLocaleGetString(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *stringBuffer,
+  const size_t stringBufferSize
+);
+
+/**
+ * Looks up a translated string and formats it with a `printf`-style variadic
+ * argument list.
+ *
+ * Retrieves the raw format string via @ref assetLocaleGetString then applies
+ * `vsnprintf` with the provided arguments.
+ *
+ * @param file  Locale file to search. Must be open.
+ * @param messageId  PO message ID to find.
+ * @param pluralCount  Count used to select the plural form.
+ * @param buffer  Buffer to receive the formatted string.
+ * @param bufferSize  Capacity of `buffer` in bytes.
+ * @param ...  Format arguments matching the specifiers in the translated
+ *             string.
+ * @return OK on success, error if the message is not found or formatting
+ *         fails.
+ */
+errorret_t assetLocaleGetStringWithVA(
+  assetlocalefile_t *file,
+  const char_t *messageId,
+  const int32_t pluralCount,
+  char_t *buffer,
+  const size_t bufferSize,
+  ...
+);
+
+/**
+ * Looks up a translated string and substitutes typed arguments into its
+ * `%s`, `%d`, and `%f` placeholders.
+ *
+ * Unlike @ref assetLocaleGetStringWithVA this variant accepts an explicit
+ * array of @ref assetlocalearg_t values, which is safer to use from
+ * generated or scripted call sites.
+ *
+ * @param file  Locale file to search. Must be open.
+ * @param messageId  PO message ID to find.
+ * @param pluralCount  Count used to select the plural form.
+ * @param buffer  Buffer to receive the formatted string.
+ * @param bufferSize  Capacity of `buffer` in bytes.
+ * @param args  Array of typed arguments; may be NULL when `argCount` is 0.
+ * @param argCount  Number of elements in `args`.
+ * @return OK on success, error if the message is not found, an argument type
+ *         mismatches the specifier, or the buffer would overflow.
+ */
+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

@@ -1,10 +1,9 @@
 # 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
-    moduleitem.c
-)
+    assetscriptloader.c
+)

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

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetscriptloader.h"
+#include "asset/loader/assetloading.h"
+#include "asset/loader/assetentry.h"
+#include "asset/loader/assetloader.h"
+#include "util/memory.h"
+#include "assert/assert.h"
+#include <jerryscript.h>
+
+errorret_t assetScriptLoaderAsync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+
+  if(loading->loading.script.state != ASSET_SCRIPT_LOADING_STATE_READ_FILE) {
+    errorOk();
+  }
+
+  assertNull(loading->loading.script.buffer, "Buffer already defined?");
+
+  assetfile_t *file = &loading->loading.script.file;
+  assetLoaderErrorChain(loading, assetFileInit(file, loading->entry->name, NULL, NULL));
+  assetLoaderErrorChain(loading, assetFileOpen(file));
+
+  size_t capacity = ASSET_SCRIPT_CHUNK_SIZE;
+  uint8_t *buffer = memoryAllocate(capacity + 1);
+  size_t offset = 0;
+
+  while(1) {
+    if(offset + ASSET_SCRIPT_CHUNK_SIZE > capacity) {
+      size_t oldCapacity = capacity + 1;
+      capacity += ASSET_SCRIPT_CHUNK_SIZE;
+      memoryResize((void **)&buffer, oldCapacity, capacity + 1);
+    }
+    assetLoaderErrorChain(loading, assetFileRead(
+      file, buffer + offset, ASSET_SCRIPT_CHUNK_SIZE
+    ));
+    size_t chunk = (size_t)file->lastRead;
+    offset += chunk;
+    if(chunk == 0) break;
+  }
+
+  buffer[offset] = '\0';
+  assetLoaderErrorChain(loading, assetFileClose(file));
+  assetLoaderErrorChain(loading, assetFileDispose(file));
+
+  loading->loading.script.buffer = buffer;
+  loading->loading.script.size = offset;
+  loading->loading.script.state = ASSET_SCRIPT_LOADING_STATE_EXEC;
+  loading->entry->state = ASSET_ENTRY_STATE_PENDING_SYNC;
+  errorOk();
+}
+
+errorret_t assetScriptLoaderSync(assetloading_t *loading) {
+  assertNotNull(loading, "Loading cannot be NULL");
+  assertTrue(loading->type == ASSET_LOADER_TYPE_SCRIPT, "Invalid type.");
+
+  switch(loading->loading.script.state) {
+    case ASSET_SCRIPT_LOADING_STATE_INITIAL:
+      loading->loading.script.state = ASSET_SCRIPT_LOADING_STATE_READ_FILE;
+      loading->entry->state = ASSET_ENTRY_STATE_PENDING_ASYNC;
+      errorOk();
+      break;
+
+    case ASSET_SCRIPT_LOADING_STATE_EXEC:
+      break;
+
+    default:
+      errorOk();
+  }
+
+  uint8_t *buffer = loading->loading.script.buffer;
+  assertNotNull(buffer, "Script buffer should have been loaded by now.");
+
+  jerry_value_t result = jerry_eval(
+    (const jerry_char_t *)buffer,
+    loading->loading.script.size,
+    JERRY_PARSE_NO_OPTS
+  );
+  memoryFree(buffer);
+  loading->loading.script.buffer = NULL;
+
+  if(jerry_value_is_exception(result)) {
+    jerry_value_t errVal = jerry_exception_value(result, false);
+    jerry_value_t errStr = jerry_value_to_string(errVal);
+    char_t buf[256];
+    jerry_size_t len = jerry_string_to_buffer(
+      errStr, JERRY_ENCODING_UTF8, (jerry_char_t *)buf, sizeof(buf) - 1
+    );
+    buf[len] = '\0';
+    jerry_value_free(errStr);
+    jerry_value_free(errVal);
+    jerry_value_free(result);
+    assetLoaderErrorThrow(loading, "Script error in '%s': %s",
+      loading->entry->name, buf
+    );
+  }
+
+  loading->entry->data.script = (assetscriptoutput_t)result;
+  loading->entry->state = ASSET_ENTRY_STATE_LOADED;
+  errorOk();
+}
+
+errorret_t assetScriptDispose(assetentry_t *entry) {
+  assertNotNull(entry, "Asset entry cannot be NULL");
+  assertTrue(entry->type == ASSET_LOADER_TYPE_SCRIPT, "Invalid type.");
+  if(entry->data.script != 0) {
+    jerry_value_free((jerry_value_t)entry->data.script);
+    entry->data.script = 0;
+  }
+  errorOk();
+}

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

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2026 Dominic Masters
+ *
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetfile.h"
+
+#define ASSET_SCRIPT_CHUNK_SIZE 1024
+
+typedef struct assetloading_s assetloading_t;
+typedef struct assetentry_s assetentry_t;
+
+typedef struct { void *nothing; } assetscriptloaderinput_t;
+typedef uint32_t assetscriptoutput_t;
+
+typedef enum {
+  ASSET_SCRIPT_LOADING_STATE_INITIAL,
+  ASSET_SCRIPT_LOADING_STATE_READ_FILE,
+  ASSET_SCRIPT_LOADING_STATE_EXEC,
+  ASSET_SCRIPT_LOADING_STATE_DONE
+} assetscriptloadingstate_t;
+
+typedef struct {
+  assetfile_t file;
+  assetscriptloadingstate_t state;
+  uint8_t *buffer;
+  size_t size;
+} assetscriptloaderloading_t;
+
+errorret_t assetScriptLoaderAsync(assetloading_t *loading);
+errorret_t assetScriptLoaderSync(assetloading_t *loading);
+errorret_t assetScriptDispose(assetentry_t *entry);

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/console/CMakeLists.txt

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