gfx-playground

branch out

--- a/.clang-format
+++ b/.clang-format
@@ -0,0 +1,31 @@
+BasedOnStyle: LLVM
+
+ColumnLimit: 120
+IndentWidth: 4
+
+PointerAlignment: Right
+ReferenceAlignment: Right
+
+BinPackArguments: false
+BinPackParameters: false
+AlignAfterOpenBracket: BlockIndent
+
+BreakBeforeBraces: Attach
+BreakAfterReturnType: ExceptShortType
+AlwaysBreakAfterDefinitionReturnType: None
+
+AllowShortNamespacesOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+
+AlignConsecutiveMacros: true
+
+Macros:
+  - GPU_PTR(x)=x
+  - GPU_HND(x)=x
+  - STATIC_CONST(x)=x

--- a/.clang-tidy
+++ b/.clang-tidy
@@ -0,0 +1,33 @@
+Checks: >
+  -*,
+  readability-braces-around-statements,
+  google-runtime-int,
+  readability-identifier-naming,
+  readability-simplify-boolean-expr,
+  readability-else-after-return,
+  readability-avoid-nested-conditional-operator,
+  bugprone-sizeof-expression,
+  bugprone-unused-raii,
+  performance-no-int-to-ptr,
+  cert-err33-c,
+  clang-analyzer-core,
+  clang-analyzer-security,
+  -clang-analyzer-security.insecureAPI.strcpy,
+  -clang-analyzer-security.insecureAPI.gets
+
+CheckOptions:
+  - { key: "google-runtime-int.UnsignedTypePrefix", value: "u" }
+  - { key: "google-runtime-int.SignedTypePrefix", value: "i" }
+  - { key: "readability-identifier-naming.VariableCase", value: "lower_case" }
+  - { key: "readability-identifier-naming.FunctionCase", value: "lower_case" }
+  - {
+      key: "readability-identifier-naming.GlobalVariableCase",
+      value: "UPPER_CASE",
+    }
+  - { key: "readability-identifier-naming.MacroCase", value: "UPPER_CASE" }
+  - { key: "readability-identifier-naming.EnumCase", value: "CamelCase" }
+  - { key: "readability-identifier-naming.StructCase", value: "CamelCase" }
+  - { key: "readability-identifier-naming.TypedefCase", value: "lower_case" }
+
+WarningsAsErrors: "*"
+HeaderFilterRegex: ".*/src/.*"

--- a/.clangd
+++ b/.clangd
@@ -0,0 +1,2 @@
+CompileFlags:
+  CompilationDatabase: build

--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,20 @@
+* text eol=lf
+*.bat text eol=crlf
+*.ps1 text eol=crlf
+*.sh text=auto eol=lf
+*.md text eol=lf
+
+*.glb binary
+*.gltf text
+*.bin binary
+*.ttf binary
+*.otf binary
+*.woff binary
+*.woff2 binary
+*.eot binary
+*.png  binary
+*.jpg  binary
+*.jpeg binary
+*.gif  binary
+*.webp binary
+*.ico  binary

--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,13 @@
+notes/
+.cache/
+.vscode/
+.DS_Store
+.idea/
+*.log
+*.tmp
+build/
+cmake/
+compile_commands.json
+third-party/*/
+assets/
+imgui.ini<
\ No newline at end of file

--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,21 @@
+[submodule "third-party/glfw"]
+	path = third-party/glfw
+	url = https://github.com/glfw/glfw.git
+[submodule "third-party/VMA"]
+	path = third-party/VMA
+	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "third-party/rtm"]
+	path = third-party/rtm
+	url = https://github.com/nfrechette/rtm.git
+[submodule "third-party/imgui"]
+	path = third-party/imgui
+	url = https://github.com/ocornut/imgui.git
+[submodule "third-party/KTX-Software"]
+	path = third-party/KTX-Software
+	url = https://github.com/KhronosGroup/KTX-Software.git
+[submodule "third-party/plog"]
+	path = third-party/plog
+	url = https://github.com/SergiusTheBest/plog
+[submodule "third-party/metal-cpp"]
+	path = third-party/metal-cpp
+	url = https://github.com/apple/metal-cpp

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -0,0 +1,266 @@
+cmake_minimum_required(VERSION 3.31.0)
+project(vk-renderer)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/build)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/build)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/build)
+
+find_package(Vulkan REQUIRED)
+
+# glfw
+set(GLFW_BUILD_DOCS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+add_subdirectory(${CMAKE_SOURCE_DIR}/third-party/glfw)
+
+# VMA
+add_subdirectory(${CMAKE_SOURCE_DIR}/third-party/VMA)
+
+# KTX
+set(KTX_FEATURE_TESTS OFF CACHE BOOL "" FORCE)
+set(KTX_FEATURE_TOOLS OFF CACHE BOOL "" FORCE)
+set(KTX_FEATURE_DOC OFF CACHE BOOL "" FORCE)
+set(KTX_FEATURE_GL_UPLOAD OFF CACHE BOOL "" FORCE)
+set(KTX_FEATURE_VK_UPLOAD OFF CACHE BOOL "" FORCE)
+set(KTX_FEATURE_LOADTEST_APPS OFF CACHE BOOL "" FORCE)
+add_subdirectory(${CMAKE_SOURCE_DIR}/third-party/KTX-Software)
+
+# plog
+add_subdirectory(${CMAKE_SOURCE_DIR}/third-party/plog)
+
+# rtm (header-only math library)
+add_library(rtm INTERFACE)
+target_include_directories(rtm INTERFACE ${CMAKE_SOURCE_DIR}/third-party/rtm/includes)
+
+# tracy
+set(ENABLE_TRACY OFF)
+if(ENABLE_TRACY)
+    add_subdirectory(${CMAKE_SOURCE_DIR}/third-party/tracy)
+    add_compile_definitions(TRACY_ENABLE)
+endif()
+
+set(ENABLE_EDITOR ON)
+if(ENABLE_EDITOR)
+    add_compile_definitions(ENABLE_EDITOR)
+endif()
+
+# slang
+include(FetchContent)
+set(SLANG_VERSION "2026.17.1")
+
+
+if(WIN32)
+    set(SLANG_URL "https://github.com/shader-slang/slang/releases/download/v${SLANG_VERSION}/slang-${SLANG_VERSION}-windows-x86_64.zip")
+elseif(APPLE)
+    set(SLANG_URL "https://github.com/shader-slang/slang/releases/download/v${SLANG_VERSION}/slang-${SLANG_VERSION}-macos-aarch64.tar.gz")
+else()
+    set(SLANG_URL "https://github.com/shader-slang/slang/releases/download/v${SLANG_VERSION}/slang-${SLANG_VERSION}-linux-x86_64.tar.gz")
+endif()
+FetchContent_Declare(slang URL ${SLANG_URL})
+FetchContent_MakeAvailable(slang)
+set(SLANG_ROOT ${slang_SOURCE_DIR})
+if(WIN32)
+    set(SLANG_LIB ${SLANG_ROOT}/lib/slang.lib)
+elseif(APPLE)
+    set(SLANG_LIB ${SLANG_ROOT}/lib/libslang.dylib)
+else()
+    set(SLANG_LIB ${SLANG_ROOT}/lib/libslang.so)
+endif()
+
+set(IMGUI_DIR ${CMAKE_SOURCE_DIR}/third-party/imgui)
+
+add_executable(${PROJECT_NAME}
+    src/renderer.cpp
+    src/quick_submit.cpp
+    src/pipelines.cpp
+    src/passes/fg.cpp
+    #
+    src/asset/asset.cpp
+    src/asset/texture.cpp
+    src/asset/gltf.cpp
+    #
+    third-party/mikktspace.c
+    #
+    src/scene/scene.cpp
+    src/scene/ibl.cpp
+    #
+    src/backend/vulkan/context.cpp
+    src/backend/vulkan/swapchain.cpp
+    src/backend/vulkan/pipeline.cpp
+    src/backend/vulkan/descriptors.cpp
+    src/backend/vulkan/debug.cpp
+    src/backend/vulkan/query_pool.cpp
+    src/backend/vulkan/cmd_pool.cpp
+    src/backend/vulkan/cmd_buffer.cpp
+    src/backend/vulkan/allocator.cpp
+    src/backend/vulkan/queue.cpp
+    src/backend/vulkan/buffer.cpp
+    src/backend/vulkan/image.cpp
+    src/backend/vulkan/sampler.cpp
+    src/backend/vulkan/shader.cpp
+    src/backend/vulkan/accel_struct.cpp
+    src/backend/vulkan/vk_conversion.cpp
+    src/backend/vulkan/rhi_helpers.cpp
+    #
+    src/core/arena.cpp
+    src/core/platform.cpp
+    src/core/math_rtm.cpp
+    src/core/logger.cpp
+    #
+    src/passes/ssr/ssr.cpp
+    # src/passes/pass_frustum_debug.cpp
+    src/passes/depth_pre/depth_normal.cpp
+    src/passes/dispatch_mdi/build_indirect.cpp
+    src/passes/forward/forward.cpp
+    src/passes/fwd_cpu/fwd_cpu.cpp
+    src/passes/shadow/shadow.cpp
+    src/passes/grid/grid.cpp
+    src/passes/id_blit/id_blit.cpp
+    src/passes/fullscreen/fullscreen.cpp
+    src/passes/cluster/cluster_bounds.cpp
+    src/passes/cluster/light_cull.cpp
+    src/passes/hiz/hiz.cpp
+    src/passes/imgui/imgui.cpp
+    src/passes/skybox/skybox.cpp
+    src/passes/rt_build.cpp
+    src/passes/ddgi/ddgi_trace.cpp
+    src/passes/ddgi/ddgi_update.cpp
+    src/passes/ddgi/ddgi_classify.cpp
+    src/passes/ddgi/ddgi_relocate.cpp
+    src/passes/ddgi/ddgi_probes_dbg.cpp
+    src/passes/debug/debug_lines.cpp
+)
+
+if(ENABLE_EDITOR)
+    target_sources(${PROJECT_NAME} PRIVATE
+        src/editor/editor.cpp
+        src/editor/debug_draw.cpp
+        src/editor/frame.cpp
+        src/editor/gizmo.cpp
+        src/editor/style.cpp
+        src/editor/viewport.cpp
+        src/editor/log_viewer.cpp
+        src/editor/texture_viewer.cpp
+        src/editor/targets.cpp
+        src/editor/timings.cpp
+        src/editor/hierarchy.cpp
+        src/editor/inspector.cpp
+        src/backend/imgui_backend.cpp
+        ${IMGUI_DIR}/imgui.cpp
+        ${IMGUI_DIR}/imgui_draw.cpp
+        ${IMGUI_DIR}/imgui_tables.cpp
+        ${IMGUI_DIR}/imgui_widgets.cpp
+        ${IMGUI_DIR}/imgui_demo.cpp
+        ${IMGUI_DIR}/backends/imgui_impl_glfw.cpp
+    )
+endif()
+
+# file(GLOB_RECURSE THIRD_PARTY_SOURCES
+#     "${CMAKE_SOURCE_DIR}/third-party/*.c"
+#     "${CMAKE_SOURCE_DIR}/third-party/*.cc"
+#     "${CMAKE_SOURCE_DIR}/third-party/*.cpp"
+#     "${CMAKE_SOURCE_DIR}/third-party/*.cxx"
+# )
+
+# file(TO_CMAKE_PATH "${CMAKE_SOURCE_DIR}/src" CLANG_TIDY_SRC_DIR)
+
+# set_target_properties(${PROJECT_NAME} PROPERTIES CXX_CLANG_TIDY "clang-tidy;--header-filter=${CLANG_TIDY_SRC_DIR}/.*")
+
+# set_source_files_properties(
+#     ${THIRD_PARTY_SOURCES}
+#     PROPERTIES SKIP_LINTING ON
+# )
+
+target_link_libraries(${PROJECT_NAME} PRIVATE
+    Vulkan::Vulkan
+    glfw
+    VulkanMemoryAllocator
+    plog::plog
+    ktx
+    rtm
+    ${SLANG_LIB}
+)
+
+if(WIN32)
+target_link_libraries(${PROJECT_NAME} PRIVATE
+    dwmapi
+)
+endif()
+
+if(ENABLE_TRACY)
+    target_link_libraries(${PROJECT_NAME} PRIVATE TracyClient)
+endif()
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+    ${SLANG_ROOT}/include
+    ${IMGUI_DIR}
+    ${IMGUI_DIR}/backends
+    ${CMAKE_SOURCE_DIR}/src
+    ${CMAKE_SOURCE_DIR}/third-party
+)
+
+target_compile_definitions(${PROJECT_NAME} PRIVATE VK_NO_PROTOTYPES IMGUI_IMPL_VULKAN_USE_VOLK)
+
+include(CheckIPOSupported)
+check_ipo_supported(RESULT ipo_supported OUTPUT ipo_output)
+if(ipo_supported)
+    message(STATUS "IPO/LTO is supported. Enabling it for Release builds.")
+    set_target_properties(${PROJECT_NAME} PROPERTIES
+        INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE
+        INTERPROCEDURAL_OPTIMIZATION_RELWITHDEBINFO TRUE
+    )
+else()
+    message(STATUS "IPO/LTO is not supported: ${ipo_output}")
+endif()
+
+if(MSVC)
+    target_compile_options(${PROJECT_NAME} PRIVATE
+        $<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>:
+            /O2
+            /Ot
+            /fp:fast
+            /arch:AVX2
+            /GL
+        >
+    )
+    set_property(TARGET ${PROJECT_NAME} PROPERTY
+        LINK_FLAGS_RELEASE "/LTCG"
+    )
+    set_property(TARGET ${PROJECT_NAME} PROPERTY
+        LINK_FLAGS_RELWITHDEBINFO "/LTCG"
+    )
+else()
+    target_compile_options(${PROJECT_NAME} PRIVATE
+        $<$<OR:$<CONFIG:Release>,$<CONFIG:RelWithDebInfo>>:
+            -O3
+            -march=native
+            -flto
+        >
+    )
+endif()
+
+add_compile_definitions(
+    FMT_USE_CONSTEXPR=0
+    FMT_ENFORCE_COMPILE_STRING=0
+)
+
+if(WIN32)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE
+        _CRT_SECURE_NO_WARNINGS
+    )
+endif()
+
+if(WIN32 OR UNIX)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE
+        RHI_BACKEND_VULKAN
+    )
+elseif(APPLE)
+    target_compile_definitions(${PROJECT_NAME} PRIVATE
+        RHI_BACKEND_METAL
+    )
+
+endif()

--- a/assets/fonts/Inter-Regular.otf
+++ b/assets/fonts/Inter-Regular.otf

--- a/assets/fonts/MonaspaceNeon-Regular.otf
+++ b/assets/fonts/MonaspaceNeon-Regular.otf

--- a/assets/gltf/DamagedHelmet.glb
+++ b/assets/gltf/DamagedHelmet.glb

--- a/assets/gltf/Sponza-KTX.glb
+++ b/assets/gltf/Sponza-KTX.glb

--- a/assets/kloofendal_overcast_puresky_4k.hdr
+++ b/assets/kloofendal_overcast_puresky_4k.hdr

--- a/assets/venetian_crossroads_4k.hdr
+++ b/assets/venetian_crossroads_4k.hdr

--- a/build_linux.sh
+++ b/build_linux.sh
@@ -0,0 +1,261 @@
+#!/usr/bin/env bash
+# Vulkan build for vk-renderer + RHI examples (Linux).
+# Usage: build_linux.sh [example] [-r] [-c]
+#   example  Name under src/backend/conformance/ (e.g. triangle). Builds
+#            src/backend/conformance/<example> with core + backend only.
+#            Default (no example): full renderer build.
+#   -r       Release build (default is Debug)
+#   -c       Clean build (delete everything first)
+# All build artifacts and output live under build/.
+# The binary must run from the repo root (shader paths are repo-relative).
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+build_type=debug
+clean_build=0
+example=""
+for arg in "$@"; do
+    case "$arg" in
+        -r|release) build_type=release ;;
+        -c)         clean_build=1 ;;
+        *)          example="$arg" ;;
+    esac
+done
+if [ -n "$example" ]; then
+    echo "[$build_type vulkan build: $example]"
+else
+    echo "[$build_type build]"
+fi
+
+ROOT="$SCRIPT_DIR"
+BUILD="$ROOT/build"
+OBJ="$BUILD/obj"
+DEPS="$ROOT/build/_deps"
+SLANG_DIR="$DEPS/slang-src"
+
+# --- Example mode (positional arg): build src/backend/conformance/<example>
+# --- with core + backend only, instead of the full renderer ------------------
+EXAMPLES="$ROOT/src/backend/conformance"
+if [ -n "$example" ]; then
+    EXAMPLE_SRC="$EXAMPLES/$example/$example.cpp"
+    if [ ! -f "$EXAMPLE_SRC" ]; then
+        echo "[error: no such example: $example (expected $EXAMPLE_SRC)]" >&2
+        exit 1
+    fi
+    OBJ="$ROOT/build/obj-ex-$example"
+fi
+
+# --- Vulkan SDK ----------------------------------------------------------
+VULKAN_CFLAGS=""
+VULKAN_LDFLAGS="-lvulkan"
+if command -v pkg-config >/dev/null 2>&1; then
+    if pkg-config --exists vulkan; then
+        VULKAN_CFLAGS="$(pkg-config --cflags vulkan)"
+        VULKAN_LDFLAGS="$(pkg-config --libs vulkan)"
+        echo "[vulkan] using pkg-config"
+    fi
+fi
+if [ -n "$VULKAN_SDK" ]; then
+    echo "[vulkan] VULKAN_SDK detected, overriding system paths"
+    VULKAN_CFLAGS="-I$VULKAN_SDK/include"
+    VULKAN_LDFLAGS="-L$VULKAN_SDK/lib -lvulkan"
+fi
+
+# --- Download Slang (binary SDK, shared across targets) ----------------------
+if [ ! -f "$SLANG_DIR/include/slang.h" ]; then
+    echo "[downloading slang]"
+    mkdir -p "$SLANG_DIR"
+    SLANG_URL="https://github.com/shader-slang/slang/releases/download/v2026.17.1/slang-2026.17.1-linux-x86_64.tar.gz"
+    curl -sL "$SLANG_URL" -o "$DEPS/slang.tar.gz"
+    tar -xzf "$DEPS/slang.tar.gz" -C "$SLANG_DIR" --strip-components=1
+    rm "$DEPS/slang.tar.gz"
+else
+    echo "[slang already downloaded]"
+fi
+SLANG_INCLUDE="-I$SLANG_DIR/include"
+SLANG_LIB="$SLANG_DIR/lib/libslang.so"
+
+# --- Clean -------------------------------------------------------------------
+if [ "$clean_build" = "1" ]; then
+    if [ -n "$example" ]; then
+        echo "[cleaning example build: $example]"
+        rm -rf "$OBJ"
+    else
+        echo "[cleaning build]"
+        rm -rf "$BUILD"
+    fi
+fi
+mkdir -p "$OBJ" "$DEPS"
+
+# --- glfw (static, shared across targets) ------------------------------------
+if [ ! -f "$DEPS/libglfw3.a" ]; then
+    echo "[building glfw]"
+    mkdir -p "$DEPS/glfw"
+    cmake -G Ninja -S "$ROOT/third-party/glfw" -B "$DEPS/glfw" \
+        -DGLFW_BUILD_DOCS=OFF -DGLFW_BUILD_TESTS=OFF -DGLFW_BUILD_EXAMPLES=OFF \
+        -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release >/dev/null 2>&1 || exit 1
+    cmake --build "$DEPS/glfw" >/dev/null 2>&1 || exit 1
+    cp "$DEPS/glfw/src/libglfw3.a" "$DEPS/libglfw3.a"
+else
+    echo "[glfw already built]"
+fi
+
+# --- KTX-Software (examples don't link it: skip) -----------------------------
+if [ -z "$example" ]; then
+if [ ! -f "$BUILD/libktx.a" ]; then
+    echo "[building ktx]"
+    mkdir -p "$DEPS/ktx"
+    cmake -G Ninja -S "$ROOT/third-party/KTX-Software" -B "$DEPS/ktx" \
+        -DKTX_FEATURE_TESTS=OFF -DKTX_FEATURE_TOOLS=OFF -DKTX_FEATURE_DOC=OFF \
+        -DKTX_FEATURE_GL_UPLOAD=OFF -DKTX_FEATURE_VK_UPLOAD=OFF \
+        -DKTX_FEATURE_LOADTEST_APPS=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo >/dev/null 2>&1 || exit 1
+    cmake --build "$DEPS/ktx" >/dev/null 2>&1 || exit 1
+    cp "$DEPS/ktx/lib/libktx.a"      "$BUILD/libktx.a"
+    cp "$DEPS/ktx/lib/libktx_read.a" "$BUILD/libktx_read.a"
+else
+    echo "[ktx already built]"
+fi
+fi
+
+# --- Compile flags -------------------------------------------------------
+#CXX="clang++"
+CXX="g++"
+CXX_COMMON="-std=c++20 -fno-rtti -D_USE_MATH_DEFINES -DVK_NO_PROTOTYPES -DRHI_BACKEND_VULKAN -DENABLE_EDITOR -DFMT_USE_CONSTEXPR=0 -DFMT_ENFORCE_COMPILE_STRING=0"
+CXX_INCLUDES="-I$ROOT/src -I$ROOT/third-party -I$ROOT/third-party/glfw/include -I$ROOT/third-party/VMA/include -I$ROOT/third-party/plog/include -I$ROOT/third-party/imgui -I$ROOT/third-party/imgui/backends -I$ROOT/third-party/rtm/includes -I$ROOT/third-party/KTX-Software/include $SLANG_INCLUDE $VULKAN_CFLAGS"
+if [ "$build_type" = "debug" ]; then
+    CXX_FLAGS="-g -O0 -D_DEBUG -DIMGUI_IMPL_VULKAN_USE_VOLK $CXX_COMMON $CXX_INCLUDES"
+else
+    CXX_FLAGS="-g -O2 -DNDEBUG -DIMGUI_IMPL_VULKAN_USE_VOLK $CXX_COMMON $CXX_INCLUDES"
+fi
+
+LD_FLAGS="$VULKAN_LDFLAGS -lX11 -lXrandr -lXinerama -lXcursor -lXi -lpthread -ldl"
+
+# --- Source files (matches CMakeLists.txt; VOLK_IMPLEMENTATION lives in
+# --- renderer.cpp / the example .cpp, so third-party/volk.c is intentionally
+# --- NOT compiled) -----------------------------------------------------------
+SRC="$ROOT/src"
+TP="$ROOT/third-party"
+
+CORE_SRC="\
+    $SRC/core/arena.cpp                  \
+    $SRC/core/platform.cpp               \
+    $SRC/core/math_rtm.cpp               \
+    $SRC/core/logger.cpp"
+
+BACKEND_SRC="\
+    $SRC/backend/vulkan/context.cpp      \
+    $SRC/backend/vulkan/swapchain.cpp    \
+    $SRC/backend/vulkan/pipeline.cpp     \
+    $SRC/backend/vulkan/descriptors.cpp  \
+    $SRC/backend/vulkan/debug.cpp        \
+    $SRC/backend/vulkan/query_pool.cpp   \
+    $SRC/backend/vulkan/cmd_pool.cpp     \
+    $SRC/backend/vulkan/cmd_buffer.cpp   \
+    $SRC/backend/vulkan/allocator.cpp    \
+    $SRC/backend/vulkan/queue.cpp        \
+    $SRC/backend/vulkan/buffer.cpp       \
+    $SRC/backend/vulkan/image.cpp        \
+    $SRC/backend/vulkan/sampler.cpp      \
+    $SRC/backend/vulkan/shader.cpp       \
+    $SRC/backend/vulkan/accel_struct.cpp \
+    $SRC/backend/vulkan/vk_conversion.cpp \
+    $SRC/backend/vulkan/rhi_helpers.cpp"
+
+RENDERER_SRC="\
+    $SRC/renderer.cpp                              \
+    $SRC/quick_submit.cpp                          \
+    $SRC/pipelines.cpp                             \
+    $SRC/passes/fg.cpp                             \
+    $SRC/asset/asset.cpp                           \
+    $SRC/asset/texture.cpp                         \
+    $SRC/asset/gltf.cpp                            \
+    $TP/mikktspace.c                               \
+    $SRC/scene/scene.cpp                           \
+    $SRC/scene/ibl.cpp                             \
+    $SRC/passes/ssr/ssr.cpp                        \
+    $SRC/passes/depth_pre/depth_normal.cpp         \
+    $SRC/passes/dispatch_mdi/build_indirect.cpp    \
+    $SRC/passes/forward/forward.cpp                \
+    $SRC/passes/fwd_cpu/fwd_cpu.cpp                \
+    $SRC/passes/shadow/shadow.cpp                  \
+    $SRC/passes/grid/grid.cpp                      \
+    $SRC/passes/id_blit/id_blit.cpp                \
+    $SRC/passes/fullscreen/fullscreen.cpp          \
+    $SRC/passes/cluster/cluster_bounds.cpp         \
+    $SRC/passes/cluster/light_cull.cpp             \
+    $SRC/passes/hiz/hiz.cpp                        \
+    $SRC/passes/imgui/imgui.cpp                    \
+    $SRC/passes/skybox/skybox.cpp                  \
+    $SRC/passes/rt_build.cpp                       \
+    $SRC/passes/ddgi/ddgi_trace.cpp                \
+    $SRC/passes/ddgi/ddgi_update.cpp               \
+    $SRC/passes/ddgi/ddgi_classify.cpp             \
+    $SRC/passes/ddgi/ddgi_relocate.cpp             \
+    $SRC/passes/ddgi/ddgi_probes_dbg.cpp           \
+    $SRC/passes/debug/debug_lines.cpp              \
+    $SRC/editor/editor.cpp                         \
+    $SRC/editor/debug_draw.cpp                     \
+    $SRC/editor/frame.cpp                          \
+    $SRC/editor/gizmo.cpp                          \
+    $SRC/editor/style.cpp                          \
+    $SRC/editor/viewport.cpp                       \
+    $SRC/editor/log_viewer.cpp                     \
+    $SRC/editor/texture_viewer.cpp                 \
+    $SRC/editor/targets.cpp                        \
+    $SRC/editor/timings.cpp                        \
+    $SRC/editor/hierarchy.cpp                      \
+    $SRC/editor/inspector.cpp                      \
+    $SRC/backend/imgui_backend.cpp                 \
+    $TP/imgui/imgui.cpp                            \
+    $TP/imgui/imgui_draw.cpp                       \
+    $TP/imgui/imgui_tables.cpp                     \
+    $TP/imgui/imgui_widgets.cpp                    \
+    $TP/imgui/imgui_demo.cpp                       \
+    $TP/imgui/backends/imgui_impl_glfw.cpp"
+
+# --- Compile -------------------------------------------------------------
+echo "[compiling]"
+if [ -n "$example" ]; then
+    for src in $EXAMPLE_SRC $CORE_SRC $BACKEND_SRC; do
+        objname=$(basename "$src" | sed 's/\.cpp$/.o/')
+        $CXX -c $CXX_FLAGS "$src" -o "$OBJ/$objname"
+    done
+else
+    for src in $CORE_SRC $BACKEND_SRC $RENDERER_SRC; do
+        objname=$(basename "$src" | sed 's/\.cpp$/.o/;s/\.c$/.o/')
+        $CXX -c $CXX_FLAGS "$src" -o "$OBJ/$objname"
+    done
+    # imgui.o collision: src/passes/imgui/imgui.cpp and third-party/imgui/imgui.cpp
+    # both emit imgui.o in this flat dir: rebuild with distinct names.
+    $CXX -c $CXX_FLAGS "$SRC/passes/imgui/imgui.cpp" -o "$OBJ/imgui_pass.o"
+    $CXX -c $CXX_FLAGS "$TP/imgui/imgui.cpp" -o "$OBJ/imgui_lib.o"
+    rm -f "$OBJ/imgui.o"
+    # stale objs from renamed/removed sources (link uses *.o wildcard)
+    rm -f "$OBJ/descriptor_pool.o" "$OBJ/descriptor_set.o" "$OBJ/gpu_resource.o" \
+        "$OBJ/cmd_buffers.o" "$OBJ/submission_queue.o" "$OBJ/render_target.o" \
+        "$OBJ/renderpass_io.o" "$OBJ/imgui_impl_vulkan.o" \
+        "$OBJ"/ui_*.o "$OBJ"/pass_*.o
+fi
+
+# --- Link -------------------------------------------------------------------
+echo "[linking]"
+if [ -n "$example" ]; then
+    OUT="$BUILD/vk-$example"
+    $CXX "$OBJ"/*.o \
+        "$DEPS/libglfw3.a" \
+        "$SLANG_LIB" \
+        $LD_FLAGS \
+        -o "$OUT"
+else
+    OUT="$BUILD/vk-renderer"
+    $CXX "$OBJ"/*.o \
+        "$BUILD/libglfw3.a" "$BUILD/libktx.a" "$BUILD/libktx_read.a" \
+        "$SLANG_LIB" \
+        $LD_FLAGS \
+        -o "$OUT"
+fi
+
+echo "[done: $OUT]"
+if [ -n "$example" ]; then
+    echo "[run from the repo root: $OUT]"
+fi

--- a/build_mac.sh
+++ b/build_mac.sh
@@ -0,0 +1,123 @@
+#!/usr/bin/env bash
+# Metal build for the RHI examples (macOS only; main renderer not supported yet).
+# Usage: build_mac.sh [example] [-r] [-c]
+#   example  Name under src/backend/conformance/ (default: triangle).
+#            Must contain <example>/<example>.cpp.
+#   -r       Release build (default is Debug)
+#   -c       Clean build (delete the example objects first)
+# All build artifacts and output live under build/.
+# The binary must run from the repo root (shader paths are repo-relative).
+set -e
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+build_type=debug
+clean_build=0
+example="triangle"
+for arg in "$@"; do
+    case "$arg" in
+        -r|release) build_type=release ;;
+        -c)         clean_build=1 ;;
+        *)          example="$arg" ;;
+    esac
+done
+echo "[$build_type metal build: $example]"
+
+ROOT="$SCRIPT_DIR"
+EXAMPLES="$ROOT/src/backend/conformance"
+EXAMPLE_SRC="$EXAMPLES/$example/$example.cpp"
+if [ ! -f "$EXAMPLE_SRC" ]; then
+    echo "[error: no such example: $example (expected $EXAMPLE_SRC)]" >&2
+    exit 1
+fi
+
+BUILD="$ROOT/build/metal-$example"
+OBJ="$ROOT/build/obj-ex-$example"
+DEPS="$ROOT/build/deps"
+
+if [ "$clean_build" = "1" ]; then
+    echo "[cleaning metal build]"
+    rm -rf "$OBJ"
+fi
+
+mkdir -p "$OBJ" "$DEPS" "$BUILD"
+
+# --- Download Slang (binary SDK, shared across examples) --------------------
+SLANG_DIR="$DEPS/slang"
+if [ ! -f "$SLANG_DIR/lib/libslang.dylib" ]; then
+    echo "[downloading slang]"
+    mkdir -p "$SLANG_DIR"
+    SLANG_URL="https://github.com/shader-slang/slang/releases/download/v2026.17.1/slang-2026.17.1-macos-aarch64.tar.gz"
+    curl -sL "$SLANG_URL" -o "$DEPS/slang.tar.gz"
+    tar -xzf "$DEPS/slang.tar.gz" -C "$SLANG_DIR" --strip-components=1
+    rm "$DEPS/slang.tar.gz"
+else
+    echo "[slang already downloaded]"
+fi
+SLANG_INCLUDE="-I$SLANG_DIR/include"
+SLANG_LINK="-L$SLANG_DIR/lib -lslang -Wl,-rpath,$SLANG_DIR/lib"
+
+# --- glfw (static, shared across examples) ----------------------------------
+if [ ! -f "$DEPS/libglfw3.a" ]; then
+    echo "[building glfw]"
+    mkdir -p "$DEPS/glfw"
+    cmake -G Ninja -S "$ROOT/third-party/glfw" -B "$DEPS/glfw" \
+        -DGLFW_BUILD_DOCS=OFF -DGLFW_BUILD_TESTS=OFF -DGLFW_BUILD_EXAMPLES=OFF \
+        -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=Release >/dev/null 2>&1 || exit 1
+    cmake --build "$DEPS/glfw" >/dev/null 2>&1 || exit 1
+    cp "$DEPS/glfw/src/libglfw3.a" "$DEPS/libglfw3.a"
+else
+    echo "[glfw already built]"
+fi
+
+# --- Compile flags ----------------------------------------------------------
+CXX="clang++"
+CXX_COMMON="-std=c++20 -fno-rtti -DRHI_BACKEND_METAL -DFMT_USE_CONSTEXPR=0 -DFMT_ENFORCE_COMPILE_STRING=0"
+CXX_INCLUDES="-I$ROOT/src -I$ROOT/third-party -I$ROOT/third-party/glfw/include -I$ROOT/third-party/plog/include -I$ROOT/third-party/rtm/includes -I$ROOT/third-party/metal-cpp $SLANG_INCLUDE"
+if [ "$build_type" = "debug" ]; then
+    CXX_FLAGS="-g -O0 -D_DEBUG $CXX_COMMON $CXX_INCLUDES"
+else
+    CXX_FLAGS="-g -O2 -DNDEBUG $CXX_COMMON $CXX_INCLUDES"
+fi
+
+# --- Source files -----------------------------------------------------------
+SRC="$ROOT/src"
+SOURCES="\
+    $EXAMPLE_SRC                  \
+    $SRC/core/arena.cpp               \
+    $SRC/core/platform.cpp            \
+    $SRC/core/logger.cpp              \
+    $SRC/core/math_rtm.cpp            \
+    $SRC/backend/metal/metal_impl.cpp \
+    $SRC/backend/metal/device.cpp     \
+    $SRC/backend/metal/swapchain.cpp  \
+    $SRC/backend/metal/cmd.cpp        \
+    $SRC/backend/metal/arguments_table.cpp \
+    $SRC/backend/metal/image.cpp      \
+    $SRC/backend/metal/sampler.cpp    \
+    $SRC/backend/metal/shader.cpp     \
+    $SRC/backend/metal/buffer.cpp     \
+    $SRC/backend/metal/pipeline.cpp   \
+    $SRC/backend/metal/metal_platform.mm"
+
+# --- Compile ----------------------------------------------------------------
+echo "[compiling]"
+for src in $SOURCES; do
+    objname=$(basename "$src" | sed 's/\.mm$/.o/;s/\.cpp$/.o/')
+    case "$src" in
+        *.mm) $CXX -fobjc-arc -c $CXX_FLAGS "$src" -o "$OBJ/$objname" ;;
+        *)    $CXX            -c $CXX_FLAGS "$src" -o "$OBJ/$objname" ;;
+    esac
+done
+
+# --- Link -------------------------------------------------------------------
+echo "[linking]"
+$CXX -fobjc-arc "$OBJ"/*.o \
+    "$DEPS/libglfw3.a" \
+    $SLANG_LINK \
+    -framework Metal -framework QuartzCore -framework Cocoa -framework Foundation \
+    -framework IOKit -framework CoreVideo \
+    -lpthread \
+    -o "$BUILD/metal-$example"
+
+echo "[done: $BUILD/metal-$example]"
+echo "[run from the repo root: ./build/metal-$example/metal-$example]"

--- a/build_win.bat
+++ b/build_win.bat
@@ -0,0 +1,299 @@
+@echo off
+setlocal enabledelayedexpansion
+cd /D "%~dp0"
+
+:: --- Usage ------------------------------------------------------------------
+::
+:: build_win.bat [example] [-r] [-c]
+::
+::   example  Name under src\backend\conformance\ (e.g. triangle). Builds
+::            src\backend\conformance\<example> with core + backend only.
+::            Default (no example): full renderer build.
+::   -r   Release build (default is Debug)
+::   -c   Clean build (delete everything first)
+
+:: --- Unpack Arguments -------------------------------------------------------
+set build_type=debug
+set clean_build=0
+set example=
+
+:parse_args
+if "%~1"=="" goto :args_done
+if /i "%~1"=="-r"       set build_type=release && shift && goto :parse_args
+if /i "%~1"=="-c"       set clean_build=1 && shift && goto :parse_args
+if /i "%~1"=="release"  set build_type=release && shift && goto :parse_args
+if /i "%~1"=="debug"    set build_type=debug && shift && goto :parse_args
+call :normalize_example "%~1"
+shift
+goto :parse_args
+:args_done
+
+if defined example (
+    echo [%build_type% vulkan build: %example%]
+) else (
+    echo [%build_type% build]
+)
+
+:: --- Find VS Toolchain ------------------------------------------------------
+for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -property installationPath`) do set "VS_PATH=%%i"
+if not defined VS_PATH echo ERROR: Visual Studio installation not found && exit /b 1
+call "%VS_PATH%\VC\Auxiliary\Build\vcvarsall.bat" x64 >nul 2>&1 || exit /b 1
+
+:: --- Vulkan SDK -------------------------------------------------------------
+if not defined VULKAN_SDK (
+    echo ERROR: VULKAN_SDK environment variable not set.
+    exit /b 1
+)
+
+:: --- Project Paths ----------------------------------------------------------
+set ROOT=%~dp0
+set BUILD=%ROOT%build
+set OBJ=%BUILD%\obj
+set DEPS=%BUILD%\_deps
+set SLANG_DIR=%DEPS%\slang-src
+set EXAMPLES_DIR=%ROOT%src\backend\conformance\
+
+:: --- Example mode (positional arg): build src\backend\conformance\<example>
+:: --- with core + backend only, instead of the full renderer ------------------
+if defined example (
+    if "!EXAMPLES_DIR:~-1!"=="\" set "EXAMPLES_DIR=!EXAMPLES_DIR:~0,-1!"
+    set "EXAMPLE_SRC=!EXAMPLES_DIR!\!example!\!example!.cpp"
+    if not exist "!EXAMPLE_SRC!" (
+        echo [error: no such example: !example! ^(expected !EXAMPLE_SRC!^)]
+        exit /b 1
+    )
+    set "OBJ=%BUILD%\obj-ex-!example!"
+)
+
+
+
+:: --- Download Slang (binary SDK) --------------------------------------------
+if not exist "%SLANG_DIR%\lib\slang.lib" (
+    echo [downloading slang]
+    if not exist "%SLANG_DIR%" mkdir "%SLANG_DIR%"
+    powershell -Command "& {param($u,$d); [System.Net.WebClient]::new().DownloadFile($u,$d)}" ^
+	-u "https://github.com/shader-slang/slang/releases/download/v2026.17.1/slang-2026.17.1-windows-x86_64.zip" ^
+        -d "%DEPS%\slang.zip" >nul 2>&1
+    powershell -Command "Expand-Archive -Path '%DEPS%\slang.zip' -DestinationPath '%DEPS%\slang_tmp' -Force" >nul 2>&1
+    xcopy /s /e /q /y "%DEPS%\slang_tmp\*" "%SLANG_DIR%\" >nul 2>&1
+    rmdir /s /q "%DEPS%\slang_tmp" >nul 2>&1
+    del "%DEPS%\slang.zip" >nul 2>&1
+) else (
+    echo [slang already downloaded]
+)
+
+set SLANG_INCLUDE=/I"%SLANG_DIR%\include"
+set SLANG_LIB=%SLANG_DIR%\lib\slang.lib
+
+:: --- Clean ------------------------------------------------------------------
+if "%clean_build%"=="1" (
+    if defined example (
+        echo [cleaning example build: %example%]
+        if exist "%OBJ%" rmdir /s /q "%OBJ%"
+    ) else (
+        echo [cleaning build]
+        if exist "%BUILD%" rmdir /s /q "%BUILD%"
+    )
+)
+
+:: --- Prep Directories -------------------------------------------------------
+if not exist "%OBJ%"  mkdir "%OBJ%"
+if not exist "%DEPS%" mkdir "%DEPS%"
+
+:: --- Build Third-Party Dependencies -----------------------------------------
+
+set KTX_BUILD_TYPE=RelWithDebInfo
+if "%build_type%"=="debug" set KTX_BUILD_TYPE=Debug
+
+:: glfw
+if not exist "%BUILD%\glfw3.lib" (
+    echo [building glfw]
+    if not exist "%DEPS%\glfw" mkdir "%DEPS%\glfw"
+    cmake -G Ninja -S "%ROOT%third-party\glfw" -B "%DEPS%\glfw" ^
+        -DGLFW_BUILD_DOCS=OFF -DGLFW_BUILD_TESTS=OFF -DGLFW_BUILD_EXAMPLES=OFF ^
+        -DBUILD_SHARED_LIBS=OFF -DCMAKE_BUILD_TYPE=%KTX_BUILD_TYPE% >nul 2>&1 || exit /b 1
+    cmake --build "%DEPS%\glfw" --config %KTX_BUILD_TYPE% >nul 2>&1 || exit /b 1
+    copy "%DEPS%\glfw\src\glfw3.lib" "%BUILD%\glfw3.lib" >nul 2>&1
+) else (
+    echo [glfw already built]
+)
+
+:: KTX-Software (examples don't link it — skip)
+if defined example goto :skip_ktx
+if not exist "%BUILD%\ktx.lib" (
+    echo [building ktx]
+    if not exist "%DEPS%\ktx" mkdir "%DEPS%\ktx"
+    cmake -G Ninja -S "%ROOT%third-party\KTX-Software" -B "%DEPS%\ktx" ^
+        -DKTX_FEATURE_TESTS=OFF -DKTX_FEATURE_TOOLS=OFF -DKTX_FEATURE_DOC=OFF ^
+        -DKTX_FEATURE_GL_UPLOAD=OFF -DKTX_FEATURE_VK_UPLOAD=OFF ^
+        -DKTX_FEATURE_LOADTEST_APPS=OFF -DCMAKE_BUILD_TYPE=%KTX_BUILD_TYPE% >nul 2>&1 || exit /b 1
+    cmake --build "%DEPS%\ktx" --config %KTX_BUILD_TYPE% >nul 2>&1 || exit /b 1
+    copy "%DEPS%\ktx\ktx.lib"               "%BUILD%\ktx.lib" >nul 2>&1
+    copy "%DEPS%\ktx\ktx_read.lib"          "%BUILD%\ktx_read.lib" >nul 2>&1
+    copy "%DEPS%\ktx\external\astc-encoder\Source\astcenc-avx2-static.lib" "%BUILD%\astcenc-avx2-static.lib" >nul 2>&1
+) else (
+    echo [ktx already built]
+)
+:skip_ktx
+
+:: ==== Compile Flags ====
+
+set CL_COMMON=/nologo /FC /Z7 /EHsc /Zc:preprocessor /std:c++20 /permissive- ^
+    /DRHI_BACKEND_VULKAN /DENABLE_EDITOR /D_CRT_SECURE_NO_WARNINGS /DVK_NO_PROTOTYPES /DKHRONOS_STATIC ^
+    /DFMT_USE_CONSTEXPR=0 /DFMT_ENFORCE_COMPILE_STRING=0
+
+set CL_INCLUDES=/I"%ROOT%src" /I"%ROOT%third-party" ^
+    /I"%ROOT%third-party\glfw\include" /I"%ROOT%third-party\VMA\include" ^
+    /I"%ROOT%third-party\plog\include" /I"%ROOT%third-party\imgui" ^
+    /I"%ROOT%third-party\imgui\backends" /I"%ROOT%third-party\rtm\includes" ^
+    /I"%ROOT%third-party\KTX-Software\include" ^
+    %SLANG_INCLUDE% /I"%VULKAN_SDK%\Include"
+
+if "%build_type%"=="debug" (
+    set CL_FLAGS=/Od /Ob1 /MDd /D_DEBUG /DIMGUI_IMPL_VULKAN_USE_VOLK %CL_COMMON% %CL_INCLUDES%
+    set LD_DEBUG=/DEBUG
+) else (
+    set CL_FLAGS=/O2 /MD /DNDEBUG /DIMGUI_IMPL_VULKAN_USE_VOLK %CL_COMMON% %CL_INCLUDES%
+    set LD_DEBUG=
+)
+
+:: ==== Source Files ====
+
+set SRC=%ROOT%src
+set TP=%ROOT%third-party
+
+set CORE_SRC=^
+    %SRC%\core\arena.cpp                            ^
+    %SRC%\core\platform.cpp                         ^
+    %SRC%\core\math_rtm.cpp                         ^
+    %SRC%\core\logger.cpp
+
+set BACKEND_SRC=^
+    %SRC%\backend\vulkan\context.cpp                ^
+    %SRC%\backend\vulkan\swapchain.cpp              ^
+    %SRC%\backend\vulkan\pipeline.cpp               ^
+    %SRC%\backend\vulkan\descriptors.cpp            ^
+    %SRC%\backend\vulkan\debug.cpp                  ^
+    %SRC%\backend\vulkan\query_pool.cpp             ^
+    %SRC%\backend\vulkan\cmd_pool.cpp               ^
+    %SRC%\backend\vulkan\cmd_buffer.cpp             ^
+    %SRC%\backend\vulkan\allocator.cpp              ^
+    %SRC%\backend\vulkan\queue.cpp                  ^
+    %SRC%\backend\vulkan\buffer.cpp                 ^
+    %SRC%\backend\vulkan\image.cpp                  ^
+    %SRC%\backend\vulkan\sampler.cpp                ^
+    %SRC%\backend\vulkan\shader.cpp                 ^
+    %SRC%\backend\vulkan\accel_struct.cpp           ^
+    %SRC%\backend\vulkan\vk_conversion.cpp          ^
+    %SRC%\backend\vulkan\rhi_helpers.cpp
+
+set SOURCES=^
+    %SRC%\renderer.cpp                              ^
+    %SRC%\quick_submit.cpp                          ^
+    %SRC%\pipelines.cpp                             ^
+    %SRC%\passes\fg.cpp                             ^
+    %SRC%\asset\asset.cpp                           ^
+    %SRC%\asset\texture.cpp                         ^
+    %SRC%\asset\gltf.cpp                            ^
+    %TP%\mikktspace.c                               ^
+    %SRC%\scene\scene.cpp                           ^
+    %SRC%\scene\ibl.cpp                             ^
+    %SRC%\passes\ssr\ssr.cpp                        ^
+    %SRC%\passes\depth_pre\depth_normal.cpp         ^
+    %SRC%\passes\dispatch_mdi\build_indirect.cpp    ^
+    %SRC%\passes\forward\forward.cpp                ^
+    %SRC%\passes\fwd_cpu\fwd_cpu.cpp                ^
+    %SRC%\passes\shadow\shadow.cpp                  ^
+    %SRC%\passes\grid\grid.cpp                      ^
+    %SRC%\passes\id_blit\id_blit.cpp                ^
+    %SRC%\passes\fullscreen\fullscreen.cpp          ^
+    %SRC%\passes\cluster\cluster_bounds.cpp         ^
+    %SRC%\passes\cluster\light_cull.cpp             ^
+    %SRC%\passes\hiz\hiz.cpp                        ^
+    %SRC%\passes\imgui\imgui.cpp                    ^
+    %SRC%\passes\skybox\skybox.cpp                  ^
+    %SRC%\passes\rt_build.cpp                       ^
+    %SRC%\passes\ddgi\ddgi_trace.cpp                ^
+    %SRC%\passes\ddgi\ddgi_update.cpp               ^
+    %SRC%\passes\ddgi\ddgi_classify.cpp             ^
+    %SRC%\passes\ddgi\ddgi_relocate.cpp             ^
+    %SRC%\passes\ddgi\ddgi_probes_dbg.cpp           ^
+    %SRC%\passes\debug\debug_lines.cpp              ^
+    %SRC%\editor\editor.cpp                         ^
+    %SRC%\editor\debug_draw.cpp                     ^
+    %SRC%\editor\frame.cpp                          ^
+    %SRC%\editor\gizmo.cpp                          ^
+    %SRC%\editor\style.cpp                          ^
+    %SRC%\editor\viewport.cpp                       ^
+    %SRC%\editor\log_viewer.cpp                     ^
+    %SRC%\editor\texture_viewer.cpp                 ^
+    %SRC%\editor\targets.cpp                       ^
+    %SRC%\editor\timings.cpp                       ^
+    %SRC%\editor\hierarchy.cpp                      ^
+    %SRC%\editor\inspector.cpp                      ^
+    %SRC%\backend\imgui_backend.cpp                 ^
+    %TP%\imgui\imgui.cpp                            ^
+    %TP%\imgui\imgui_draw.cpp                       ^
+    %TP%\imgui\imgui_tables.cpp                     ^
+    %TP%\imgui\imgui_widgets.cpp                    ^
+    %TP%\imgui\imgui_demo.cpp                       ^
+    %TP%\imgui\backends\imgui_impl_glfw.cpp
+
+:: ==== Compile ====
+echo [compiling]
+
+pushd "%OBJ%"
+if defined example goto :compile_example
+cl /c /MP %CL_FLAGS% %CORE_SRC% %BACKEND_SRC% %SOURCES% 2>&1 | findstr /v "Microsoft (R) Copyright (C)" | findstr /v "^$"
+:: imgui.obj collision: src\passes\imgui\imgui.cpp and third-party\imgui\imgui.cpp
+:: both emit imgui.obj in this flat dir — rebuild with distinct names.
+cl /c %CL_FLAGS% /Fo"%OBJ%\imgui_pass.obj" "%SRC%\passes\imgui\imgui.cpp" 2>&1 | findstr /v "Microsoft (R) Copyright (C)" | findstr /v "^$"
+cl /c %CL_FLAGS% /Fo"%OBJ%\imgui_lib.obj" "%TP%\imgui\imgui.cpp" 2>&1 | findstr /v "Microsoft (R) Copyright (C)" | findstr /v "^$"
+if exist "%OBJ%\imgui.obj" del "%OBJ%\imgui.obj"
+:: stale objs from renamed/removed sources (link uses *.obj wildcard)
+if exist "%OBJ%\descriptor_pool.obj" del "%OBJ%\descriptor_pool.obj"
+if exist "%OBJ%\descriptor_set.obj" del "%OBJ%\descriptor_set.obj"
+if exist "%OBJ%\imgui_impl_vulkan.obj" del "%OBJ%\imgui_impl_vulkan.obj"
+del "%OBJ%\pass_*.obj" 2>nul
+goto :compile_done
+:compile_example
+cl /c /MP %CL_FLAGS% "%EXAMPLE_SRC%" %CORE_SRC% %BACKEND_SRC% 2>&1 | findstr /v "Microsoft (R) Copyright (C)" | findstr /v "^$"
+:compile_done
+popd
+
+:: ==== Link ====
+echo [linking]
+
+if defined example (
+    set LIBS="%VULKAN_SDK%\Lib\vulkan-1.lib" ^
+        "%BUILD%\glfw3.lib" "%SLANG_LIB%" ^
+        gdi32.lib user32.lib shell32.lib dwmapi.lib
+    set "OUT=%BUILD%\vk-%example%.exe"
+) else (
+    set LIBS="%VULKAN_SDK%\Lib\vulkan-1.lib" ^
+        "%BUILD%\glfw3.lib" "%BUILD%\ktx.lib" "%BUILD%\ktx_read.lib" ^
+        "%BUILD%\astcenc-avx2-static.lib" "%SLANG_LIB%" ^
+        gdi32.lib user32.lib shell32.lib dwmapi.lib
+    set "OUT=%BUILD%\vk-renderer.exe"
+)
+
+cl %OBJ%\*.obj %LIBS% /link /MANIFEST:EMBED /INCREMENTAL:NO %LD_DEBUG% /OUT:"%OUT%" 2>&1 | findstr /v "Microsoft (R) Copyright (C)" | findstr /v "^$"
+
+echo [done: %OUT%]
+if defined example echo [run from repo root: %OUT%]
+exit /b 0
+
+:: --- Normalize example argument to a bare name ------------------------------
+:: Accepts: triangle, triangle.cpp, triangle\triangle.cpp,
+:: .\triangle\triangle.cpp, ./triangle/triangle.cpp, etc.
+:normalize_example
+set "raw=%~1"
+set "norm=!raw:/=\!"
+:strip_trailing
+if not defined norm goto :normalize_done
+if "!norm:~-1!"=="\" set "norm=!norm:~0,-1!" & goto :strip_trailing
+if "!norm:~-2!"=="\." set "norm=!norm:~0,-2!" & goto :strip_trailing
+:normalize_done
+for %%A in ("!norm!") do set "example=%%~nA"
+if not defined example set "example=!norm!"
+goto :eof

--- a/readme.md
+++ b/readme.md
@@ -0,0 +1,41 @@
+### Overview
+
+GPU driven Vulkan/Metal playground renderer (main renderer is Vulkan on Windows/Linux for now), contains a rendering interface, a precompiled frame-graph, `DescriptorHandle<T>` based bindless resource fetching, and a basic ImGui editor. Generally intended to be a gfx lab bench for myself.
+
+- Explicit frame-graph (`src/passes/fg.*`), passes declare read/write states and barriers get baked outside the hot path.
+- GPU-driven MDI forward path: compute shader, build-indirect, HiZ and frustum culling -> depth-pre -> forward.
+- Cascaded shadow maps, clustered point lights, DDGI or infinite IBL for indirect.
+- IBL skybox from HDR, gltf load (cgltf + KTX + mikktspace), ImGui editor with shader reload.
+- Render backend abstraction in `src/backend/rhi.h`. Metal coverage runs `src/backend/conformance/*` for now as I work on expanding the coverage.
+
+### Local setup
+
+- Vulkan SDK 1.4+
+- C++20, CMake 3.31+ (CMake path only), Ninja recommended
+- Windows: VS2022 + `vswhere` on PATH (bat should find it for you). Linux: gcc/clang + dev Vulkan headers. macOS: conformance-only (main renderer unsupported, Metal WIP).
+
+```sh
+git submodule update --init --recursive
+```
+
+Submodules: glfw, VMA, rtm, imgui, KTX-Software, plog. Slang 2026.17.1 is fetched as a binary (CMake FetchContent, or auto-downloaded by the bat/sh scripts)
+
+#### Scripts
+```
+build_win.bat                 # Windows debug
+build_win.bat -r              # Windows release
+build_win.bat -c              # clean rebuild
+build_win.bat triangle        # conformance probe (no renderer)
+./build_linux.sh              # Linux debug (add triangle for probe)
+./build_linux.sh -r           # Linux release
+./build_mac.sh triangle       # macOS probe only
+```
+
+#### CMake
+```
+cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug
+cmake --build build
+```
+
+### To-do
+There's generally just a lot to do all over the place in this, but currently I'm just slowly chipping away at the editor and Metal coverage, toward renderer.cpp.<
\ No newline at end of file

--- a/slang-format.py
+++ b/slang-format.py
@@ -0,0 +1,185 @@
+# LLM generated file
+# based on https://github.com/shader-slang/slang/blob/master/source/slang/slang-language-server-auto-format.cpp
+# slangd just silently does some pre/post processing for clang-format,
+# this is just a tiny file to do the same. I just want some dedicated tool to format all shaders if needed
+
+# single file
+# python format_slang.py myshader.slang
+
+# format directory recursively
+# python format_slang.py ./src
+
+# custom style
+# python format_slang.py --style LLVM ./src
+
+# multiple files
+# python format_slang.py file1.slang file2.slang ./src
+
+
+#!/usr/bin/env python3
+import subprocess
+import re
+import os
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+
+def find_clang_format():
+    """Find clang-format executable"""
+    # Try PATH first
+    result = subprocess.run(
+        ["where" if os.name == "nt" else "which", "clang-format"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode == 0:
+        return result.stdout.strip()
+    return "clang-format"
+
+
+def extract_spirv_asm_ranges(text):
+    """Extract ranges of spirv_asm blocks to exclude from formatting"""
+    ranges = []
+    # Simple regex to find spirv_asm { ... } blocks
+    pattern = r"spirv_asm\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}"
+    for match in re.finditer(pattern, text, re.DOTALL):
+        ranges.append((match.start(), match.end()))
+    return ranges
+
+
+def format_source(text, clang_format_path, style, fallback_style):
+    """Call clang-format and parse XML output"""
+
+    # Build clang-format command
+    cmd = [
+        clang_format_path,
+        "--assume-filename",
+        "file.cs",
+        "--output-replacements-xml",
+    ]
+
+    # Add style arguments
+    if style.startswith("file"):
+        # Check if .clang-format exists
+        if os.path.exists(".clang-format") or os.path.exists("_clang_format"):
+            cmd.extend(["-style", style])
+        elif fallback_style:
+            cmd.extend(["-style", fallback_style])
+    elif style:
+        cmd.extend(["-style", style])
+
+    # Run clang-format with UTF-8 encoding
+    result = subprocess.run(
+        cmd,
+        input=text,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",  # Add this
+        errors="replace",  # Add this to handle any encoding issues gracefully
+    )
+
+    if result.returncode != 0:
+        print(f"clang-format error: {result.stderr}")
+        return []
+
+    # Parse XML output
+    try:
+        root = ET.fromstring(result.stdout)
+        edits = []
+        for replacement in root.findall("replacement"):
+            offset = int(replacement.get("offset", "0"))
+            length = int(replacement.get("length", "0"))
+            new_text = replacement.text or ""
+            # Decode XML entities
+            new_text = new_text.replace("
", "\r").replace("
", "\n")
+            new_text = new_text.replace("&lt;", "<").replace("&gt;", ">")
+            new_text = new_text.replace("&amp;", "&").replace("&apos;", "'")
+            new_text = new_text.replace("&quot;", '"')
+            edits.append((offset, length, new_text))
+        return edits
+    except ET.ParseError as e:
+        print(f"Failed to parse clang-format output: {e}")
+        return []
+
+
+def apply_edits(text, edits, exclusion_ranges):
+    """Apply text edits, respecting exclusion ranges"""
+    # Filter out edits in spirv_asm blocks
+    filtered_edits = []
+    for offset, length, new_text in edits:
+        skip = False
+        for start, end in exclusion_ranges:
+            if start <= offset < end:
+                skip = True
+                break
+        if not skip:
+            # Skip semicolon-after-brace special case
+            if length == 0 and offset < len(text) and text[offset] == ";":
+                if offset > 0 and text[offset - 1] == "}":
+                    skip = True
+            if not skip:
+                filtered_edits.append((offset, length, new_text))
+
+    # Apply edits in reverse order (to preserve offsets)
+    result = text
+    for offset, length, new_text in reversed(filtered_edits):
+        result = result[:offset] + new_text + result[offset + length :]
+
+    return result
+
+
+def format_file(file_path, clang_format_path, style="file", fallback_style=None):
+    """Format a single file"""
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    exclusion_ranges = extract_spirv_asm_ranges(content)
+    edits = format_source(content, clang_format_path, style, fallback_style)
+    formatted = apply_edits(content, edits, exclusion_ranges)
+
+    with open(file_path, "w", encoding="utf-8", newline="") as f:
+        f.write(formatted)
+
+    print(f"Formatted: {file_path}")
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Format Slang files like the LSP does")
+    parser.add_argument(
+        "--style", default="file", help="clang-format style (default: file)"
+    )
+    parser.add_argument(
+        "--fallback-style",
+        default="{BasedOnStyle: Microsoft, BreakBeforeBraces: Allman, ColumnLimit: 0}",
+        help="clang-format fallback style",
+    )
+    parser.add_argument(
+        "--clang-format", default=None, help="Path to clang-format executable"
+    )
+    parser.add_argument("files", nargs="+", help="Files or directories to format")
+
+    args = parser.parse_args()
+
+    clang_format = args.clang_format or find_clang_format()
+    print(f"Using clang-format: {clang_format}")
+
+    # Gather files
+    file_list = []
+    for item in args.files:
+        if os.path.isfile(item):
+            file_list.append(item)
+        elif os.path.isdir(item):
+            file_list.extend(Path(item).rglob("*.slang"))
+
+    # Format files
+    for file_path in file_list:
+        try:
+            format_file(file_path, clang_format, args.style, args.fallback_style)
+        except Exception as e:
+            print(f"Error formatting {file_path}: {e}")
+
+
+if __name__ == "__main__":
+    main()

--- a/src/asset/asset.cpp
+++ b/src/asset/asset.cpp
@@ -0,0 +1,19 @@
+#include "asset.h"
+
+AssetHandle AssetManager::load(const char *path) {
+    AssetHandle h{(u32)assets.size()};
+    assets.emplace_back();
+    if (!load_gltf_asset(path, assets.back())) {
+        assets.pop_back();
+        return {};
+    }
+    return h;
+}
+
+const AssetScene *AssetManager::get(AssetHandle h) const {
+    return h.id < assets.size() ? &assets[h.id] : nullptr;
+}
+
+AssetScene *AssetManager::get(AssetHandle h) {
+    return h.id < assets.size() ? &assets[h.id] : nullptr;
+}

--- a/src/asset/asset.h
+++ b/src/asset/asset.h
@@ -0,0 +1,139 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "core/globals.h"
+#include "core/math_rtm.h"
+#include "shaders/renderer_types.h"
+
+constexpr u32 ASSET_INVALID = 0xffffffffu;
+
+struct AssetHandle {
+    u32 id = ASSET_INVALID;
+
+    bool valid() const {
+        return id != ASSET_INVALID;
+    }
+    bool operator==(const AssetHandle &o) const {
+        return id == o.id;
+    }
+    explicit operator bool() const {
+        return valid();
+    }
+};
+
+struct AssetGeometry {
+    u32 first_vertex;
+    u32 vertex_count;
+    u32 first_index;
+    u32 index_count;
+};
+
+struct AssetTexture {
+    std::string name;
+    std::string path;
+    u8 *blob = nullptr;
+    usize blob_size = 0;
+    bool is_ktx = false;
+    bool is_srgb = true;
+    bool is_hdr = false;
+};
+
+struct AssetMaterial {
+    std::string name;
+    vec4 base_color = vec4(1.0f, 1.0f, 1.0f, 1.0f);
+    f32 metallic = 0.2f;
+    f32 roughness = 0.8f;
+    vec3 emissive = vec3(0.0f);
+    u32 base_color_tex = ASSET_INVALID;
+    u32 normal_tex = ASSET_INVALID;
+    u32 mr_tex = ASSET_INVALID;
+    u32 emissive_tex = ASSET_INVALID;
+    bool double_sided = false;
+};
+
+struct AssetSubmesh {
+    u32 geometry = ASSET_INVALID;
+    u32 material = ASSET_INVALID;
+    vec3 aabb_min = vec3(0.0f);
+    vec3 aabb_max = vec3(0.0f);
+    vec4 sphere = vec4(0.0f, 0.0f, 0.0f, 1.0f);
+};
+
+struct AssetMesh {
+    u32 first_submesh;
+    u32 submesh_count;
+};
+
+struct AssetCamera {
+    enum Type {
+        Perspective,
+        Orthographic
+    };
+    Type type;
+    f32 yfov;
+    f32 znear;
+    f32 zfar;
+    f32 aspect_ratio;
+};
+
+struct AssetLight {
+    enum Type {
+        Directional,
+        Point
+    };
+    Type type;
+    vec3 color = {1.0f, 1.0f, 1.0f};
+    f32 intensity = 1.0f;
+    f32 range = 0.0f;
+};
+
+struct AssetNode {
+    mat4 local = identity();
+    int parent = -1;
+    u32 first_child;
+    u32 child_count;
+    u32 mesh = ASSET_INVALID;
+    i32 camera = -1;
+    i32 light = -1;
+    u32 first_instance;
+    u32 instance_count;
+};
+
+struct AssetScene {
+    std::string name;
+    std::vector<Vertex> vertices;
+    std::vector<u32> indices;
+    std::vector<AssetGeometry> geometries;
+    std::vector<AssetTexture> textures;
+    std::vector<AssetMaterial> materials;
+    std::vector<AssetSubmesh> submeshes;
+    std::vector<AssetMesh> meshes;
+    std::vector<AssetNode> nodes;
+    std::vector<AssetCamera> cameras;
+    std::vector<AssetLight> lights;
+    std::vector<u32> child_indices;
+    std::vector<u32> mesh_submeshes;
+    std::vector<TRS> instance_locals;
+    std::vector<u32> root_nodes;
+
+    std::vector<std::string> submesh_names;
+    std::vector<std::string> mesh_names;
+    std::vector<std::string> node_names;
+};
+
+class AssetManager {
+  public:
+    AssetHandle load(const char *path);
+    const AssetScene *get(AssetHandle h) const;
+    AssetScene *get(AssetHandle h);
+    u32 count() const {
+        return (u32)assets.size();
+    }
+
+  private:
+    std::vector<AssetScene> assets;
+};
+
+bool load_gltf_asset(const char *path, AssetScene &out);

--- a/src/asset/gltf.cpp
+++ b/src/asset/gltf.cpp
@@ -0,0 +1,579 @@
+#include <cstddef>
+
+#include "asset.h"
+#include "core/logger.h"
+#include "core/math_rtm.h"
+
+#define CGLTF_IMPLEMENTATION
+#include <cgltf.h>
+#include <mikktspace.h>
+#include <stb_image.h>
+
+#include <filesystem>
+#include <vector>
+
+// clang-format off
+
+// both are right handed
+// my:   right-handed | +X fwd, -Y rgt (+Y lft), +Z up
+// gltf: right-handed | +X rgt, +Y up,           +Z fwd
+
+// maps gltf axes 1:1 directly into my space
+// I think this is pretty common? Unless theres a better solutio?
+// For entire level/world geometry exports so global coordinates don't rotate
+// props/characters will import facing backwards (looking down -X)
+static const mat4 GLTF_TO_ENGINE_PURE = {
+    0.0f, 1.0f, 0.0f, 0.0f,  // col 0: gltf X (rgt) -> my Y (lft)
+    0.0f, 0.0f, 1.0f, 0.0f,  // col 1: gltf Y (up)  -> my Z (up)
+    1.0f, 0.0f, 0.0f, 0.0f,  // col 2: gltf Z (fwd) -> my X (fwd)
+    0.0f, 0.0f, 0.0f, 1.0f
+};
+
+// bakes a 180-degree yaw rot (mind both the flips) into the conversion matrix
+// aligns assets modeled facing the front-camera in blender to automatically
+// face my +X fwd dir ootb preserves winding order (+det)
+static const mat4 GLTF_TO_ENGINE_FLIPPED = {
+     0.0f, -1.0f,  0.0f,  0.0f,  // col 0: gltf X (rgt) -> my -Y (flip rgt)
+     0.0f,  0.0f,  1.0f,  0.0f,  // col 1: gltf Y (up)  -> my  Z
+    -1.0f,  0.0f,  0.0f,  0.0f,  // col 2: gltf Z (fwd) -> my -X (flip fwd)
+     0.0f,  0.0f,  0.0f,  1.0f
+};
+
+// #define GLTF_TO_ENGINE m4_identity()
+#define GLTF_TO_ENGINE GLTF_TO_ENGINE_FLIPPED
+// #define GLTF_TO_ENGINE GLTF_TO_ENGINE_PURE
+// clang-format on
+
+struct MikkUserData {
+    const std::vector<vec3> *positions;
+    const std::vector<vec3> *normals;
+    const std::vector<vec2> *uvs;
+    const std::vector<u32> *indices;
+    std::vector<vec4> *tangents_out;
+};
+
+static int mikk_get_num_faces(const SMikkTSpaceContext *ctx) {
+    auto *d = (MikkUserData *)ctx->m_pUserData;
+    return (int)(d->indices->size() / 3);
+}
+
+static int mikk_get_num_vertices_of_face(const SMikkTSpaceContext *, int) {
+    return 3;
+}
+
+static void mikk_get_position(const SMikkTSpaceContext *ctx, f32 pos[], int face, int vert) {
+    auto *d = (MikkUserData *)ctx->m_pUserData;
+    u32 idx = (*d->indices)[face * 3 + vert];
+    pos[0] = (*d->positions)[idx].x;
+    pos[1] = (*d->positions)[idx].y;
+    pos[2] = (*d->positions)[idx].z;
+}
+
+static void mikk_get_normal(const SMikkTSpaceContext *ctx, f32 nrm[], int face, int vert) {
+    auto *d = (MikkUserData *)ctx->m_pUserData;
+    u32 idx = (*d->indices)[face * 3 + vert];
+    nrm[0] = (*d->normals)[idx].x;
+    nrm[1] = (*d->normals)[idx].y;
+    nrm[2] = (*d->normals)[idx].z;
+}
+
+static void mikk_get_texcoord(const SMikkTSpaceContext *ctx, f32 uv[], int face, int vert) {
+    auto *d = (MikkUserData *)ctx->m_pUserData;
+    u32 idx = (*d->indices)[face * 3 + vert];
+    uv[0] = (*d->uvs)[idx].x;
+    uv[1] = (*d->uvs)[idx].y;
+}
+
+static void
+mikk_set_ts_space_basic(const SMikkTSpaceContext *ctx, const f32 tangent[], const f32 sign, int face, int vert) {
+    auto *d = (MikkUserData *)ctx->m_pUserData;
+    u32 idx = (*d->indices)[face * 3 + vert];
+    (*d->tangents_out)[idx] = vec4(tangent[0], tangent[1], tangent[2], sign);
+}
+
+// helpers
+static u32 add_texture(AssetScene &out, const cgltf_texture_view &view, const std::string &gltf_dir, bool srgb) {
+    if (!view.texture) {
+        return ASSET_INVALID;
+    }
+
+    cgltf_image *img = nullptr;
+
+    AssetTexture tex{};
+
+    tex.is_srgb = srgb;
+
+    if (view.texture->has_basisu) {
+        img = view.texture->basisu_image;
+        tex.is_ktx = true;
+    } else {
+        img = view.texture->image;
+    }
+
+    if (!img) {
+        return ASSET_INVALID;
+    }
+
+    if (img->name) {
+        tex.name = img->name;
+    }
+
+    if (img->uri) {
+        tex.path = gltf_dir + "/" + img->uri;
+    } else if (img->buffer_view) {
+        tex.blob_size = img->buffer_view->size;
+        tex.blob = new u8[tex.blob_size];
+        const u8 *src = (const u8 *)img->buffer_view->buffer->data + img->buffer_view->offset;
+        memcpy(tex.blob, src, tex.blob_size);
+    }
+
+    u32 index = (u32)out.textures.size();
+    out.textures.push_back(tex);
+    return index;
+}
+
+bool load_gltf_asset(const char *path, AssetScene &out) {
+    cgltf_options options{};
+    cgltf_data *data = nullptr;
+
+    if (cgltf_parse_file(&options, path, &data) != cgltf_result_success) {
+        VEL_ERROR("Failed to parse glTF: {}", path);
+        return false;
+    }
+
+    if (cgltf_load_buffers(&options, data, path) != cgltf_result_success) {
+        VEL_ERROR("Failed to load glTF buffers: {}", path);
+
+        cgltf_free(data);
+
+        return false;
+    }
+
+    out = {};
+
+    std::filesystem::path gltf_path(path);
+
+    std::string gltf_dir = gltf_path.parent_path().generic_string();
+
+    // materials
+    out.materials.resize(data->materials_count);
+
+    for (cgltf_size i = 0; i < data->materials_count; ++i) {
+        const cgltf_material &m = data->materials[i];
+
+        AssetMaterial &mat = out.materials[i];
+
+        if (m.name) {
+            mat.name = m.name;
+        }
+
+        mat.double_sided = m.double_sided;
+
+        if (m.has_pbr_metallic_roughness) {
+            const auto &pbr = m.pbr_metallic_roughness;
+
+            mat.base_color = vec4(
+                pbr.base_color_factor[0], pbr.base_color_factor[1], pbr.base_color_factor[2], pbr.base_color_factor[3]
+            );
+
+            mat.metallic = (f32)pbr.metallic_factor;
+            mat.roughness = (f32)pbr.roughness_factor;
+
+            mat.base_color_tex = add_texture(out, pbr.base_color_texture, gltf_dir, true);
+
+            mat.mr_tex = add_texture(out, pbr.metallic_roughness_texture, gltf_dir, false);
+        }
+
+        mat.normal_tex = add_texture(out, m.normal_texture, gltf_dir, false);
+
+        mat.emissive_tex = add_texture(out, m.emissive_texture, gltf_dir, true);
+
+        mat.emissive = vec3((f32)m.emissive_factor[0], (f32)m.emissive_factor[1], (f32)m.emissive_factor[2]);
+    }
+
+    // meshes
+    out.meshes.resize(data->meshes_count);
+    out.mesh_names.resize(data->meshes_count);
+
+    for (cgltf_size mi = 0; mi < data->meshes_count; ++mi) {
+        const cgltf_mesh &src_mesh = data->meshes[mi];
+
+        AssetMesh &mesh = out.meshes[mi];
+        mesh.first_submesh = (u32)out.mesh_submeshes.size();
+
+        if (src_mesh.name) {
+            out.mesh_names[mi] = src_mesh.name;
+        }
+
+        for (cgltf_size pi = 0; pi < src_mesh.primitives_count; ++pi) {
+            const cgltf_primitive &prim = src_mesh.primitives[pi];
+
+            if (prim.type != cgltf_primitive_type_triangles) {
+                continue;
+            }
+
+            std::vector<vec3> positions;
+            std::vector<vec3> normals;
+            std::vector<vec2> uvs;
+            std::vector<vec4> tangents;
+
+            std::vector<f32> float_data;
+
+            for (cgltf_size ai = 0; ai < prim.attributes_count; ++ai) {
+                const cgltf_attribute &attr = prim.attributes[ai];
+
+                cgltf_accessor *accessor = attr.data;
+
+                float_data.resize(accessor->count * cgltf_num_components(accessor->type));
+
+                cgltf_accessor_unpack_floats(accessor, float_data.data(), float_data.size());
+
+                switch (attr.type) {
+                case cgltf_attribute_type_position: {
+                    positions.resize(accessor->count);
+
+                    memcpy(positions.data(), float_data.data(), float_data.size() * sizeof(f32));
+
+                } break;
+
+                case cgltf_attribute_type_normal: {
+                    normals.resize(accessor->count);
+
+                    memcpy(normals.data(), float_data.data(), float_data.size() * sizeof(f32));
+
+                } break;
+
+                case cgltf_attribute_type_texcoord: {
+                    if (attr.index == 0) {
+                        uvs.resize(accessor->count);
+
+                        memcpy(uvs.data(), float_data.data(), float_data.size() * sizeof(f32));
+                    }
+
+                } break;
+
+                case cgltf_attribute_type_tangent: {
+                    tangents.resize(accessor->count);
+
+                    memcpy(tangents.data(), float_data.data(), float_data.size() * sizeof(f32));
+
+                    // gltf tangents are VEC4 (xyz + sign w), but some
+                    // files store VEC3 (xyz only, no w). In that case
+                    // the w component remains 0.0 from resize()
+                    u32 comps = cgltf_num_components(accessor->type);
+                    if (comps < 4) {
+                        for (auto &t : tangents) {
+                            t.w = 1.0f;
+                        }
+                    }
+
+                } break;
+
+                default:
+                    break;
+                }
+            }
+
+            if (positions.empty()) {
+                continue;
+            }
+
+            // indices
+            std::vector<u32> indices;
+
+            if (prim.indices) {
+                indices.resize(prim.indices->count);
+
+                for (cgltf_size i = 0; i < prim.indices->count; ++i) {
+                    indices[i] = (u32)cgltf_accessor_read_index(prim.indices, i);
+                }
+            } else {
+                indices.resize(positions.size());
+
+                for (u32 i = 0; i < positions.size(); ++i) {
+                    indices[i] = i;
+                }
+            }
+
+            // coordinate conversion
+            for (usize i = 0; i < positions.size(); ++i) {
+                vec4 p = transform_point(positions[i], GLTF_TO_ENGINE);
+                positions[i] = {p.x, p.y, p.z};
+
+                if (i < normals.size()) {
+                    normals[i] = transform_direction(normals[i], GLTF_TO_ENGINE).normalized();
+                }
+            }
+
+            if (!tangents.empty()) {
+                for (usize i = 0; i < tangents.size(); ++i) {
+                    vec3 t = vec3(tangents[i].x, tangents[i].y, tangents[i].z);
+                    t = transform_direction(t, GLTF_TO_ENGINE).normalized();
+                    tangents[i].x = t.x;
+                    tangents[i].y = t.y;
+                    tangents[i].z = t.z;
+                }
+            }
+
+            // generate tangents
+            if (tangents.empty() && !normals.empty() && !uvs.empty()) {
+                tangents.resize(positions.size(), vec4(0, 0, 0, 1));
+
+                MikkUserData user{};
+
+                user.positions = &positions;
+                user.normals = &normals;
+                user.uvs = &uvs;
+                user.indices = &indices;
+                user.tangents_out = &tangents;
+
+                SMikkTSpaceInterface iface{};
+
+                iface.m_getNumFaces = mikk_get_num_faces;
+                iface.m_getNumVerticesOfFace = mikk_get_num_vertices_of_face;
+
+                iface.m_getPosition = mikk_get_position;
+                iface.m_getNormal = mikk_get_normal;
+                iface.m_getTexCoord = mikk_get_texcoord;
+                iface.m_setTSpaceBasic = mikk_set_ts_space_basic;
+
+                SMikkTSpaceContext ctx{};
+
+                ctx.m_pInterface = &iface;
+                ctx.m_pUserData = &user;
+
+                genTangSpaceDefault(&ctx);
+
+                for (usize i = 0; i < tangents.size(); ++i) {
+                    tangents[i].w *= -1.0f;
+                }
+            }
+
+            // ---------------------------------------------
+            // out
+            AssetGeometry geom;
+            geom.first_vertex = (u32)out.vertices.size();
+            geom.vertex_count = (u32)positions.size();
+            geom.first_index = (u32)out.indices.size();
+            geom.index_count = (u32)indices.size();
+
+            for (usize i = 0; i < positions.size(); ++i) {
+                Vertex v{};
+
+                v.pos = positions[i];
+
+                v.normal = (i < normals.size()) ? normals[i] : vec3(0, 0, 1);
+
+                v.uv = (i < uvs.size()) ? uvs[i] : vec2(0);
+
+                v.tangent = (i < tangents.size()) ? tangents[i] : vec4(1, 0, 0, 1);
+
+                out.vertices.push_back(v);
+            }
+
+            out.indices.insert(out.indices.end(), indices.begin(), indices.end());
+
+            u32 geom_index = (u32)out.geometries.size();
+
+            out.geometries.push_back(geom);
+
+            AssetSubmesh submesh{};
+
+            submesh.geometry = geom_index;
+
+            submesh.material = prim.material ? (u32)(prim.material - data->materials) : ASSET_INVALID;
+
+            // Compute submesh bounds from converted vertex positions
+            {
+                vec3 min_pos{FLT_MAX, FLT_MAX, FLT_MAX};
+                vec3 max_pos{-FLT_MAX, -FLT_MAX, -FLT_MAX};
+                for (u32 idx : indices) {
+                    const vec3 &p = positions[idx];
+                    min_pos.x = std::min(min_pos.x, p.x);
+                    min_pos.y = std::min(min_pos.y, p.y);
+                    min_pos.z = std::min(min_pos.z, p.z);
+                    max_pos.x = std::max(max_pos.x, p.x);
+                    max_pos.y = std::max(max_pos.y, p.y);
+                    max_pos.z = std::max(max_pos.z, p.z);
+                }
+                submesh.aabb_min = min_pos;
+                submesh.aabb_max = max_pos;
+                vec3 center = (min_pos + max_pos) * 0.5f;
+                f32 radius = (max_pos - min_pos).length() * 0.5f;
+                submesh.sphere = vec4(center.x, center.y, center.z, radius);
+            }
+
+            if (prim.material && prim.material->name) {
+                out.submesh_names.push_back(prim.material->name);
+            } else {
+                out.submesh_names.emplace_back();
+            }
+
+            u32 submesh_index = (u32)out.submeshes.size();
+
+            out.submeshes.push_back(submesh);
+
+            out.mesh_submeshes.push_back(submesh_index);
+        }
+
+        mesh.submesh_count = (u32)out.mesh_submeshes.size() - mesh.first_submesh;
+    }
+
+    // nodes
+    out.nodes.resize(data->nodes_count);
+    out.node_names.resize(data->nodes_count);
+
+    for (cgltf_size ni = 0; ni < data->nodes_count; ++ni) {
+        const cgltf_node &src = data->nodes[ni];
+
+        AssetNode &dst = out.nodes[ni];
+
+        if (src.name) {
+            out.node_names[ni] = src.name;
+        }
+
+        cgltf_node_transform_local(&src, dst.local.m);
+
+        dst.local = inverse(GLTF_TO_ENGINE) * dst.local * GLTF_TO_ENGINE;
+
+        if (src.parent) {
+            dst.parent = (int)(src.parent - data->nodes);
+        }
+
+        if (src.mesh) {
+            dst.mesh = (u32)(src.mesh - data->meshes);
+        }
+
+        if (src.camera) {
+            dst.camera = (i32)(src.camera - data->cameras);
+        }
+
+        if (src.light) {
+            dst.light = (i32)(src.light - data->lights);
+        }
+
+        dst.first_child = (u32)out.child_indices.size();
+        dst.child_count = (u32)src.children_count;
+        for (cgltf_size ci = 0; ci < src.children_count; ++ci) {
+            out.child_indices.push_back((u32)(src.children[ci] - data->nodes));
+        }
+
+        dst.first_instance = (u32)out.instance_locals.size();
+        dst.instance_count = 0;
+        if (src.has_mesh_gpu_instancing) {
+            const cgltf_mesh_gpu_instancing &inst = src.mesh_gpu_instancing;
+            const cgltf_accessor *transl = nullptr;
+            const cgltf_accessor *rot = nullptr;
+            const cgltf_accessor *scale = nullptr;
+            for (cgltf_size ai = 0; ai < inst.attributes_count; ++ai) {
+                const cgltf_attribute &attr = inst.attributes[ai];
+                if (strcmp(attr.name, "TRANSLATION") == 0) {
+                    transl = attr.data;
+                } else if (strcmp(attr.name, "ROTATION") == 0) {
+                    rot = attr.data;
+                } else if (strcmp(attr.name, "SCALE") == 0) {
+                    scale = attr.data;
+                }
+            }
+
+            cgltf_size count = 0;
+            if (transl) {
+                count = transl->count;
+            } else if (rot) {
+                count = rot->count;
+            } else if (scale) {
+                count = scale->count;
+            }
+            dst.instance_count = (u32)count;
+
+            // gltf -> engine frame conversion (a rotation), applied to TRS directly.
+            // Exact for uniform/identity scale; non-uniform scale is approximated by
+            // the TRS decomposition (a TRS cannot represent a rotated non-uniform scale).
+            const quat frame = mat4_to_trs(GLTF_TO_ENGINE).rotation;
+            const quat frame_inv = rtm::quat_conjugate(frame.q);
+
+            out.instance_locals.reserve(out.instance_locals.size() + count);
+            for (cgltf_size ii = 0; ii < count; ++ii) {
+                TRS trs;
+                if (transl) {
+                    f32 v[3];
+                    cgltf_accessor_read_float(transl, ii, v, 3);
+                    trs.translation = vec3(v[0], v[1], v[2]);
+                }
+                if (rot) {
+                    f32 v[4];
+                    cgltf_accessor_read_float(rot, ii, v, 4);
+                    trs.rotation = quat(rtm::quat_normalize(rtm::vector_set(v[0], v[1], v[2], v[3])));
+                }
+                if (scale) {
+                    f32 v[3];
+                    cgltf_accessor_read_float(scale, ii, v, 3);
+                    trs.scale = vec3(v[0], v[1], v[2]);
+                }
+
+                trs.translation = transform_direction(trs.translation, GLTF_TO_ENGINE);
+                trs.rotation = quat(rtm::quat_mul(frame_inv, rtm::quat_mul(trs.rotation.q, frame)));
+                out.instance_locals.push_back(trs);
+            }
+        }
+    }
+
+    // camers
+    out.cameras.resize(data->cameras_count);
+    for (cgltf_size ci = 0; ci < data->cameras_count; ++ci) {
+        const cgltf_camera &src = data->cameras[ci];
+        AssetCamera &dst = out.cameras[ci];
+
+        if (src.type == cgltf_camera_type_perspective) {
+            dst.type = AssetCamera::Perspective;
+            dst.yfov = src.data.perspective.yfov;
+            dst.znear = src.data.perspective.znear;
+            dst.zfar = src.data.perspective.has_zfar ? src.data.perspective.zfar : 1000.0f;
+            dst.aspect_ratio = src.data.perspective.has_aspect_ratio ? src.data.perspective.aspect_ratio : 0.0f;
+        } else {
+            dst.type = AssetCamera::Orthographic;
+            dst.yfov = 0.0f;
+            dst.znear = src.data.orthographic.znear;
+            dst.zfar = src.data.orthographic.zfar;
+        }
+    }
+
+    // lights (KHR_lights_punctual)
+    out.lights.resize(data->lights_count);
+    for (cgltf_size li = 0; li < data->lights_count; ++li) {
+        const cgltf_light &src = data->lights[li];
+        AssetLight &dst = out.lights[li];
+
+        if (src.type == cgltf_light_type_directional) {
+            dst.type = AssetLight::Directional;
+        } else if (src.type == cgltf_light_type_point) {
+            dst.type = AssetLight::Point;
+            dst.range = src.range;
+        }
+        dst.color.x = src.color[0];
+        dst.color.y = src.color[1];
+        dst.color.z = src.color[2];
+        dst.intensity = src.intensity;
+    }
+
+    // root nodes
+    const cgltf_scene *scene = data->scene ? data->scene : &data->scenes[0];
+
+    for (cgltf_size i = 0; i < scene->nodes_count; ++i) {
+        out.root_nodes.push_back((u32)(scene->nodes[i] - data->nodes));
+    }
+
+    VEL_INFO(
+        "Loaded glTF: {} meshes, {} submeshes, {} materials, {} textures, {} cameras, {} lights",
+        out.meshes.size(),
+        out.submeshes.size(),
+        out.materials.size(),
+        out.textures.size(),
+        out.cameras.size(),
+        out.lights.size()
+    );
+
+    cgltf_free(data);
+
+    return true;
+}

--- a/src/asset/texture.cpp
+++ b/src/asset/texture.cpp
@@ -0,0 +1,423 @@
+#include "texture.h"
+
+#include <ktx.h>
+#include <stb_image.h>
+
+#include <cstdio>
+#include <filesystem>
+#include <string>
+
+#include "core/globals.h"
+#include "core/gpu_arena.h"
+#include "quick_submit.h"
+
+static u32 calculate_mip_levels(u32 width, u32 height) {
+    u32 levels = 1;
+    while (width > 1 || height > 1) {
+        width >>= 1;
+        height >>= 1;
+        levels++;
+    }
+    return levels;
+}
+
+static ktx_transcode_fmt_e to_ktx_transcode_format(rhi::ImageFormat fmt) {
+    switch (fmt) {
+    case rhi::ImageFormat::BC7_UNORM:
+    case rhi::ImageFormat::BC7_SRGB:
+        return KTX_TTF_BC7_RGBA;
+    default:
+        return KTX_TTF_RGBA32;
+    }
+}
+
+static rhi::ImageRange whole_range(u32 mip_levels, u32 layers) {
+    rhi::ImageRange r{};
+    r.mip_count = mip_levels;
+    r.layer_count = layers;
+    return r;
+}
+
+static rhi::ImageRange mip_range(u32 mip) {
+    rhi::ImageRange r{};
+    r.mip = mip;
+    r.mip_count = 1;
+    r.layer_count = 1;
+    return r;
+}
+
+static void barrier_image_to_transfer_dst(rhi::CmdBuffer &cmd, rhi::Image *image, u32 mip_levels, u32 layers) {
+    rhi::barrier(
+        cmd, *image, whole_range(mip_levels, layers), rhi::ResourceState::Idle, rhi::ResourceState::TransferTo
+    );
+}
+
+static void barrier_image_to_shader_read(rhi::CmdBuffer &cmd, rhi::Image *image, u32 mip_levels, u32 layers) {
+    rhi::barrier(
+        cmd, *image, whole_range(mip_levels, layers), rhi::ResourceState::TransferTo, rhi::ResourceState::TextureSample
+    );
+}
+
+static void barrier_mip_to_src(rhi::CmdBuffer &cmd, rhi::Image *image, u32 mip) {
+    rhi::barrier(cmd, *image, mip_range(mip), rhi::ResourceState::TransferTo, rhi::ResourceState::TransferFrom);
+}
+
+static void barrier_mip_to_shader_read(rhi::CmdBuffer &cmd, rhi::Image *image, u32 mip) {
+    rhi::barrier(cmd, *image, mip_range(mip), rhi::ResourceState::TransferFrom, rhi::ResourceState::TextureSample);
+}
+
+static void set_view_shader_read(rhi::ImageView *view) {
+    if (view == nullptr || view->desc.image == nullptr) {
+        return;
+    }
+    view->desc.image->state = rhi::ResourceState::TextureSample;
+}
+
+static void generate_mips_2d(rhi::CmdBuffer &cmd, rhi::Image *image, u32 width, u32 height, u32 mip_levels) {
+    u32 mip_w = width;
+    u32 mip_h = height;
+    for (u32 i = 0; i < mip_levels - 1; ++i) {
+        u32 next_w = std::max(mip_w >> 1, 1u);
+        u32 next_h = std::max(mip_h >> 1, 1u);
+
+        barrier_mip_to_src(cmd, image, i);
+
+        rhi::ImageBlit blit{
+            .src_mip = i,
+            .dst_mip = i + 1,
+            .src_x0 = 0,
+            .src_y0 = 0,
+            .src_x1 = static_cast<i32>(mip_w),
+            .src_y1 = static_cast<i32>(mip_h),
+            .dst_x0 = 0,
+            .dst_y0 = 0,
+            .dst_x1 = static_cast<i32>(next_w),
+            .dst_y1 = static_cast<i32>(next_h),
+        };
+        rhi::blit_image(cmd, *image, &blit, 1);
+
+        barrier_mip_to_shader_read(cmd, image, i);
+
+        mip_w = next_w;
+        mip_h = next_h;
+    }
+    // previous mip is still in TransferTo — transition it now
+    rhi::barrier(
+        cmd, *image, mip_range(mip_levels - 1), rhi::ResourceState::TransferTo, rhi::ResourceState::TextureSample
+    );
+}
+
+static bool upload_stb_pixels(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const void *pixels,
+    u32 width,
+    u32 height,
+    u64 pixel_stride, // bytes per pixel × channels (4 or 16)
+    rhi::ImageFormat format,
+    const char *name = nullptr
+) {
+    u32 mip_levels = calculate_mip_levels(width, height);
+    u64 image_size = static_cast<u64>(width) * height * pixel_stride;
+    u64 staging_off = stage_to_arena(staging, pixels, image_size);
+    if (staging_off == SIZE_MAX) {
+        return false;
+    }
+    rhi::buffer_flush(device, staging.buffer, staging_off, image_size);
+
+    rhi::ImageDesc img_desc{};
+    img_desc.width = width;
+    img_desc.height = height;
+    img_desc.mip_levels = mip_levels;
+    if (name != nullptr) {
+        img_desc.name = name;
+    }
+    img_desc.usage = rhi::ImageUsage::Sampled | rhi::ImageUsage::TransferDst | rhi::ImageUsage::TransferSrc;
+    img_desc.format = format;
+    rhi::create_image(device, img_desc, out_image);
+
+    rhi::ImageViewDesc view_desc{};
+    view_desc.image = &out_image;
+    if (!rhi::create_image_view(device, view_desc, out_view)) {
+        rhi::destroy_image(device, out_image);
+        return false;
+    }
+
+    QsCmd *cmd = qs_acquire(qs);
+
+    barrier_image_to_transfer_dst(cmd->cmd, &out_image, mip_levels, 1);
+
+    rhi::BufferTextureCopyRegion region{};
+    region.buffer_offset = staging_off;
+    region.texture_extent_width = width;
+    region.texture_extent_height = height;
+    region.texture_extent_depth = 1;
+    region.base_array_layer = 0;
+    region.mip_level = 0;
+    region.layer_count = 1;
+    rhi::copy_buffer_to_texture(cmd->cmd, staging.buffer, out_view, region);
+
+    if (mip_levels > 1) {
+        generate_mips_2d(cmd->cmd, &out_image, width, height, mip_levels);
+    } else {
+        barrier_image_to_shader_read(cmd->cmd, &out_image, 1, 1);
+    }
+
+    set_view_shader_read(&out_view);
+
+    qs_submit(qs, *cmd);
+    return true;
+}
+
+bool ktx_texture_needs_to_flip_to_top_left(ktxTexture *kTexture) {
+    if (!kTexture) {
+        return false;
+    }
+
+    if (kTexture->orientation.y == 'u') {
+        return true;
+    }
+
+    return false;
+}
+
+static bool upload_ktx2_texture(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    ktxTexture2 *ktx_tex,
+    const char *name = nullptr
+) {
+    ktxTexture *base = ktxTexture(ktx_tex);
+    u32 width = base->baseWidth;
+    u32 height = base->baseHeight;
+    u32 mip_levels = base->numLevels;
+    u32 layers = base->numLayers;
+    u32 faces = base->numFaces;
+    u32 array_layers = (layers > 1) ? layers : faces;
+    bool is_cubemap = (faces == 6);
+
+    rhi::ImageDesc image_desc{};
+    if (name != nullptr) {
+        image_desc.name = name;
+    }
+    image_desc.format = rhi::image_format_from_vk(ktx_tex->vkFormat);
+    image_desc.is_cubemap = is_cubemap;
+    image_desc.width = width;
+    image_desc.height = height;
+    image_desc.mip_levels = mip_levels;
+    image_desc.layers = array_layers;
+    image_desc.usage = rhi::ImageUsage::TransferDst | rhi::ImageUsage::Sampled;
+    rhi::create_image(device, image_desc, out_image);
+
+    rhi::ImageViewDesc view_desc{};
+    view_desc.image = &out_image;
+    view_desc.aspect = rhi::ImageAspect::Color;
+    view_desc.dimension = is_cubemap ? rhi::TextureViewDimension::TEXTURE_CUBE : rhi::TextureViewDimension::TEXTURE_2D;
+    view_desc.layer_count = array_layers;
+    if (!rhi::create_image_view(device, view_desc, out_view)) {
+        rhi::destroy_image(device, out_image);
+        ktxTexture_Destroy(base);
+        return false;
+    }
+
+    ktx_size_t data_size = ktxTexture_GetDataSize(base);
+    u64 staging_off = stage_to_arena(staging, base->pData, data_size);
+    if (staging_off == SIZE_MAX) {
+        ktxTexture_Destroy(base);
+        return false;
+    }
+    rhi::buffer_flush(device, staging.buffer, staging_off, data_size);
+
+    QsCmd *cmd = qs_acquire(qs);
+
+    barrier_image_to_transfer_dst(cmd->cmd, &out_image, mip_levels, array_layers);
+
+    for (u32 level = 0; level < mip_levels; ++level) {
+        for (u32 layer = 0; layer < array_layers; ++layer) {
+            ktx_size_t offset;
+            ktxTexture_GetImageOffset(base, level, layer, 0, &offset);
+
+            rhi::BufferTextureCopyRegion region{};
+            region.buffer_offset = staging_off + offset;
+            region.mip_level = level;
+            region.base_array_layer = layer;
+            region.layer_count = 1;
+            region.texture_extent_width = std::max(width >> level, 1u);
+            region.texture_extent_height = std::max(height >> level, 1u);
+            region.texture_extent_depth = 1;
+            rhi::copy_buffer_to_texture(cmd->cmd, staging.buffer, out_view, region);
+        }
+    }
+
+    barrier_image_to_shader_read(cmd->cmd, &out_image, mip_levels, array_layers);
+
+    set_view_shader_read(&out_view);
+
+    qs_submit(qs, *cmd);
+    ktxTexture_Destroy(base);
+    return true;
+}
+
+////////////
+bool load_texture_from_memory(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const u8 *data,
+    usize size,
+    ImageColorSpace color_space,
+    const char *name
+) {
+    int w, h, channels;
+    stbi_uc *pixels = stbi_load_from_memory(data, static_cast<int>(size), &w, &h, &channels, STBI_rgb_alpha);
+    if (!pixels) {
+        (void)std::fprintf(stderr, "Failed to load texture from memory (size: %zu)\n", size);
+        return false;
+    }
+
+    rhi::ImageFormat fmt =
+        (color_space == ImageColorSpace::SRGB) ? rhi::ImageFormat::RGBA8_SRGB : rhi::ImageFormat::RGBA8_UNORM;
+    bool ok = upload_stb_pixels(
+        device, qs, staging, out_image, out_view, pixels, static_cast<u32>(w), static_cast<u32>(h), 4, fmt, name
+    );
+    stbi_image_free(pixels);
+    return ok;
+}
+
+bool create_texture_from_raw_rgba(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const void *pixels,
+    u32 width,
+    u32 height,
+    u32 pixel_stride,
+    rhi::ImageFormat cs,
+    const char *name
+) {
+    return upload_stb_pixels(device, qs, staging, out_image, out_view, pixels, width, height, pixel_stride, cs, name);
+}
+
+bool load_texture_ktx2_from_memory(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const u8 *data,
+    usize size,
+    ImageColorSpace color_space,
+    const char *name
+) {
+    ktxTexture2 *ktx_tex = nullptr;
+    if (ktxTexture2_CreateFromMemory(data, size, KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &ktx_tex) != KTX_SUCCESS) {
+        return false;
+    }
+
+    if (ktxTexture2_NeedsTranscoding(ktx_tex)) {
+        ktx_transcode_fmt_e tf =
+            to_ktx_transcode_format(rhi::preferred_compressed_format(device, color_space == ImageColorSpace::SRGB));
+
+        if (ktxTexture2_TranscodeBasis(ktx_tex, tf, 0) != KTX_SUCCESS) {
+            (void)std::fprintf(stderr, "KTX2 transcode failed\n");
+            ktxTexture_Destroy(ktxTexture(ktx_tex));
+            return false;
+        }
+    }
+
+    return upload_ktx2_texture(device, qs, staging, out_image, out_view, ktx_tex, name);
+}
+
+bool load_texture(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    const char *path,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    ImageColorSpace color_space
+) {
+    std::filesystem::path p(path);
+    std::string ext = p.extension().string();
+
+    if (ext == ".ktx2") {
+        ktxTexture2 *ktx_tex = nullptr;
+        KTX_error_code err = ktxTexture2_CreateFromNamedFile(path, KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &ktx_tex);
+
+        if (err != KTX_SUCCESS) {
+            (void)std::fprintf(stderr, "Failed to load KTX2: %s (error: %d)\n", path, err);
+            return false;
+        }
+
+        if (ktxTexture2_NeedsTranscoding(ktx_tex)) {
+            ktx_transcode_fmt_e tf =
+                to_ktx_transcode_format(rhi::preferred_compressed_format(device, color_space == ImageColorSpace::SRGB));
+
+            if (ktxTexture2_TranscodeBasis(ktx_tex, tf, 0) != KTX_SUCCESS) {
+                (void)std::fprintf(stderr, "KTX2 transcode failed: %s\n", path);
+                ktxTexture_Destroy(ktxTexture(ktx_tex));
+                return false;
+            }
+        }
+
+        return upload_ktx2_texture(device, qs, staging, out_image, out_view, ktx_tex, path);
+    }
+
+    if (ext == ".hdr") {
+        int w, h, channels;
+        f32 *pixels = stbi_loadf(path, &w, &h, &channels, STBI_rgb_alpha);
+        if (!pixels) {
+            (void)std::fprintf(stderr, "Failed to load HDR texture: %s\n", path);
+            return false;
+        }
+
+        bool ok = upload_stb_pixels(
+            device,
+            qs,
+            staging,
+            out_image,
+            out_view,
+            pixels,
+            static_cast<u32>(w),
+            static_cast<u32>(h),
+            sizeof(f32) * 4,
+            rhi::ImageFormat::RGBA32_FLOAT,
+            path
+        );
+        stbi_image_free(pixels);
+        return ok;
+    }
+
+    // fallback: assume PNG / 8-bit
+    int w, h, channels;
+    stbi_uc *pixels = stbi_load(path, &w, &h, &channels, STBI_rgb_alpha);
+    if (!pixels) {
+        (void)std::fprintf(stderr, "Failed to load texture: %s\n", path);
+        return false;
+    }
+
+    rhi::ImageFormat fmt =
+        (color_space == ImageColorSpace::SRGB) ? rhi::ImageFormat::RGBA8_SRGB : rhi::ImageFormat::RGBA8_UNORM;
+    bool ok = upload_stb_pixels(
+        device, qs, staging, out_image, out_view, pixels, static_cast<u32>(w), static_cast<u32>(h), 4, fmt, path
+    );
+    stbi_image_free(pixels);
+    return ok;
+}
+
+void destroy_texture(rhi::Device &device, rhi::Image &image, rhi::ImageView &view) {
+    rhi::destroy_image_view(device, view);
+    rhi::destroy_image(device, image);
+    image = {};
+    view = {};
+}

--- a/src/asset/texture.h
+++ b/src/asset/texture.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include "backend/rhi.h"
+#include "core/globals.h"
+
+enum struct ImageColorSpace {
+    SRGB,
+    Linear,
+};
+
+struct Arena;
+struct QuickSubmit;
+
+bool load_texture_from_memory(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const u8 *data,
+    usize size,
+    ImageColorSpace color_space,
+    const char *name = nullptr
+);
+
+bool load_texture_ktx2_from_memory(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const u8 *data,
+    usize size,
+    ImageColorSpace color_space,
+    const char *name = nullptr
+);
+
+bool create_texture_from_raw_rgba(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    const void *pixels,
+    u32 width,
+    u32 height,
+    u32 pixel_stride,
+    rhi::ImageFormat cs,
+    const char *name = nullptr
+);
+
+bool load_texture(
+    rhi::Device &device,
+    QuickSubmit &qs,
+    Arena &staging,
+    const char *path,
+    rhi::Image &out_image,
+    rhi::ImageView &out_view,
+    ImageColorSpace color_space
+);
+
+void destroy_texture(rhi::Device &device, rhi::Image &image, rhi::ImageView &view);

--- a/src/backend/conformance/descriptor_handle/descriptor_handle.cpp
+++ b/src/backend/conformance/descriptor_handle/descriptor_handle.cpp
@@ -0,0 +1,283 @@
+#include "backend/rhi.h"
+#include "core/logger.h"
+#include "core/math_rtm.h"
+#include "core/platform.h"
+
+#include <chrono>
+#include <cmath>
+#include <cstring>
+
+static constexpr u32 DH_TEX_W = 2;
+static constexpr u32 DH_TEX_H = 2;
+static constexpr u8 DH_TEX[2][DH_TEX_W * DH_TEX_H * 4] = {
+    {255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255},
+    {0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255, 0, 0, 255, 255},
+};
+static constexpr f32 DH_OFFSET[4] = {0.2f, -0.15f, 0.0f, 0.0f};
+
+struct DhPush {
+    vec4 tint; // 0
+    u64 tex;   // 16, slot (vk) / ResourceID (mtl)
+    u64 samp;  // 24, slot (vk) / ResourceID (mtl)
+    u64 ubo;   // 32, slot (vk) / device address (mtl)
+    u64 cbuf;  // 40, slot (vk) / device address (mtl)
+    u64 bbuf;  // 48, slot (vk) / device address (mtl)
+    u64 addr;  // 56, device address (both)
+};
+static_assert(sizeof(DhPush) == 64, "DhPush size drift");
+
+int main() {
+    vel::Logger::init();
+    rhi::Config config{};
+    config.vsync_enabled = true;
+    config.enable_validation = true;
+    rhi::Device device{};
+    rhi::Swapchain swapchain{};
+    rhi::CmdPool pool{};
+    rhi::CmdBuffer cmd{};
+    rhi::Sync *frame_sync = nullptr;
+    rhi::ShaderCompiler sc{};
+    rhi::RenderPipeline pipeline{};
+    Platform platform{};
+    platform.width = 800;
+    platform.height = 800;
+
+    init_platform(config.instance_extensions);
+    rhi::create_context(device, config);
+    rhi::create_memory_allocator(device);
+    rhi::init_compiler(sc);
+    create_window(device, platform, "descriptor-handle", WindowMode::Windowed, true);
+
+    rhi::SwapchainDesc swapchain_desc{};
+    swapchain_desc.native_window = platform_native_window(platform);
+    swapchain_desc.width = platform.width;
+    swapchain_desc.height = platform.height;
+    swapchain_desc.vsync_enabled = config.vsync_enabled;
+    swapchain_desc.image_count = config.swapchain_image_count;
+    rhi::create_swapchain(device, swapchain_desc, swapchain);
+
+    rhi::Queue graphics_queue = rhi::graphics_queue(device);
+    rhi::CmdPoolDesc cmd_pool_desc;
+    cmd_pool_desc.queue_family_index = rhi::queue_family_index(graphics_queue);
+    cmd_pool_desc.flags = rhi::CmdPoolUsage::Transient | rhi::CmdPoolUsage::ResetCommandBuffer;
+    rhi::create_cmd_pool(device, cmd_pool_desc, pool);
+    rhi::CmdBufferDesc cmd_desc{};
+    cmd_desc.pool = &pool;
+    cmd_desc.level = rhi::CmdBufferLevel::Primary;
+    rhi::create_cmd_buffer(device, cmd_desc, cmd);
+    frame_sync = rhi::sync_create(device, 0);
+
+    rhi::Buffer offset_buf{};
+    rhi::BufferView offset_view{};
+    rhi::BufferView offset_cview{};
+    rhi::BufferView offset_bview{};
+    {
+        rhi::BufferDesc d{};
+        d.size = sizeof(DH_OFFSET);
+        d.usage = rhi::BufferUsage::StorageBuffer | rhi::BufferUsage::UniformBuffer | rhi::BufferUsage::ShaderAddr;
+        d.memory = rhi::BufferMemType::Upload;
+        rhi::create_buffer(device, d, offset_buf);
+        std::memcpy(offset_buf.mapped, DH_OFFSET, sizeof(DH_OFFSET));
+        rhi::BufferViewDesc vd{};
+        vd.buffer = &offset_buf;
+        vd.offset = 0;
+        vd.size = sizeof(DH_OFFSET);
+        vd.type = rhi::BufferViewType::Storage;
+        if (!rhi::create_buffer_view(device, vd, offset_view)) {
+            VEL_CRITICAL("descriptor-handle: failed to create buffer view");
+            return 1;
+        }
+        vd.type = rhi::BufferViewType::Uniform;
+        if (!rhi::create_buffer_view(device, vd, offset_cview)) {
+            VEL_CRITICAL("descriptor-handle: failed to create constant buffer view");
+            return 1;
+        }
+        vd.type = rhi::BufferViewType::Storage;
+        if (!rhi::create_buffer_view(device, vd, offset_bview)) {
+            VEL_CRITICAL("descriptor-handle: failed to create byte buffer view");
+            return 1;
+        }
+    }
+
+    rhi::Sampler sampler{};
+    {
+        rhi::SamplerDesc sdesc{};
+        sdesc.filter = rhi::SamplerFilter::LINEAR;
+        sdesc.address = rhi::SamplerAddressMode::CLAMP;
+        rhi::create_sampler(device, sdesc, sampler);
+    }
+
+    rhi::Image tex_img[2];
+    rhi::ImageView tex_view[2];
+    rhi::Buffer staging{};
+    {
+        rhi::BufferDesc d{};
+        d.size = 2 * DH_TEX_W * DH_TEX_H * 4;
+        d.usage = rhi::BufferUsage::CopySrc;
+        d.memory = rhi::BufferMemType::Upload;
+        rhi::create_buffer(device, d, staging);
+    }
+    {
+        rhi::reset_cmd_buffer(cmd);
+        rhi::begin_cmd_buffer(cmd, rhi::CmdBufferBeginDesc{.usage = rhi::CmdBufferUsage::OneTimeSubmit});
+        for (int i = 0; i < 2; ++i) {
+            rhi::ImageDesc idesc{};
+            idesc.width = DH_TEX_W;
+            idesc.height = DH_TEX_H;
+            idesc.format = rhi::ImageFormat::RGBA8_UNORM;
+            idesc.usage = rhi::ImageUsage::Sampled | rhi::ImageUsage::TransferDst;
+            rhi::create_image(device, idesc, tex_img[i]);
+            rhi::ImageViewDesc vdesc{};
+            vdesc.image = &tex_img[i];
+            vdesc.aspect = rhi::ImageAspect::Color;
+            rhi::create_image_view(device, vdesc, tex_view[i]);
+            std::memcpy((u8 *)staging.mapped + i * DH_TEX_W * DH_TEX_H * 4, DH_TEX[i], DH_TEX_W * DH_TEX_H * 4);
+            rhi::ImageRange range{};
+            rhi::barrier(cmd, tex_img[i], range, rhi::ResourceState::Idle, rhi::ResourceState::TransferTo);
+            rhi::BufferTextureCopyRegion region{};
+            region.buffer_offset = (u64)i * DH_TEX_W * DH_TEX_H * 4;
+            region.layer_count = 1;
+            region.texture_extent_width = DH_TEX_W;
+            region.texture_extent_height = DH_TEX_H;
+            region.texture_extent_depth = 1;
+            rhi::copy_buffer_to_texture(cmd, staging, tex_view[i], region);
+            rhi::barrier(cmd, tex_img[i], range, rhi::ResourceState::TransferTo, rhi::ResourceState::TextureSample);
+            tex_img[i].state = rhi::ResourceState::TextureSample;
+        }
+        rhi::end_cmd_buffer(cmd);
+        rhi::QueueSubmitDesc submit{};
+        submit.cmd_count = 1;
+        submit.cmds = &cmd;
+        rhi::queue_submit(device, graphics_queue, submit);
+        rhi::queue_wait_idle(device);
+    }
+
+    rhi::RenderPipelineDesc pd{};
+    pd.device = &device;
+    pd.set_shaders(sc, "conformance/descriptor_handle.slang", "vsMain", "fsMain");
+    pd.set_depth_testing(false, false, rhi::PipelineCompareOp::LESS);
+    pd.set_cull_mode(rhi::PipelineCullMode::NONE, rhi::PipelineTriangleWindingOrder::CCW);
+    pd.set_color_format(rhi::swapchain_format(swapchain));
+    pipeline = pd.build();
+    if (!rhi::valid(pipeline)) {
+        VEL_CRITICAL("descriptor-handle: pipeline build failed");
+        return 1;
+    }
+
+    const auto start = std::chrono::steady_clock::now();
+    u64 frame_count = 0;
+    while (platform_update(platform)) {
+        if (platform.framebuffer_resized || rhi::swapchain_needs_recreate(swapchain)) {
+            platform.framebuffer_resized = false;
+            if (!platform_wait_for_valid_framebuffer(platform)) {
+                break;
+            }
+            rhi::queue_wait_idle(device);
+            rhi::destroy_swapchain(device, swapchain);
+            swapchain_desc.width = platform.width;
+            swapchain_desc.height = platform.height;
+            rhi::create_swapchain(device, swapchain_desc, swapchain);
+            continue;
+        }
+        const f32 time = std::chrono::duration<f32>(std::chrono::steady_clock::now() - start).count();
+        const u32 alt = (u32)((u64)time % 2);
+        DhPush push{};
+        const f32 pulse = 0.75f + 0.25f * std::sin(time * 2.0f);
+        push.tint = vec4(pulse, pulse, pulse, 1.0f);
+        push.tex = rhi::handle_id(device, tex_view[alt]);
+        push.samp = rhi::handle_id(device, sampler);
+        push.ubo = rhi::handle_id(device, offset_view);
+        push.cbuf = rhi::handle_id(device, offset_cview);
+        push.bbuf = rhi::handle_id(device, offset_bview);
+        push.addr = rhi::buffer_device_address(device, offset_buf);
+        if (tex_view[alt].slot == UINT64_MAX || sampler.slot == UINT64_MAX || offset_view.slot == UINT64_MAX ||
+            offset_cview.slot == UINT64_MAX || offset_bview.slot == UINT64_MAX || push.addr == 0) {
+            VEL_CRITICAL(
+                "descriptor-handle: null handle (tex={} samp={} ubo={} cbuf={} bbuf={} addr={})",
+                push.tex,
+                push.samp,
+                push.ubo,
+                push.cbuf,
+                push.bbuf,
+                push.addr
+            );
+            return 1;
+        }
+
+        rhi::reset_cmd_buffer(cmd);
+        rhi::begin_cmd_buffer(cmd, rhi::CmdBufferBeginDesc{.usage = rhi::CmdBufferUsage::OneTimeSubmit});
+        u32 image_index = 0;
+        if (!rhi::acquire_swapchain_image(device, swapchain, image_index, cmd)) {
+            rhi::reset_cmd_buffer(cmd);
+            continue;
+        }
+        rhi::Image *swap_image = rhi::swapchain_image(swapchain, image_index);
+        rhi::Extent2D extent = rhi::swapchain_extent(swapchain);
+        rhi::ImageView swap_view = rhi::get_cached_image_view(device, *swap_image, {.aspect = rhi::ImageAspect::Color});
+
+        rhi::AttachmentDesc color_att{};
+        color_att.img = &swap_view;
+        color_att.loadOp = rhi::LoadOp::CLEAR;
+        color_att.storeOp = rhi::StoreOp::STORE;
+        color_att.clearValue.color.float32[0] = 0.1f;
+        color_att.clearValue.color.float32[1] = 0.1f;
+        color_att.clearValue.color.float32[2] = 0.1f;
+        color_att.clearValue.color.float32[3] = 1.0f;
+        rhi::RenderingInfo ri{};
+        ri.colorAttachments[0] = color_att;
+        ri.colorAttachmentCount = 1;
+        ri.width = extent.width;
+        ri.height = extent.height;
+
+        rhi::begin_rendering(cmd, ri);
+        rhi::set_pipeline(cmd, pipeline);
+        rhi::Viewport vp{};
+        vp.width = (f32)extent.width;
+        vp.height = (f32)extent.height;
+        rhi::set_viewports(cmd, &vp);
+        rhi::Rect scissor{};
+        scissor.width = (i16)extent.width;
+        scissor.height = (i16)extent.height;
+        rhi::set_scissors(cmd, &scissor);
+        rhi::set_constants(cmd, pipeline, rhi::ShaderStage::VERTEX | rhi::ShaderStage::FRAGMENT, sizeof(push), &push);
+        rhi::draw(cmd, 3, 1, 0, 0);
+        rhi::end_rendering(cmd);
+
+        rhi::ImageRange range{};
+        rhi::barrier(cmd, *swap_image, range, swap_image->state, rhi::ResourceState::Display);
+        rhi::end_cmd_buffer(cmd);
+
+        rhi::QueueSignal completion{{frame_sync, frame_count + 1}};
+        rhi::QueueSubmitDesc submit{};
+        submit.cmd_count = 1;
+        submit.cmds = &cmd;
+        submit.signal_count = 1;
+        submit.signals = &completion;
+        rhi::queue_submit(device, graphics_queue, submit);
+        rhi::present_swapchain(device, swapchain, image_index, {frame_sync, frame_count + 1});
+        ++frame_count;
+        rhi::sync_host_wait(frame_sync, frame_count);
+    }
+
+    rhi::device_wait_idle(device);
+    rhi::destroy_pipeline(device, pipeline);
+    rhi::destroy_buffer(device, staging);
+    for (int i = 0; i < 2; ++i) {
+        rhi::destroy_image_view(device, tex_view[i]);
+        rhi::destroy_image(device, tex_img[i]);
+    }
+    rhi::destroy_sampler(device, sampler);
+    rhi::destroy_buffer_view(device, offset_bview);
+    rhi::destroy_buffer_view(device, offset_cview);
+    rhi::destroy_buffer_view(device, offset_view);
+    rhi::destroy_buffer(device, offset_buf);
+    rhi::sync_destroy(frame_sync);
+    rhi::destroy_cmd_buffer(device, pool, cmd);
+    rhi::destroy_cmd_pool(device, pool);
+    rhi::destroy_swapchain(device, swapchain);
+    rhi::destroy_memory_allocator(device);
+    destroy_window(device, platform);
+    rhi::destroy_context(device);
+    vel::Logger::shutdown();
+    return 0;
+}

--- a/src/backend/conformance/indexed_quad/indexed_quad.cpp
+++ b/src/backend/conformance/indexed_quad/indexed_quad.cpp
@@ -0,0 +1,219 @@
+#include "backend/rhi.h"
+#include "core/logger.h"
+#include "core/platform.h"
+
+#include <chrono>
+#include <cmath>
+#include <cstring>
+#include <stddef.h>
+
+static constexpr u32 QUAD_VERTEX_BINDING = 1;
+
+struct QuadVertex {
+    f32 pos[2];
+    f32 color[3];
+};
+
+static constexpr QuadVertex QUAD_VERTICES[4] = {
+    {{-0.5f, -0.5f}, {1.0f, 0.0f, 0.0f}},
+    {{0.5f, -0.5f}, {0.0f, 1.0f, 0.0f}},
+    {{0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}},
+    {{-0.5f, 0.5f}, {1.0f, 1.0f, 1.0f}},
+};
+
+static constexpr u32 QUAD_INDICES[6] = {0, 1, 2, 2, 3, 0};
+
+struct QuadPush {
+    f32 time;
+    f32 _pad0;
+    f32 offset[2];
+    f32 tint[4];
+};
+
+int main() {
+    vel::Logger::init();
+    rhi::Config config{};
+    config.vsync_enabled = true;
+    config.enable_validation = true;
+
+    rhi::Device device{};
+    rhi::Swapchain swapchain{};
+    rhi::CmdPool pool{};
+    rhi::CmdBuffer cmd{};
+    rhi::Sync *frame_sync = nullptr;
+    rhi::ShaderCompiler sc{};
+    rhi::Buffer vertex_buffer{};
+    rhi::Buffer index_buffer{};
+    rhi::RenderPipeline pipeline{};
+
+    Platform platform{};
+    platform.width = 800;
+    platform.height = 800;
+
+    init_platform(config.instance_extensions);
+    rhi::create_context(device, config);
+    if (!rhi::create_memory_allocator(device)) {
+        VEL_CRITICAL("indexed-quad-example: failed to create memory allocator");
+        return 1;
+    }
+    if (!rhi::init_compiler(sc)) {
+        VEL_CRITICAL("indexed-quad-example: failed to init shader compiler");
+        return 1;
+    }
+    create_window(device, platform, "indexed-quad-example", WindowMode::Windowed, true);
+
+    rhi::SwapchainDesc swapchain_desc{};
+    swapchain_desc.native_window = platform_native_window(platform);
+    swapchain_desc.width = platform.width;
+    swapchain_desc.height = platform.height;
+    swapchain_desc.vsync_enabled = config.vsync_enabled;
+    swapchain_desc.image_count = config.swapchain_image_count;
+    rhi::create_swapchain(device, swapchain_desc, swapchain);
+
+    rhi::Queue graphics_queue = rhi::graphics_queue(device);
+
+    rhi::CmdPoolDesc cmd_pool_desc;
+    cmd_pool_desc.queue_family_index = rhi::queue_family_index(graphics_queue);
+    cmd_pool_desc.flags = rhi::CmdPoolUsage::Transient | rhi::CmdPoolUsage::ResetCommandBuffer;
+    rhi::create_cmd_pool(device, cmd_pool_desc, pool);
+    rhi::CmdBufferDesc cmd_desc{};
+    cmd_desc.pool = &pool;
+    cmd_desc.level = rhi::CmdBufferLevel::Primary;
+    rhi::create_cmd_buffer(device, cmd_desc, cmd);
+
+    frame_sync = rhi::sync_create(device, 0);
+
+    rhi::BufferDesc vb_desc{};
+    vb_desc.size = sizeof(QUAD_VERTICES);
+    vb_desc.usage = rhi::BufferUsage::VertexBuffer;
+    vb_desc.memory = rhi::BufferMemType::Upload;
+    rhi::create_buffer(device, vb_desc, vertex_buffer);
+    std::memcpy(vertex_buffer.mapped, QUAD_VERTICES, sizeof(QUAD_VERTICES));
+
+    rhi::BufferDesc ib_desc{};
+    ib_desc.size = sizeof(QUAD_INDICES);
+    ib_desc.usage = rhi::BufferUsage::IndexBuffer;
+    ib_desc.memory = rhi::BufferMemType::Upload;
+    rhi::create_buffer(device, ib_desc, index_buffer);
+    std::memcpy(index_buffer.mapped, QUAD_INDICES, sizeof(QUAD_INDICES));
+
+    rhi::RenderPipelineDesc pd{};
+    pd.device = &device;
+    pd.set_shaders(sc, "conformance/indexed_quad.slang", "vsMain", "fsMain");
+    pd.add_vertex_binding(QUAD_VERTEX_BINDING, sizeof(QuadVertex));
+    pd.add_vertex_attribute(0, QUAD_VERTEX_BINDING, rhi::ImageFormat::RG32_FLOAT, offsetof(QuadVertex, pos));
+    pd.add_vertex_attribute(1, QUAD_VERTEX_BINDING, rhi::ImageFormat::RGB32_FLOAT, offsetof(QuadVertex, color));
+    pd.set_depth_testing(false, false, rhi::PipelineCompareOp::LESS);
+    pd.set_cull_mode(rhi::PipelineCullMode::NONE, rhi::PipelineTriangleWindingOrder::CCW);
+    pd.set_color_format(rhi::swapchain_format(swapchain));
+    pipeline = pd.build();
+
+    const auto start_time = std::chrono::steady_clock::now();
+
+    u64 frame_count = 0;
+    while (platform_update(platform)) {
+        if (platform.framebuffer_resized || rhi::swapchain_needs_recreate(swapchain)) {
+            platform.framebuffer_resized = false;
+            if (!platform_wait_for_valid_framebuffer(platform)) {
+                break;
+            }
+            rhi::queue_wait_idle(device);
+            rhi::destroy_swapchain(device, swapchain);
+            swapchain_desc.width = platform.width;
+            swapchain_desc.height = platform.height;
+            rhi::create_swapchain(device, swapchain_desc, swapchain);
+            continue;
+        }
+
+        const f32 time = std::chrono::duration<f32>(std::chrono::steady_clock::now() - start_time).count();
+        QuadPush push{};
+        push.time = time;
+        push.offset[0] = 0.25f * std::sin(time * 0.7f);
+        push.offset[1] = 0.25f * std::cos(time * 0.9f);
+        const f32 pulse = 0.75f + 0.25f * std::sin(time * 2.0f);
+        push.tint[0] = pulse;
+        push.tint[1] = pulse;
+        push.tint[2] = pulse;
+        push.tint[3] = 1.0f;
+
+        rhi::reset_cmd_buffer(cmd);
+        rhi::begin_cmd_buffer(cmd, rhi::CmdBufferBeginDesc{.usage = rhi::CmdBufferUsage::OneTimeSubmit});
+
+        u32 image_index = 0;
+        if (!rhi::acquire_swapchain_image(device, swapchain, image_index, cmd)) {
+            rhi::reset_cmd_buffer(cmd);
+            continue;
+        }
+
+        rhi::Image *swap_image = rhi::swapchain_image(swapchain, image_index);
+        rhi::Extent2D extent = rhi::swapchain_extent(swapchain);
+        rhi::ImageView swap_view = rhi::get_cached_image_view(device, *swap_image, {.aspect = rhi::ImageAspect::Color});
+
+        rhi::AttachmentDesc color_att{};
+        color_att.img = &swap_view;
+        color_att.loadOp = rhi::LoadOp::CLEAR;
+        color_att.storeOp = rhi::StoreOp::STORE;
+        color_att.clearValue.color.float32[0] = 0.1f;
+        color_att.clearValue.color.float32[1] = 0.1f;
+        color_att.clearValue.color.float32[2] = 0.1f;
+        color_att.clearValue.color.float32[3] = 1.0f;
+
+        rhi::RenderingInfo ri{};
+        ri.colorAttachments[0] = color_att;
+        ri.colorAttachmentCount = 1;
+        ri.width = extent.width;
+        ri.height = extent.height;
+
+        rhi::begin_rendering(cmd, ri);
+        rhi::set_pipeline(cmd, pipeline);
+
+        rhi::Viewport vp{};
+        vp.width = (f32)extent.width;
+        vp.height = (f32)extent.height;
+        rhi::set_viewports(cmd, &vp);
+
+        rhi::Rect scissor{};
+        scissor.width = (i16)extent.width;
+        scissor.height = (i16)extent.height;
+        rhi::set_scissors(cmd, &scissor);
+
+        rhi::set_vertex_buffer(cmd, vertex_buffer, QUAD_VERTEX_BINDING, 0);
+        rhi::set_index_buffer(cmd, index_buffer, 0, rhi::IndexType::UINT32);
+        rhi::set_constants(cmd, pipeline, rhi::ShaderStage::VERTEX | rhi::ShaderStage::FRAGMENT, sizeof(push), &push);
+        rhi::draw_indexed(cmd, 6, 1, 0, 0, 0);
+        rhi::end_rendering(cmd);
+
+        rhi::ImageRange range{};
+        rhi::barrier(cmd, *swap_image, range, swap_image->state, rhi::ResourceState::Display);
+        rhi::end_cmd_buffer(cmd);
+
+        rhi::QueueSignal completion{{frame_sync, frame_count + 1}};
+        rhi::QueueSubmitDesc submit{};
+        submit.cmd_count = 1;
+        submit.cmds = &cmd;
+        submit.signal_count = 1;
+        submit.signals = &completion;
+        rhi::queue_submit(device, graphics_queue, submit);
+
+        rhi::present_swapchain(device, swapchain, image_index, {frame_sync, frame_count + 1});
+        ++frame_count;
+
+        rhi::sync_host_wait(frame_sync, frame_count);
+    }
+
+    rhi::device_wait_idle(device);
+
+    rhi::destroy_pipeline(device, pipeline);
+    rhi::destroy_buffer(device, index_buffer);
+    rhi::destroy_buffer(device, vertex_buffer);
+    rhi::sync_destroy(frame_sync);
+    rhi::destroy_cmd_buffer(device, pool, cmd);
+    rhi::destroy_cmd_pool(device, pool);
+    rhi::destroy_swapchain(device, swapchain);
+    rhi::destroy_memory_allocator(device);
+    destroy_window(device, platform);
+    rhi::destroy_context(device);
+
+    vel::Logger::shutdown();
+    return 0;
+}