Fix SDL compile failure when an image atomic's result is used (#2218 )

Ignore additional tags when deriving the mod version (#2219 )
Harden SDL-GPU buffer mapping lifetime (#2217 )
2026-11-15 01:34:48 +00:00 · 2026-10-04 18:56:12 -07:00 · 2026-10-04 18:33:06 -07:00 · 2026-10-04 16:31:48 -07:00 · 2026-10-04 15:36:50 -07:00 · 2026-10-04 15:22:09 -07:00
216 changed files with 8373 additions and 3095 deletions
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# usage: companion-version.sh <name> <catalog-key>; TAG is <name>-v<version>[-N] or unset
+set -euo pipefail
+
+name="${1:?name required}"
+key="${2:?catalog key required}"
+
+cd "$(dirname "${BASH_SOURCE[0]}")/../.."
+base="$(sed -nE "s/^$key = \"(.*)\"\$/\\1/p" gradle/libs.versions.toml)"
+[[ -n "$base" ]] || { echo "$key not found" >&2; exit 1; }
+
+tag="${TAG:-}"
+if [[ -z "$tag" ]]; then
+    echo "$base"
+    exit 0
+fi
+
+version="${tag#"$name"-v}"
+if [[ "$version" == "$tag" || ( "$version" != "$base" && ! "$version" =~ ^"$base"-[1-9][0-9]*$ ) ]]; then
+    echo "bad tag '$tag': want $name-v$base[-N]" >&2
+    exit 1
+fi
+echo "$version"
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# usage: release-companion-jar.sh <jar> <notes>; TAG is <name>-v<version>
+set -euo pipefail
+
+: "${TAG:?TAG required}"
+jar="${1:?jar required}"
+notes="${2:?notes required}"
+
+gh release create "$TAG" "$jar" --latest=false --title "angelica-${TAG%%-v*} ${TAG#*-v}" --notes "$notes"
@@ -0,0 +1,53 @@
+name: Build angelica-moltenvk
+
+on:
+  push:
+    tags:
+      - "moltenvk-v*"
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish angelica-moltenvk.jar to the GTNH maven
+        type: boolean
+        required: false
+        default: false
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v4
+      - name: Compute version
+        shell: bash
+        env:
+          TAG: ${{ github.ref_type == 'tag' && github.ref_name || '' }}
+        run: |
+          version="$(bash .github/scripts/companion-version.sh moltenvk lwjgl3Release)"
+          echo "MOLTENVK_VERSION=$version" >> "$GITHUB_ENV"
+      - name: Build angelica-moltenvk.jar
+        run: ./gradlew -PmoltenvkVersion="$MOLTENVK_VERSION" :moltenvk:distJar
+      - uses: actions/upload-artifact@v4
+        with:
+          name: angelica-moltenvk
+          path: moltenvk/build/libs/angelica-moltenvk-*.jar
+          if-no-files-found: error
+      - name: Publish to GTNH maven
+        if: github.ref_type == 'tag' || inputs.publish
+        env:
+          MAVEN_USER: ${{ secrets.MAVEN_USER }}
+          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+        run: ./gradlew -PpublishMoltenVK=true -PmoltenvkVersion="$MOLTENVK_VERSION" :moltenvk:publish
+      - name: Create GitHub release
+        if: github.ref_type == 'tag'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+        run: bash .github/scripts/release-companion-jar.sh moltenvk/build/libs/angelica-moltenvk-*.jar "MoltenVK for the SDL GPU Vulkan driver on macOS."
@@ -12,6 +12,9 @@ on:
        required: false
        default: false

+permissions:
+  contents: write
+
 jobs:
  build:
    strategy:
@@ -66,8 +69,15 @@ jobs:
            cp "$d"/* "$dest/"
          done
          find tracy-client/src/main/resources/natives -type f
+      - name: Compute version
+        shell: bash
+        env:
+          TAG: ${{ github.ref_type == 'tag' && github.ref_name || '' }}
+        run: |
+          version="$(bash .github/scripts/companion-version.sh tracy tracy)"
+          echo "TRACY_JAR_VERSION=$version" >> "$GITHUB_ENV"
      - name: Build angelica-tracy.jar
-        run: ./gradlew :tracy-client:distJar
+        run: ./gradlew -PtracyJarVersion="$TRACY_JAR_VERSION" :tracy-client:distJar
      - uses: actions/upload-artifact@v4
        with:
          name: angelica-tracy
@@ -78,4 +88,10 @@ jobs:
        env:
          MAVEN_USER: ${{ secrets.MAVEN_USER }}
          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
-        run: ./gradlew -PpublishTracy=true :tracy-client:publish
+        run: ./gradlew -PpublishTracy=true -PtracyJarVersion="$TRACY_JAR_VERSION" :tracy-client:publish
+      - name: Create GitHub release
+        if: github.ref_type == 'tag'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+        run: bash .github/scripts/release-companion-jar.sh tracy-client/build/libs/angelica-tracy-*.jar "Tracy profiler backend for Angelica."
@@ -3,7 +3,7 @@ name: Release tagged build

 on:
  push:
-    tags: [ '*', '!tracy-v*' ]
+    tags: [ '*', '!tracy-v*', '!moltenvk-v*' ]

 permissions:
  contents: write
@@ -6,6 +6,8 @@ plugins {
    id("com.gtnewhorizons.gtnhconvention")
 }

+apply(from = "gradle/mod-version.gradle.kts")
+
 val lwjglDebug = false
 val gpuHud = false
 val renderdoc = false
@@ -93,6 +93,9 @@ DependencyHandlerScope.of(dependencies).apply {
    shadowImplementation(project(":lwjgl3-backend")) { isTransitive = false }
    shadowImplementation(project(":sdl-gpu")) { isTransitive = false }
    runtimeOnlyNonPublishable(project(":tracy-client")) { isTransitive = false }
+    if (System.getProperty("os.name").lowercase().contains("mac")) {
+        runtimeOnlyNonPublishable(project(":moltenvk")) { isTransitive = false }
+    }
    devOnlyNonPublishable(libs.async.profiler)
    shadowImplementation(libs.eventbus)

@@ -17,7 +17,7 @@ public final class SystemProperties {

    // Backend selection
    public static final String KEY_USE_SDL_GPU = "angelica.sdlgpu.enable";
-    public static final boolean USE_SDL_GPU = Boolean.getBoolean(KEY_USE_SDL_GPU);
+    public static final Boolean SDL_GPU_OVERRIDE = parseBooleanOverride(KEY_USE_SDL_GPU);
    public static final String GL_PROFILE = System.getProperty("angelica.glProfile", "");
    public static final boolean DISABLE_NVIDIA_WORKAROUND = Boolean.getBoolean("angelica.disableNvidiaWorkaround");
    public static final boolean DISABLE_LTW_WORKAROUND = Boolean.getBoolean("angelica.disableLtwWorkaround");
@@ -28,7 +28,8 @@ public final class SystemProperties {

    // SDL-GPU
    public static final String KEY_SDL_GPU_DRIVER = "angelica.sdlgpu.driver";
-    public static final String SDL_GPU_DRIVER = System.getProperty(KEY_SDL_GPU_DRIVER, "");
+    public static final String SDL_GPU_DRIVER_OVERRIDE = parseStringOverride(KEY_SDL_GPU_DRIVER);
+    public static final String MOLTENVK_DIR = System.getProperty("angelica.moltenvk.dir", "angelica" + File.separator + "natives" + File.separator + "moltenvk");
    public static final boolean SDL_GPU_DEBUG = Boolean.getBoolean("angelica.sdlgpu.debug");
    private static final SdlAssertionMode ENCODER_ASSERTIONS = parseEnum("angelica.sdlgpu.encoderAssertions", SdlAssertionMode.OFF, SdlAssertionMode.WARN, SdlAssertionMode.class);
    public static final boolean SDL_ENCODER_ASSERTIONS = ENCODER_ASSERTIONS != SdlAssertionMode.OFF;
@@ -63,6 +64,7 @@ public final class SystemProperties {
    public static final String FLYBY_ORIGIN = System.getProperty("angelica.flyby.origin", "");
    public static final FlybyPacing FLYBY_PACING = parseEnum("angelica.flyby.pacing", FlybyPacing.UNCAPPED, FlybyPacing.UNCAPPED, FlybyPacing.class);
    public static final FlybyWeather FLYBY_WEATHER = parseEnum("angelica.flyby.weather", FlybyWeather.CLEAR, FlybyWeather.CLEAR, FlybyWeather.class);
+    public static final FlybyCamera FLYBY_CAMERA = parseEnum("angelica.flyby.camera", FlybyCamera.FIRST_PERSON, FlybyCamera.FIRST_PERSON, FlybyCamera.class);
    public static final boolean FLYBY_JFR = Boolean.getBoolean("angelica.flyby.jfr");
    public static final float FLYBY_PITCH = parseFloat("angelica.flyby.pitch");
    public static final int FLYBY_SCREENSHOTS = Integer.getInteger("angelica.flyby.screenshots", 0);
@@ -131,6 +133,12 @@ public final class SystemProperties {
        CONFIGURED
    }

+    public enum FlybyCamera {
+        FIRST_PERSON,
+        THIRD_PERSON_BACK,
+        THIRD_PERSON_FRONT
+    }
+
    public enum FlybyWeather {
        CLEAR,
        RAIN,
@@ -158,7 +166,12 @@ public final class SystemProperties {

    private static Boolean parseBooleanOverride(String key) {
        final String raw = System.getProperty(key);
-        return raw == null ? null : Boolean.parseBoolean(raw);
+        return raw == null || raw.isEmpty() ? null : Boolean.parseBoolean(raw);
+    }
+
+    private static String parseStringOverride(String key) {
+        final String raw = System.getProperty(key);
+        return raw == null || raw.isEmpty() ? null : raw;
    }

    private static double parseDouble(String key) {
@@ -21,6 +21,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.MaterialStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
+import com.gtnewhorizons.angelica.glsm.stacks.RetainedState;
 import com.gtnewhorizons.angelica.glsm.stacks.ScissorStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.StackIdAllocator;
 import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
@@ -29,7 +30,7 @@ import com.gtnewhorizons.angelica.glsm.states.AlphaState;
 import com.gtnewhorizons.angelica.glsm.states.BlendState;
 import com.gtnewhorizons.angelica.glsm.states.ClipPlaneState;
 import com.gtnewhorizons.angelica.glsm.states.Color4;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import com.gtnewhorizons.angelica.glsm.states.ImageUnitArray;
 import com.gtnewhorizons.angelica.glsm.states.SamplerUnitArray;
 import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray;
@@ -106,6 +107,7 @@ public class GLContextState {
    public int maxBoundTextureUnit = 0;
    public int maxBoundImageUnit = 0;
    public final StateSet[] attribSets = new StateSet[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
+    public RetainedState retainedOwner;
    public int attribDepth = 0;

    public boolean savesState(int id) {
@@ -229,9 +231,16 @@ public class GLContextState {
    public int boundCopyReadBuffer;
    public int boundCopyWriteBuffer;
    public final Int2IntMap boundOtherBuffers = new Int2IntOpenHashMap();
-    public PixelUnpackState pixelUnpackState = PixelUnpackState.DEFAULT;
+    public PixelStoreState pixelUnpackState = PixelStoreState.DEFAULT;
+    public PixelStoreState pixelPackState = PixelStoreState.DEFAULT;
+    public final int[] clientAttribSavedMask = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final PixelStoreState[] clientAttribSavedPixelUnpack = new PixelStoreState[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final PixelStoreState[] clientAttribSavedPixelPack = new PixelStoreState[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final int[] clientAttribSavedUnpackBuffer = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final int[] clientAttribSavedPackBuffer = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
    public final int[] clientAttribSavedTextureUnit = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
    public final int[] clientAttribSavedVertexFlags = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final boolean[] clientAttribSavedVertexArray = new boolean[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
    public int clientAttribStackPointer = 0;
    public int restoreChangedMask;
    public long restoreUnitChangedMask;
@@ -31,6 +31,7 @@ import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
 import com.gtnewhorizons.angelica.glsm.recording.commands.IndexedDrawCapture;
 import com.gtnewhorizons.angelica.glsm.recording.commands.TexImage2DCmd;
 import com.gtnewhorizons.angelica.glsm.recording.commands.TexSubImage2DCmd;
+import com.gtnewhorizons.angelica.glsm.shader.ProgramBinaryCache;
 import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.BlendStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
@@ -49,6 +50,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.MaterialStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
+import com.gtnewhorizons.angelica.glsm.stacks.RetainedState;
 import com.gtnewhorizons.angelica.glsm.stacks.ScissorStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.StackIdAllocator;
 import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
@@ -59,7 +61,7 @@ import com.gtnewhorizons.angelica.glsm.states.BlendState;
 import com.gtnewhorizons.angelica.glsm.states.ClipPlaneState;
 import com.gtnewhorizons.angelica.glsm.states.Color4;
 import com.gtnewhorizons.angelica.glsm.states.ColorMask;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import com.gtnewhorizons.angelica.glsm.states.PolygonState;
 import com.gtnewhorizons.angelica.glsm.states.SamplerUnitArray;
 import com.gtnewhorizons.angelica.glsm.states.ImageUnitBinding;
@@ -307,17 +309,25 @@ public class GLStateManager {
        return Thread.currentThread() == MainThread;
    }

+    public static void requireContext(String call) {
+        if (Thread.currentThread() == MainThread || RENDER_BACKEND.hasContextOnThread()) return;
+        throw new IllegalStateException(call + " on thread " + Thread.currentThread().getName() + ", which has no GL context");
+    }
+
    @Getter private static GLSMInitConfig initConfig;

    public static ContextCapabilities capabilities;

    // Software stack depths for FFP emulation
    public static final int MAX_ATTRIB_STACK_DEPTH = 32;
+    public static final int RETAINED_SLOT = MAX_ATTRIB_STACK_DEPTH;
+    public static final int STATE_SLOTS = MAX_ATTRIB_STACK_DEPTH + 1;
    public static final int MAX_MODELVIEW_STACK_DEPTH = 32 + 2;
    public static final int MAX_PROJECTION_STACK_DEPTH = 4;
    public static final int MAX_TEXTURE_STACK_DEPTH = 4;
    public static final int MAX_CLIP_PLANES = 8;
    public static final int MAX_TEXTURE_UNITS = RENDER_BACKEND.getInteger(GL20.GL_MAX_TEXTURE_IMAGE_UNITS);
+    public static final int MAX_LEGACY_TEXTURE_UNITS = Math.min(VertexKey.MAX_UNITS, MAX_TEXTURE_UNITS);

    public static final GLFeatureSet HAS_MULTIPLE_SET = new GLFeatureSet();

@@ -542,6 +552,7 @@ public class GLStateManager {
        final GLContextState glCtx = ctx();
        DisplayListManager.abortCompilation();
        glCtx.attribDepth = 0;
+        glCtx.retainedOwner = null;
        for (int i = 0; i < glCtx.attribSets.length; i++) {
            glCtx.attribSets[i] = null;
        }
@@ -1182,11 +1193,35 @@ public class GLStateManager {
                case GL11.GL_LINE_STIPPLE_PATTERN -> glCtx.lineState.getStipplePattern() & 0xFFFF;
                case GL11.GL_LINE_STIPPLE_REPEAT -> glCtx.lineState.getStippleFactor();
                case GL11.GL_LIST_INDEX -> DisplayListManager.isRecording() ? Math.max(DisplayListManager.getRecordingListId(), 0) : 0;
+                case GL11.GL_ATTRIB_STACK_DEPTH -> glCtx.attribDepth;
+                case GL11.GL_CLIENT_ATTRIB_STACK_DEPTH -> glCtx.clientAttribStackPointer;
+                case GL11.GL_TEXTURE_STACK_DEPTH -> getMatrixStackDepth(glCtx.textures.getTextureUnitMatrix(glCtx.activeTextureUnit.getValue()));
+                case GL11.GL_MAX_ATTRIB_STACK_DEPTH -> MAX_ATTRIB_STACK_DEPTH;
+                case GL11.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH -> CLIENT_ATTRIB_STACK_DEPTH;
+                case GL11.GL_MAX_MODELVIEW_STACK_DEPTH -> MAX_MODELVIEW_STACK_DEPTH;
+                case GL11.GL_MAX_PROJECTION_STACK_DEPTH -> MAX_PROJECTION_STACK_DEPTH;
+                case GL11.GL_MAX_TEXTURE_STACK_DEPTH -> MAX_TEXTURE_STACK_DEPTH;
+                case GL13.GL_MAX_TEXTURE_UNITS -> MAX_LEGACY_TEXTURE_UNITS;
+                case GL11.GL_MAX_LIGHTS -> glCtx.lightStates.length;
+                case GL11.GL_STENCIL_BITS -> drawFramebufferBits(glCtx, true);
+                case GL11.GL_DEPTH_BITS -> drawFramebufferBits(glCtx, false);
                default -> RENDER_BACKEND.getInteger(pname);
            };
        };
    }

+    private static int drawFramebufferBits(GLContextState glCtx, boolean stencil) {
+        final int sizePname = stencil ? GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE : GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE;
+        if (glCtx.drawFramebuffer == 0) {
+            return RENDER_BACKEND.getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, stencil ? GL11.GL_STENCIL : GL11.GL_DEPTH, sizePname);
+        }
+        final int attachment = stencil ? GL30.GL_STENCIL_ATTACHMENT : GL30.GL_DEPTH_ATTACHMENT;
+        if (RENDER_BACKEND.getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, attachment, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) == GL11.GL_NONE) {
+            return 0;
+        }
+        return RENDER_BACKEND.getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, attachment, sizePname);
+    }
+
    public static void glGetInteger(int pname, IntBuffer params) {
        if (!isCachingEnabled()) {
            RENDER_BACKEND.getInteger(pname, params);
@@ -1235,6 +1270,48 @@ public class GLStateManager {
        }
    }

+    private static void putLightingInts(FloatBuffer values, int pname, boolean material, IntBuffer params) {
+        final int count = switch (pname) {
+            case GL11.GL_AMBIENT, GL11.GL_DIFFUSE, GL11.GL_SPECULAR -> 4;
+            case GL11.GL_EMISSION -> material ? 4 : 0;
+            case GL11.GL_COLOR_INDEXES -> material ? 3 : 0;
+            case GL11.GL_SHININESS -> material ? 1 : 0;
+            case GL11.GL_POSITION -> material ? 0 : 4;
+            case GL11.GL_SPOT_DIRECTION -> material ? 0 : 3;
+            case GL11.GL_SPOT_EXPONENT, GL11.GL_SPOT_CUTOFF, GL11.GL_CONSTANT_ATTENUATION, GL11.GL_LINEAR_ATTENUATION,
+                 GL11.GL_QUADRATIC_ATTENUATION -> material ? 0 : 1;
+            default -> 0;
+        };
+        final boolean color = count == 4 && pname != GL11.GL_POSITION;
+        final int pos = params.position();
+        for (int i = 0; i < count; i++) {
+            final float value = values.get(i);
+            final int converted;
+            if (color) {
+                converted = (int) (2147483647.0 * value);
+            } else if (material) {
+                converted = value < 0 ? -Math.round(-value) : Math.round(value);
+            } else {
+                converted = (int) value;
+            }
+            params.put(pos + i, converted);
+        }
+    }
+
+    public static void glGetMaterial(int face, int pname, IntBuffer params) {
+        final FloatBuffer scratch = ctx().queryScratch;
+        scratch.clear();
+        glGetMaterial(face, pname, scratch);
+        putLightingInts(scratch, pname, true, params);
+    }
+
+    public static void glGetLight(int light, int pname, IntBuffer params) {
+        final FloatBuffer scratch = ctx().queryScratch;
+        scratch.clear();
+        glGetLight(light, pname, scratch);
+        putLightingInts(scratch, pname, false, params);
+    }
+
    public static void glGetLight(int light, int pname, FloatBuffer params) {
        final LightStateStack state = ctx().lightDataStates[light - GL11.GL_LIGHT0];
        switch (pname) {
@@ -1287,12 +1364,25 @@ public class GLStateManager {
                params.put(pos + 2, normal.z);
            }
            case GL11.GL_CURRENT_TEXTURE_COORDS -> {
-                final Vector4f tc = glCtx.ffp.currentTexCoords[0];
+                final int unit = glCtx.activeTextureUnit.getValue();
                final int pos = params.position();
-                params.put(pos, tc.x);
-                params.put(pos + 1, tc.y);
-                params.put(pos + 2, tc.z);
-                params.put(pos + 3, tc.w);
+                if (unit == 1) {
+                    params.put(pos, glCtx.lastBrightnessX);
+                    params.put(pos + 1, glCtx.lastBrightnessY);
+                    params.put(pos + 2, 0.0f);
+                    params.put(pos + 3, 1.0f);
+                } else if (unit >= 0 && unit < glCtx.ffp.currentTexCoords.length) {
+                    final Vector4f tc = glCtx.ffp.currentTexCoords[unit];
+                    params.put(pos, tc.x);
+                    params.put(pos + 1, tc.y);
+                    params.put(pos + 2, tc.z);
+                    params.put(pos + 3, tc.w);
+                } else {
+                    params.put(pos, 0.0f);
+                    params.put(pos + 1, 0.0f);
+                    params.put(pos + 2, 0.0f);
+                    params.put(pos + 3, 1.0f);
+                }
            }
            case GL11.GL_FOG_COLOR -> {
                final FloatBuffer fogBuf = glCtx.fogState.getFogColorBuffer();
@@ -1604,58 +1694,25 @@ public class GLStateManager {
    }

    public static void glBlendFunc(int srcFactor, int dstFactor) {
-        final GLContextState glCtx = ctx();
-        final RecordMode mode = DisplayListManager.getRecordMode();
-        if (mode != RecordMode.NONE) {
-            DisplayListManager.recordBlendFunc(srcFactor, dstFactor, srcFactor, dstFactor);
-            if (mode == RecordMode.COMPILE) {
-                return;
-            }
-        }
-        final boolean snapshotted = snapshotVanillaBlendFunc();
-        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
-        if (bh != null && bh.isBlendLocked()) {
-            mod(glCtx.blendState);
-            bh.deferBlendFunc(srcFactor, dstFactor, srcFactor, dstFactor);
-            postVanillaBlendChangeIfMoved(snapshotted);
-            return;
-        }
-        final boolean caching = isCachingEnabled();
+        tryBlendFuncSeparate(srcFactor, dstFactor, srcFactor, dstFactor);
+    }
+
+    private static void issueBlendFunc(BlendStateStack blend) {
        if (GLSMConfig.hudCacheOverride) {
-            mod(glCtx.blendState);
-            glCtx.blendState.setAll(srcFactor, dstFactor, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
-            glCtx.blendState.clearFuncUnknownState();
-            RENDER_BACKEND.blendFuncSeparate(srcFactor, dstFactor, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
-            if (GLSMHooks.BLEND_FUNC_CHANGE.hasListeners()) {
-                GLSMHooks.blendFuncChangeEvent.srcRgb = srcFactor;
-                GLSMHooks.blendFuncChangeEvent.dstRgb = dstFactor;
-                GLSMHooks.blendFuncChangeEvent.srcAlpha = GL11.GL_ONE;
-                GLSMHooks.blendFuncChangeEvent.dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
-                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
-            }
-            postVanillaBlendChangeIfMoved(snapshotted);
-            return;
+            RENDER_BACKEND.blendFuncSeparate(blend.getSrcRgb(), blend.getDstRgb(), GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        } else {
+            RENDER_BACKEND.blendFuncSeparate(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha());
        }
-        final boolean bypass = !caching;
-        if (bypass
-                || glCtx.blendState.getSrcRgb() != srcFactor
-                || glCtx.blendState.getDstRgb() != dstFactor
-                || glCtx.blendState.getSrcAlpha() != srcFactor
-                || glCtx.blendState.getDstAlpha() != dstFactor
-                || glCtx.blendState.isFuncUnknown()) {
-            mod(glCtx.blendState);
-            glCtx.blendState.setAll(srcFactor, dstFactor, srcFactor, dstFactor);
-            glCtx.blendState.clearFuncUnknownState();
-            RENDER_BACKEND.blendFunc(srcFactor, dstFactor);
-            if (GLSMHooks.BLEND_FUNC_CHANGE.hasListeners()) {
-                GLSMHooks.blendFuncChangeEvent.srcRgb = srcFactor;
-                GLSMHooks.blendFuncChangeEvent.dstRgb = dstFactor;
-                GLSMHooks.blendFuncChangeEvent.srcAlpha = srcFactor;
-                GLSMHooks.blendFuncChangeEvent.dstAlpha = dstFactor;
-                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
-            }
-        }
-        postVanillaBlendChangeIfMoved(snapshotted);
+    }
+
+    public static void setHudCacheOverride(boolean enabled) {
+        if (GLSMConfig.hudCacheOverride == enabled) return;
+        GLSMConfig.hudCacheOverride = enabled;
+        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
+        if (bh != null && bh.isOverrideHeld()) return;
+        final BlendStateStack blend = ctx().blendState;
+        issueBlendFunc(blend);
+        blend.clearFuncUnknownState();
    }

    public static void glBlendEquation(int mode) {
@@ -1707,22 +1764,19 @@ public class GLStateManager {
            postVanillaBlendChangeIfMoved(snapshotted);
            return;
        }
-        if (GLSMConfig.hudCacheOverride && dstAlpha != GL11.GL_ONE_MINUS_SRC_ALPHA) {
-            srcAlpha = GL11.GL_ONE;
-            dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
-        }
        final boolean caching = isCachingEnabled();
        final boolean bypass = !caching;
        if (bypass || glCtx.blendState.getSrcRgb() != srcRgb || glCtx.blendState.getDstRgb() != dstRgb || glCtx.blendState.getSrcAlpha() != srcAlpha || glCtx.blendState.getDstAlpha() != dstAlpha || glCtx.blendState.isFuncUnknown()) {
            mod(glCtx.blendState);
            glCtx.blendState.setAll(srcRgb, dstRgb, srcAlpha, dstAlpha);
            glCtx.blendState.clearFuncUnknownState();
-            RENDER_BACKEND.blendFuncSeparate(srcRgb, dstRgb, srcAlpha, dstAlpha);
+            issueBlendFunc(glCtx.blendState);
            if (GLSMHooks.BLEND_FUNC_CHANGE.hasListeners()) {
+                final boolean hudCache = GLSMConfig.hudCacheOverride;
                GLSMHooks.blendFuncChangeEvent.srcRgb = srcRgb;
                GLSMHooks.blendFuncChangeEvent.dstRgb = dstRgb;
-                GLSMHooks.blendFuncChangeEvent.srcAlpha = srcAlpha;
-                GLSMHooks.blendFuncChangeEvent.dstAlpha = dstAlpha;
+                GLSMHooks.blendFuncChangeEvent.srcAlpha = hudCache ? GL11.GL_ONE : srcAlpha;
+                GLSMHooks.blendFuncChangeEvent.dstAlpha = hudCache ? GL11.GL_ONE_MINUS_SRC_ALPHA : dstAlpha;
                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
            }
        }
@@ -2557,11 +2611,13 @@ public class GLStateManager {
    }

    public static int glGenTextures() {
+        requireContext("glGenTextures");
        flushDeferredTextureDeletes();
        return RENDER_BACKEND.genTextures();
    }

    public static void glGenTextures(IntBuffer textures) {
+        requireContext("glGenTextures");
        flushDeferredTextureDeletes();
        RENDER_BACKEND.genTextures(textures);
    }
@@ -3282,22 +3338,63 @@ public class GLStateManager {
        };
    }

+    private static boolean isPositionArrayEnabled(GLContextState glCtx) {
+        final VAOManager.Attrib position = glCtx.vaos.attrib(Usage.POSITION.getAttributeLocation());
+        return position != null && position.enabled;
+    }
+
    static final int CLIENT_ATTRIB_STACK_DEPTH = 16;
    public static void glPushClientAttrib(int mask) {
        final GLContextState glCtx = ctx();
-        if (glCtx.clientAttribStackPointer < CLIENT_ATTRIB_STACK_DEPTH) {
-            glCtx.clientAttribSavedTextureUnit[glCtx.clientAttribStackPointer] = glCtx.clientActiveTextureUnit;
-            glCtx.clientAttribSavedVertexFlags[glCtx.clientAttribStackPointer] = glCtx.vaos.getVertexFlags();
-            glCtx.clientAttribStackPointer++;
+        final int sp = glCtx.clientAttribStackPointer;
+        if (sp < CLIENT_ATTRIB_STACK_DEPTH) {
+            glCtx.clientAttribSavedMask[sp] = mask;
+            if ((mask & GL11.GL_CLIENT_PIXEL_STORE_BIT) != 0) {
+                glCtx.clientAttribSavedPixelPack[sp] = glCtx.pixelPackState;
+                glCtx.clientAttribSavedPixelUnpack[sp] = glCtx.pixelUnpackState;
+                glCtx.clientAttribSavedPackBuffer[sp] = glCtx.boundPixelPackBuffer;
+                glCtx.clientAttribSavedUnpackBuffer[sp] = glCtx.boundPixelUnpackBuffer;
+            }
+            if ((mask & GL11.GL_CLIENT_VERTEX_ARRAY_BIT) != 0) {
+                glCtx.clientAttribSavedTextureUnit[sp] = glCtx.clientActiveTextureUnit;
+                glCtx.clientAttribSavedVertexFlags[sp] = glCtx.vaos.getVertexFlags();
+                glCtx.clientAttribSavedVertexArray[sp] = isPositionArrayEnabled(glCtx);
+            }
+            glCtx.clientAttribStackPointer = sp + 1;
        }
    }

    public static void glPopClientAttrib() {
        final GLContextState glCtx = ctx();
        if (glCtx.clientAttribStackPointer > 0) {
-            glCtx.clientAttribStackPointer--;
-            glCtx.clientActiveTextureUnit = glCtx.clientAttribSavedTextureUnit[glCtx.clientAttribStackPointer];
-            glCtx.vaos.setVertexFlags(glCtx.clientAttribSavedVertexFlags[glCtx.clientAttribStackPointer]);
+            final int sp = --glCtx.clientAttribStackPointer;
+            final int mask = glCtx.clientAttribSavedMask[sp];
+            if ((mask & GL11.GL_CLIENT_PIXEL_STORE_BIT) != 0) {
+                final PixelStoreState pack = glCtx.clientAttribSavedPixelPack[sp];
+                final PixelStoreState unpack = glCtx.clientAttribSavedPixelUnpack[sp];
+                glCtx.clientAttribSavedPixelPack[sp] = null;
+                glCtx.clientAttribSavedPixelUnpack[sp] = null;
+                PixelStoreState.applyDiff(glCtx.pixelPackState, pack, true);
+                glCtx.pixelPackState = pack;
+                PixelStoreState.applyDiff(glCtx.pixelUnpackState, unpack, false);
+                glCtx.pixelUnpackState = unpack;
+                final int packBuffer = glCtx.clientAttribSavedPackBuffer[sp];
+                if (glCtx.boundPixelPackBuffer != packBuffer) glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, packBuffer);
+                final int unpackBuffer = glCtx.clientAttribSavedUnpackBuffer[sp];
+                if (glCtx.boundPixelUnpackBuffer != unpackBuffer) glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, unpackBuffer);
+            }
+            if ((mask & GL11.GL_CLIENT_VERTEX_ARRAY_BIT) != 0) {
+                glCtx.clientActiveTextureUnit = glCtx.clientAttribSavedTextureUnit[sp];
+                glCtx.vaos.setVertexFlags(glCtx.clientAttribSavedVertexFlags[sp]);
+                final boolean vertexArray = glCtx.clientAttribSavedVertexArray[sp];
+                if (isPositionArrayEnabled(glCtx) != vertexArray) {
+                    if (vertexArray) {
+                        glEnableClientState(GL11.GL_VERTEX_ARRAY);
+                    } else {
+                        glDisableClientState(GL11.GL_VERTEX_ARRAY);
+                    }
+                }
+            }
        }
    }

@@ -4177,6 +4274,89 @@ public class GLStateManager {
        }
    }

+    public static void retainModifiedState(int depth, RetainedState out) {
+        final GLContextState glCtx = ctx();
+        if (depth < 0 || depth != glCtx.attribDepth - 1) {
+            throw new IllegalStateException("retainModifiedState: depth " + depth + " is not the open push (attrib depth " + glCtx.attribDepth + ")");
+        }
+        glCtx.retainedOwner = out;
+        final int count = glCtx.modifiedCount[depth];
+        final int[] ids = glCtx.modifiedIds[depth];
+        final CowStateStack<?>[] stackById = glCtx.stackById;
+        out.ensureCapacity(count);
+        for (int i = 0; i < count; i++) {
+            final int id = ids[i];
+            stackById[id].captureSlot(RETAINED_SLOT);
+            out.ids[i] = id;
+        }
+        out.count = count;
+        out.program = glCtx.activeProgram;
+        out.programGen = programLifetimeGeneration;
+    }
+
+    public static void applyRetainedState(RetainedState in) {
+        final GLContextState glCtx = ctx();
+        if (glCtx.retainedOwner != in) return;
+        final CowStateStack<?>[] stackById = glCtx.stackById;
+        final byte[] kindById = glCtx.kindById;
+        final int[] ids = in.ids;
+        final int count = in.count;
+        int first = 0;
+        while (first < count && !CowDispatch.slotChanged(kindById[ids[first]], stackById[ids[first]], RETAINED_SLOT)) first++;
+        if (first < count) applyRetainedChanges(glCtx, in, first);
+        if (in.program != glCtx.activeProgram && (in.program == 0 || in.programGen == programLifetimeGeneration)) glUseProgram(in.program);
+    }
+
+    private static void applyRetainedChanges(GLContextState glCtx, RetainedState in, int first) {
+        beforeUncapturedStateChange();
+        final boolean blendSnapshotted = snapshotVanillaBlendFunc();
+        final int alphaFuncId = glCtx.alphaState.stackId();
+        final int alphaTestId = glCtx.alphaTest.stackId();
+        boolean alphaChanged = false;
+        final boolean prevPoppingAttributes = glCtx.poppingAttributes;
+        glCtx.poppingAttributes = true;
+        try {
+            final CowStateStack<?>[] stackById = glCtx.stackById;
+            final int[] restoreBitById = glCtx.restoreBitById;
+            final int[] restoreUnitById = glCtx.restoreUnitById;
+            final byte[] kindById = glCtx.kindById;
+            int changed = 0;
+            long unitsChanged = 0L;
+            for (int i = first; i < in.count; i++) {
+                final int id = in.ids[i];
+                final CowStateStack<?> cow = stackById[id];
+                final byte kind = kindById[id];
+                if (!CowDispatch.slotChanged(kind, cow, RETAINED_SLOT)) continue;
+                cow.beforeModify();
+                final int bit = restoreBitById[id];
+                if (bit != 0) {
+                    changed |= bit;
+                    final int unit = restoreUnitById[id];
+                    if (unit >= 0) unitsChanged |= 1L << Math.min(unit, 63);
+                }
+                CowDispatch.restoreSlot(kind, cow, RETAINED_SLOT);
+                if (id == alphaFuncId || id == alphaTestId) alphaChanged = true;
+            }
+            glCtx.restoreChangedMask = changed;
+            glCtx.restoreUnitChangedMask = unitsChanged;
+            issueRestoredBackendState(glCtx, -1);
+            glCtx.lightingGeneration++;
+            glCtx.fragmentGeneration++;
+            glCtx.colorGeneration++;
+            glCtx.ffp.normalGeneration++;
+            glCtx.ffp.texCoordGeneration++;
+            glCtx.dirtyColorAttrib = true;
+            glCtx.dirtyNormalAttrib = true;
+            glCtx.dirtyTexCoordAttrib = true;
+            postVanillaBlendChangeIfMoved(blendSnapshotted);
+        } finally {
+            glCtx.poppingAttributes = prevPoppingAttributes;
+        }
+        if (alphaChanged && GLSMHooks.ALPHA_STATE_CHANGE.hasListeners()) {
+            GLSMHooks.ALPHA_STATE_CHANGE.post(GLSMHooks.alphaStateChangeEvent);
+        }
+    }
+
    private static boolean isDepthColorOverridden() {
        final DeferredDepthColorHandler dch = GLSMHooks.depthColorHandler;
        return dch != null && dch.isOverrideHeld();
@@ -4195,7 +4375,7 @@ public class GLStateManager {
        RENDER_BACKEND.depthMask(glCtx.depthState.isEnabled());
        RENDER_BACKEND.clearDepth(glCtx.depthState.getClearValue());

-        RENDER_BACKEND.blendFuncSeparate(glCtx.blendState.getSrcRgb(), glCtx.blendState.getDstRgb(), glCtx.blendState.getSrcAlpha(), glCtx.blendState.getDstAlpha());
+        issueBlendFunc(glCtx.blendState);
        glCtx.blendState.clearFuncUnknownState();
        RENDER_BACKEND.blendEquationSeparate(glCtx.blendState.getEquationRgb(), glCtx.blendState.getEquationAlpha());
        RENDER_BACKEND.blendColor(glCtx.blendState.getBlendColorR(), glCtx.blendState.getBlendColorG(), glCtx.blendState.getBlendColorB(), glCtx.blendState.getBlendColorA());
@@ -4256,12 +4436,7 @@ public class GLStateManager {
        }
    }

-    /**
-     * After popping GLSM stacks, apply restored state to the GL driver.
-     */
-    private static void applyRestoredState(StateSet set, boolean blendSnapshotted) {
-        final GLContextState glCtx = ctx();
-        final int restore = set.restore;
+    private static void issueRestoredBackendState(GLContextState glCtx, int restore) {
        final int changed = glCtx.restoreChangedMask;
        if ((restore & StateSet.R_DEPTH) != 0 && (changed & StateSet.R_DEPTH) != 0) {
            attribValueRestores++;
@@ -4280,7 +4455,7 @@ public class GLStateManager {
                attribValueRestores++;
                final DeferredBlendHandler restoreBlendHandler = GLSMHooks.blendHandler;
                if (restoreBlendHandler == null || !restoreBlendHandler.isOverrideHeld()) {
-                    RENDER_BACKEND.blendFuncSeparate(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha());
+                    issueBlendFunc(blend);
                    attribBackendCalls++;
                    blend.clearFuncUnknownState();
                }
@@ -4377,6 +4552,16 @@ public class GLStateManager {
                attribBackendCalls++;
            }
        }
+    }
+
+    /**
+     * After popping GLSM stacks, apply restored state to the GL driver.
+     */
+    private static void applyRestoredState(StateSet set, boolean blendSnapshotted) {
+        final GLContextState glCtx = ctx();
+        final int restore = set.restore;
+        final int changed = glCtx.restoreChangedMask;
+        issueRestoredBackendState(glCtx, restore);

        final int bump = set.bump;
        final int depth = glCtx.attribDepth;
@@ -4466,6 +4651,10 @@ public class GLStateManager {
                return;
            }
        }
+        if (ctx().attribDepth == 0) {
+            warnOnce("popattrib-underflow", "glPopAttrib called with an empty attrib stack; ignoring");
+            return;
+        }
        GLDebug.popGroup();
        GLDebug.pushGroup("popState");
        try {
@@ -5269,13 +5458,18 @@ public class GLStateManager {
    }
    public static void glClearTexImage(int texture, int level, int format, int type, ByteBuffer data) { RENDER_BACKEND.clearTexImage(texture, level, format, type); }

-    public static int glGenSamplers() { return RENDER_BACKEND.genSamplers(); }
+    public static int glGenSamplers() {
+        requireContext("glGenSamplers");
+        return RENDER_BACKEND.genSamplers();
+    }

    public static void glGenSamplers(IntBuffer samplers) {
+        requireContext("glGenSamplers");
        for (int i = samplers.position(); i < samplers.limit(); i++) samplers.put(i, RENDER_BACKEND.genSamplers());
    }

    public static void glGenSamplers(int[] samplers) {
+        requireContext("glGenSamplers");
        for (int i = 0; i < samplers.length; i++) samplers[i] = RENDER_BACKEND.genSamplers();
    }

@@ -6342,7 +6536,11 @@ public class GLStateManager {
    public static void glPixelStorei(int pname, int param) {
        final GLContextState glCtx = ctx();
        if (isCachingEnabled()) {
-            glCtx.pixelUnpackState = glCtx.pixelUnpackState.with(pname, param);
+            if (PixelStoreState.isPack(pname)) {
+                glCtx.pixelPackState = glCtx.pixelPackState.with(pname, param);
+            } else {
+                glCtx.pixelUnpackState = glCtx.pixelUnpackState.with(pname, param);
+            }
        }
        RENDER_BACKEND.pixelStorei(pname, param);
    }
@@ -6643,12 +6841,12 @@ public class GLStateManager {
        }
    }

-    public static void forcePixelUnpackState(PixelUnpackState target) {
-        PixelUnpackState.applyDiff(ctx().pixelUnpackState, target);
+    public static void forcePixelUnpackState(PixelStoreState target) {
+        PixelStoreState.applyDiff(ctx().pixelUnpackState, target, false);
    }

-    public static void restorePixelUnpackState(PixelUnpackState applied) {
-        PixelUnpackState.applyDiff(applied, ctx().pixelUnpackState);
+    public static void restorePixelUnpackState(PixelStoreState applied) {
+        PixelStoreState.applyDiff(applied, ctx().pixelUnpackState, false);
    }

    private static boolean warnedUntrackedPixelBuffer;
@@ -6692,26 +6890,32 @@ public class GLStateManager {
    }

    public static int glGenBuffers() {
+        requireContext("glGenBuffers");
        return RENDER_BACKEND.genBuffers();
    }

    public static void glGenBuffers(IntBuffer buffers) {
+        requireContext("glGenBuffers");
        for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.genBuffers());
    }

    public static void glGenBuffers(int[] buffers) {
+        requireContext("glGenBuffers");
        for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.genBuffers();
    }

    public static int glCreateBuffers() {
+        requireContext("glCreateBuffers");
        return RENDER_BACKEND.createBuffers();
    }

    public static void glCreateBuffers(IntBuffer buffers) {
+        requireContext("glCreateBuffers");
        for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.createBuffers());
    }

    public static void glCreateBuffers(int[] buffers) {
+        requireContext("glCreateBuffers");
        for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.createBuffers();
    }

@@ -6783,7 +6987,7 @@ public class GLStateManager {

    private static void onBufferStorage(int target, int flags) {
        if ((flags & MAP_PERSISTENT_BIT) != 0) {
-            markPersistentlyMapped(target);
+            if (!RENDER_BACKEND.isBufferImmutable(bufferForTarget(ctx(), target))) markPersistentlyMapped(target);
            return;
        }
        onBufferRespec(target);
@@ -6866,14 +7070,27 @@ public class GLStateManager {

    public static void nglBufferSubData(int target, long offset, long size, long data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); }

-    public static ByteBuffer glMapBuffer(int target, int access) { onBufferMap(target, access); return RENDER_BACKEND.mapBuffer(target, access); }
+    public static ByteBuffer glMapBuffer(int target, int access) {
+        final ByteBuffer buf = RENDER_BACKEND.mapBuffer(target, access);
+        if (buf != null) onBufferMap(target, access);
+        return buf;
+    }
    public static ByteBuffer glMapBuffer(int target, int access, ByteBuffer old_buffer) { return glMapBuffer(target, access); }
-    public static ByteBuffer glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) { onBufferMap(target, access); return RENDER_BACKEND.mapBuffer(target, access, length, old_buffer); }
-    public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access) { onBufferMapRange(target, access); return RENDER_BACKEND.mapBufferRange(target, offset, length, access); }
+    public static ByteBuffer glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) {
+        final ByteBuffer buf = RENDER_BACKEND.mapBuffer(target, access, length, old_buffer);
+        if (buf != null) onBufferMap(target, access);
+        return buf;
+    }
+    public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access) {
+        final ByteBuffer buf = RENDER_BACKEND.mapBufferRange(target, offset, length, access);
+        if (buf != null) onBufferMapRange(target, access);
+        return buf;
+    }
    public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access, ByteBuffer old_buffer) { return glMapBufferRange(target, offset, length, access); }
    public static long glMapBufferRangeAddress(int target, long offset, long length, int access) {
-        onBufferMapRange(target, access);
-        return RENDER_BACKEND.mapBufferRangeAddress(target, offset, length, access);
+        final long address = RENDER_BACKEND.mapBufferRangeAddress(target, offset, length, access);
+        if (address != 0L) onBufferMapRange(target, access);
+        return address;
    }
    public static void glFlushMappedBufferRange(int target, long offset, long length) { RENDER_BACKEND.flushMappedBufferRange(target, offset, length); }
    public static boolean glUnmapBuffer(int target) { onBufferUnmap(target); return RENDER_BACKEND.unmapBuffer(target); }
@@ -7102,6 +7319,7 @@ public class GLStateManager {
    }

    public static int glGenVertexArrays() {
+        requireContext("glGenVertexArrays");
        return RENDER_BACKEND.genVertexArrays();
    }

@@ -7155,6 +7373,7 @@ public class GLStateManager {
    }

    public static int glGenFramebuffers() {
+        requireContext("glGenFramebuffers");
        return RENDER_BACKEND.genFramebuffers();
    }

@@ -7172,15 +7391,24 @@ public class GLStateManager {

    public static void glFramebufferTexture(int target, int attachment, int texture, int level) { RENDER_BACKEND.framebufferTexture(target, attachment, texture, level); }

-    public static int glGenRenderbuffers() { return RENDER_BACKEND.genRenderbuffers(); }
+    public static int glGenRenderbuffers() {
+        requireContext("glGenRenderbuffers");
+        return RENDER_BACKEND.genRenderbuffers();
+    }
    public static void glDeleteRenderbuffers(int renderbuffer) { RENDER_BACKEND.deleteRenderbuffers(renderbuffer); }
    public static void glBindRenderbuffer(int target, int renderbuffer) { RENDER_BACKEND.bindRenderbuffer(target, renderbuffer); }
    public static void glRenderbufferStorage(int target, int internalformat, int width, int height) { RENDER_BACKEND.renderbufferStorage(target, internalformat, width, height); }
    public static void glRenderbufferStorageMultisample(int target, int samples, int internalformat, int width, int height) { RENDER_BACKEND.renderbufferStorageMultisample(target, samples, internalformat, width, height); }
    public static void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget, int renderbuffer) { RENDER_BACKEND.framebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); }

-    public static void glGenQueries(IntBuffer ids) { RENDER_BACKEND.genQueries(ids); }
-    public static int glGenQueries() { return RENDER_BACKEND.genQueries(); }
+    public static void glGenQueries(IntBuffer ids) {
+        requireContext("glGenQueries");
+        RENDER_BACKEND.genQueries(ids);
+    }
+    public static int glGenQueries() {
+        requireContext("glGenQueries");
+        return RENDER_BACKEND.genQueries();
+    }
    public static void glDeleteQueries(int id) { RENDER_BACKEND.deleteQueries(id); }
    public static void glBeginQuery(int target, int id) { RENDER_BACKEND.beginQuery(target, id); }
    public static void glEndQuery(int target) { RENDER_BACKEND.endQuery(target); }
@@ -7251,8 +7479,8 @@ public class GLStateManager {
        }
    }
    public static long nglMapBuffer(int target, int access) {
-        onBufferMap(target, access);
        final ByteBuffer buf = RENDER_BACKEND.mapBuffer(target, access);
+        if (buf != null) onBufferMap(target, access);
        return buf == null ? 0L : MemoryUtilities.memAddress0(buf);
    }
    public static void nglMultiDrawElementsBaseVertex(int mode, long count, int type, long indices, int primcount, long basevertex) {
@@ -7779,6 +8007,9 @@ public class GLStateManager {
        if (ShaderManager.isEnabled()) {
            generateVertexShaderIfNeeded(program);
        }
+        if (ProgramBinaryCache.isEnabled()) {
+            ProgramBinaryCache.markRetrievable(program);
+        }
        RENDER_BACKEND.linkProgram(program);
        if (ShaderManager.isEnabled() && RENDER_BACKEND.getProgrami(program, GL20.GL_LINK_STATUS) == GL11.GL_FALSE) {
            LOGGER.warn("Program {} failed to link: {}", program, RENDER_BACKEND.getProgramInfoLog(program));
@@ -7786,6 +8017,21 @@ public class GLStateManager {
        CompatUniformManager.onLinkProgram(program);
    }

+    public static void glProgramParameteri(int program, int pname, int value) {
+        RENDER_BACKEND.programParameteri(program, pname, value);
+    }
+
+    public static void glGetProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {
+        RENDER_BACKEND.getProgramBinary(program, length, binaryFormat, binary);
+    }
+
+    public static void glProgramBinary(int program, int binaryFormat, ByteBuffer binary) {
+        RENDER_BACKEND.programBinary(program, binaryFormat, binary);
+        if (RENDER_BACKEND.getProgrami(program, GL20.GL_LINK_STATUS) == GL11.GL_TRUE) {
+            CompatUniformManager.onLinkProgram(program);
+        }
+    }
+
    /**
     * If a program has a fragment shader but no vertex shader, generate a passthrough vertex shader from the fragment's in declarations and attach it.
     */
@@ -7860,6 +8106,7 @@ public class GLStateManager {
    }

    public static int glCreateShader(int type) {
+        requireContext("glCreateShader");
        return RENDER_BACKEND.createShader(type);
    }

@@ -7868,6 +8115,7 @@ public class GLStateManager {
    }

    public static int glCreateProgram() {
+        requireContext("glCreateProgram");
        final int program = RENDER_BACKEND.createProgram();
        programsPendingDeletion.remove(program);
        programLifetimeGeneration++;
@@ -72,6 +72,10 @@ public class GlslTransformUtils {
    }

    public static String renameReservedWords(String source, int targetVersion) {
+        if (!containsWholeWord(source, "sample") && !containsWholeWord(source, "new")
+            && (targetVersion < 400 || !containsWholeWord(source, "sampler"))) {
+            return source;
+        }
        for (var entry : VERSIONED_RESERVED_WORDS.entrySet()) {
            // Rename identifiers that become reserved words at or above this GLSL version
            if (targetVersion >= entry.getKey()) {
@@ -83,6 +87,23 @@ public class GlslTransformUtils {
        return source;
    }

+    static boolean containsWholeWord(String source, String word) {
+        int from = 0;
+        while (true) {
+            final int match = source.indexOf(word, from);
+            if (match < 0) return false;
+            final int end = match + word.length();
+            if ((match == 0 || !isAsciiWordChar(source.charAt(match - 1))) && (end == source.length() || !isAsciiWordChar(source.charAt(end)))) {
+                return true;
+            }
+            from = match + 1;
+        }
+    }
+
+    private static boolean isAsciiWordChar(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+    }
+
    public static String restoreReservedWords(String source) {
        source = source.replace(RENAMED_PREFIX + "texture", "texture");
        source = source.replace(RENAMED_PREFIX + "sampler", "sampler");
@@ -1,6 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
@@ -25,10 +25,10 @@ public final class LTWWorkaround {
            oneTexel = BufferUtils.createByteBuffer(4);
        }
        oneTexel.clear();
-        GLStateManager.forcePixelUnpackState(PixelUnpackState.DEFAULT);
+        GLStateManager.forcePixelUnpackState(PixelStoreState.DEFAULT);
        GLStateManager.suspendPixelUnpackBuffer();
        RENDER_BACKEND.texSubImage2D(target, level, 0, 0, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, oneTexel);
        GLStateManager.restorePixelUnpackBuffer();
-        GLStateManager.restorePixelUnpackState(PixelUnpackState.DEFAULT);
+        GLStateManager.restorePixelUnpackState(PixelStoreState.DEFAULT);
    }
 }
@@ -48,6 +48,7 @@ public class RenderSystem {
    private static boolean supportsClearTexture;
    private static boolean supportsTesselation;
    private static boolean supportsSamplerObjects;
+    private static boolean supportsProgramBinary;
    private static int maxImageUnits;
    @Getter private static int maxCombinedTextureImageUnits;
    private static int maxSSBOBindings;
@@ -159,6 +160,9 @@ public class RenderSystem {
            maxCombinedTextureImageUnits = RENDER_BACKEND.getInteger(GL20.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
        }

+        supportsProgramBinary = RENDER_BACKEND.supportsProgramBinary();
+        GLStateManager.LOGGER.info("Program Binary: {}", supportsProgramBinary);
+
        maxGlslVersion = Integer.parseInt(parseGlVersionString(RENDER_BACKEND.getString(GL20.GL_SHADING_LANGUAGE_VERSION)));
        supportsGpuShader4 = GLStateManager.capabilities.GL_EXT_gpu_shader4;

@@ -611,6 +615,10 @@ public class RenderSystem {
        return supportsSamplerObjects;
    }

+    public static boolean supportsProgramBinary() {
+        return supportsProgramBinary;
+    }
+
    public static int genSampler() {
        if (!supportsSamplerObjects) return 0;
        return GLStateManager.glGenSamplers();
@@ -107,9 +107,11 @@ public final class StateSet {
                GLStateManager.getTextures().getTextureUnitBindings(0), GLStateManager.getTextures().getTextureUnitBindings(1),
                GLStateManager.getActiveTextureUnitStack(), GLStateManager.getProgramStack(),
                GLStateManager.getBlendMode(), GLStateManager.getAlphaTest(), GLStateManager.getDepthTest(),
-                GLStateManager.getTextures().getTextureUnitStates(0)
+                GLStateManager.getTextures().getTextureUnitStates(0),
+                GLStateManager.getColorMask(), GLStateManager.getCullState(),
+                GLStateManager.getPolygonState(), GLStateManager.getPolygonOffsetFillState()
            ),
-            R_BLEND | R_DEPTH | R_TEXTURE | R_ACTIVE_UNIT | R_PROGRAM,
+            R_BLEND | R_DEPTH | R_COLOR_MASK | R_TEXTURE | R_ACTIVE_UNIT | R_PROGRAM | R_POLYGON,
            0,
            true);
    }
@@ -121,9 +123,11 @@ public final class StateSet {
                GLStateManager.getTextures().getTextureUnitBindings(0), GLStateManager.getTextures().getTextureUnitBindings(1),
                GLStateManager.getActiveTextureUnitStack(),
                GLStateManager.getBlendMode(), GLStateManager.getAlphaTest(), GLStateManager.getDepthTest(),
-                GLStateManager.getTextures().getTextureUnitStates(0)
+                GLStateManager.getTextures().getTextureUnitStates(0),
+                GLStateManager.getColorMask(), GLStateManager.getCullState(),
+                GLStateManager.getPolygonState(), GLStateManager.getPolygonOffsetFillState()
            ),
-            R_BLEND | R_DEPTH | R_TEXTURE | R_ACTIVE_UNIT,
+            R_BLEND | R_DEPTH | R_COLOR_MASK | R_TEXTURE | R_ACTIVE_UNIT | R_POLYGON,
            0,
            true);
    }
@@ -0,0 +1,38 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import com.gtnewhorizons.angelica.config.SystemProperties;
+
+public final class BackendOptions {
+
+    private static boolean configSdlGpu;
+    private static String configDriver = "";
+    private static int configGlVersion;
+
+    private BackendOptions() {}
+
+    public static void latch(boolean sdlGpu, String driver, int glVersion) {
+        configSdlGpu = sdlGpu;
+        configDriver = driver;
+        configGlVersion = glVersion;
+    }
+
+    public static boolean sdlGpuRequested() {
+        return SystemProperties.SDL_GPU_OVERRIDE != null ? SystemProperties.SDL_GPU_OVERRIDE : configSdlGpu;
+    }
+
+    public static String sdlGpuDriver() {
+        return SystemProperties.SDL_GPU_DRIVER_OVERRIDE != null ? SystemProperties.SDL_GPU_DRIVER_OVERRIDE : configDriver;
+    }
+
+    public static boolean configSdlGpu() {
+        return configSdlGpu;
+    }
+
+    public static String configDriver() {
+        return configDriver;
+    }
+
+    public static int configGlVersion() {
+        return configGlVersion;
+    }
+}
@@ -0,0 +1,55 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+
+public final class BackendStartGuard {
+
+    private static final Logger LOGGER = LogManager.getLogger("Angelica/BackendStartGuard");
+
+    private static File pending;
+    private static boolean tripped;
+
+    private BackendStartGuard() {}
+
+    public static boolean begin(File marker, boolean sdlGpuConfigured, boolean flagForced) {
+        pending = null;
+        tripped = false;
+        if (!sdlGpuConfigured || flagForced) {
+            delete(marker);
+            return false;
+        }
+        if (marker.isFile()) {
+            delete(marker);
+            tripped = true;
+            return true;
+        }
+        try {
+            final File dir = marker.getParentFile();
+            if (dir != null && !dir.isDirectory() && !dir.mkdirs()) throw new IOException("cannot create " + dir);
+            if (marker.createNewFile()) pending = marker;
+        } catch (IOException e) {
+            LOGGER.warn("Could not write {}: {}", marker, e.toString());
+        }
+        return false;
+    }
+
+    public static void finish() {
+        if (pending == null) return;
+        delete(pending);
+        pending = null;
+    }
+
+    public static boolean tripped() {
+        return tripped;
+    }
+
+    private static void delete(File marker) {
+        if (marker.isFile() && !marker.delete()) {
+            LOGGER.warn("Could not delete {}", marker);
+        }
+    }
+}
@@ -1,6 +1,7 @@
 package com.gtnewhorizons.angelica.glsm.backend;

 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.AMDDebugOutput;
 import org.lwjgl.opengl.AMDDebugOutputCallback;
@@ -23,6 +24,7 @@ import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL40;
+import org.lwjgl.opengl.GL41;
 import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.GL33;
 import org.lwjgl.opengl.GL42;
@@ -807,6 +809,28 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        return GL20.glIsProgram(obj);
    }

+    @Override
+    public boolean supportsProgramBinary() {
+        final ContextCapabilities caps = GLStateManager.capabilities;
+        return !RenderSystem.isGLES() && (caps.OpenGL41 || caps.GL_ARB_get_program_binary)
+            && GL11.glGetInteger(GL41.GL_NUM_PROGRAM_BINARY_FORMATS) > 0;
+    }
+
+    @Override
+    public void programParameteri(int program, int pname, int value) {
+        GL41.glProgramParameteri(program, pname, value);
+    }
+
+    @Override
+    public void getProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {
+        GL41.glGetProgramBinary(program, length, binaryFormat, binary);
+    }
+
+    @Override
+    public void programBinary(int program, int binaryFormat, ByteBuffer binary) {
+        GL41.glProgramBinary(program, binaryFormat, binary);
+    }
+
    @Override
    public void validateProgram(int program) {
        GL20.glValidateProgram(program);
@@ -0,0 +1,125 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import com.gtnewhorizons.angelica.config.SystemProperties;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
+
+public final class MoltenVK {
+
+    public enum Source {
+        ENV,
+        JAR,
+        SYSTEM,
+        NONE
+    }
+
+    public static final String ENV_VULKAN_LIBRARY = "SDL_VULKAN_LIBRARY";
+    public static final String JAR_NAME = "angelica-moltenvk";
+
+    private static final Logger LOGGER = LogManager.getLogger("Angelica/MoltenVK");
+    private static final String LIB_NAME = "libMoltenVK.dylib";
+    private static final String[] SYSTEM_PATHS = { "/opt/homebrew/lib/" + LIB_NAME, "/usr/local/lib/" + LIB_NAME };
+    private static final String ARCH = archName(System.getProperty("os.arch", ""));
+
+    private static Source source;
+    private static String path;
+    private static boolean located;
+
+    private MoltenVK() {}
+
+    public static synchronized Source source() {
+        if (source == null) {
+            final boolean macos = System.getProperty("os.name", "").toLowerCase().contains("mac");
+            source = detect(macos, System.getenv(ENV_VULKAN_LIBRARY), MoltenVK.class.getResource(bundledResource(ARCH)) != null, SYSTEM_PATHS);
+        }
+        return source;
+    }
+
+    public static synchronized String locate() {
+        if (!located) {
+            path = resolve(source(), System.getenv(ENV_VULKAN_LIBRARY), bundledResource(ARCH), new File(SystemProperties.MOLTENVK_DIR), ARCH, SYSTEM_PATHS);
+            located = true;
+        }
+        return path;
+    }
+
+    static String archName(String osArch) {
+        final String arch = osArch.toLowerCase();
+        return arch.contains("aarch64") || arch.contains("arm64") ? "arm64" : "x64";
+    }
+
+    static String bundledResource(String arch) {
+        return "/macos/" + arch + "/org/lwjgl/vulkan/" + LIB_NAME;
+    }
+
+    static Source detect(boolean macos, String env, boolean bundled, String[] systemPaths) {
+        if (!macos) return Source.NONE;
+        if (env != null && !env.isEmpty()) return Source.ENV;
+        if (bundled) return Source.JAR;
+        return systemPath(systemPaths) != null ? Source.SYSTEM : Source.NONE;
+    }
+
+    static String resolve(Source source, String env, String resource, File dir, String arch, String[] systemPaths) {
+        return switch (source) {
+            case ENV -> env;
+            case JAR -> {
+                final String extracted = extract(resource, dir, arch);
+                yield extracted != null ? extracted : systemPath(systemPaths);
+            }
+            case SYSTEM -> systemPath(systemPaths);
+            case NONE -> null;
+        };
+    }
+
+    private static String systemPath(String[] systemPaths) {
+        for (final String candidate : systemPaths) {
+            if (new File(candidate).isFile()) return candidate;
+        }
+        return null;
+    }
+
+    private static String extract(String resource, File dir, String arch) {
+        final byte[] lib;
+        try (InputStream in = MoltenVK.class.getResourceAsStream(resource)) {
+            if (in == null) return null;
+            lib = readAll(in);
+        } catch (IOException e) {
+            LOGGER.warn("MoltenVK: failed reading {}: {}", resource, e.toString());
+            return null;
+        }
+
+        final File target = new File(dir, "libMoltenVK-" + arch + ".dylib");
+        File tmp = null;
+        try {
+            if (!target.isFile() || target.length() != lib.length || !Arrays.equals(Files.readAllBytes(target.toPath()), lib)) {
+                if (!dir.isDirectory() && !dir.mkdirs()) throw new IOException("cannot create " + dir);
+                tmp = File.createTempFile("libMoltenVK", ".dylib", dir);
+                Files.write(tmp.toPath(), lib);
+                Files.move(tmp.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException e) {
+            LOGGER.warn("MoltenVK: failed extracting to {}: {}", target, e.toString());
+            if (tmp != null) tmp.delete();
+            return null;
+        }
+        return target.getAbsolutePath();
+    }
+
+    private static byte[] readAll(InputStream in) throws IOException {
+        final ByteArrayOutputStream out = new ByteArrayOutputStream(1 << 20);
+        final byte[] buf = new byte[16384];
+        int n;
+        while ((n = in.read(buf)) != -1) {
+            out.write(buf, 0, n);
+        }
+        return out.toByteArray();
+    }
+}
@@ -36,6 +36,9 @@ public abstract class RenderBackend {
    /** Returns true if the current thread has a valid render context. */
    public abstract boolean hasContext();

+    /** Returns true if the calling thread may issue render commands. */
+    public boolean hasContextOnThread() { return hasContext(); }
+
    /** Returns true if the calling thread owns the "GL Context" */
    public abstract boolean isCurrent();

@@ -56,6 +59,7 @@ public abstract class RenderBackend {

    public boolean framebufferCompletenessIsMeaningful() { return true; }
    public void onPersistentBufferWrite(int glId, long offset, long size) {}
+    public boolean isBufferImmutable(int glId) { return false; }

    public boolean isAnisotropicSupported() { return true; }

@@ -504,6 +508,10 @@ public abstract class RenderBackend {
    public abstract int getUniformLocation(int program, ByteBuffer name);
    public boolean isShader(int obj) { return false; }
    public boolean isProgram(int obj) { return false; }
+    public boolean supportsProgramBinary() { return false; }
+    public void programParameteri(int program, int pname, int value) {}
+    public void getProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {}
+    public void programBinary(int program, int binaryFormat, ByteBuffer binary) {}
    public void validateProgram(int program) {}
    public void getAttachedShaders(int program, IntBuffer count, IntBuffer shaders) {
        if (count != null) count.put(0, 0);
@@ -133,11 +133,13 @@ public class DSAARB extends DSAUnsupported {

    @Override
    public int createFramebuffer() {
+        GLStateManager.requireContext("glCreateFramebuffers");
        return RENDER_BACKEND.createFramebuffers();
    }

    @Override
    public int createTexture(int target) {
+        GLStateManager.requireContext("glCreateTextures");
        return RENDER_BACKEND.createTextures(target);
    }
 }
@@ -165,7 +165,7 @@ public class DSAUnsupported implements DSAAccess {

    @Override
    public int createTexture(int target) {
-        final int texture = RENDER_BACKEND.genTextures();
+        final int texture = GLStateManager.glGenTextures();
        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
        return texture;
    }
@@ -54,9 +54,17 @@ public final class GeometryShaderGenerator {
        sb.append("    vec4 c0 = gl_in[0].gl_Position;\n");
        sb.append("    vec4 c1 = gl_in[1].gl_Position;\n\n");

+        sb.append("    float d0 = c0.z + c0.w;\n");
+        sb.append("    float d1 = c1.z + c1.w;\n");
+        sb.append("    if (d0 < 0.0 && d1 < 0.0) return;\n");
+        sb.append("    float t0 = d0 < 0.0 ? d0 / (d0 - d1) : 0.0;\n");
+        sb.append("    float t1 = d1 < 0.0 ? d0 / (d0 - d1) : 1.0;\n");
+        sb.append("    vec4 p0 = mix(c0, c1, t0);\n");
+        sb.append("    vec4 p1 = mix(c0, c1, t1);\n\n");
+
        sb.append("    // NDC positions\n");
-        sb.append("    vec2 n0 = c0.xy / c0.w;\n");
-        sb.append("    vec2 n1 = c1.xy / c1.w;\n\n");
+        sb.append("    vec2 n0 = p0.xy / p0.w;\n");
+        sb.append("    vec2 n1 = p1.xy / p1.w;\n\n");

        sb.append("    // Screen-space direction and perpendicular\n");
        sb.append("    vec2 dir = normalize((n1 - n0) * u_ViewportSize);\n");
@@ -74,22 +82,22 @@ public final class GeometryShaderGenerator {
    }

    private static void emitVertex(StringBuilder sb, VertexKey key, int endpointIdx, String offsetExpr) {
-        final String ci = "c" + endpointIdx;
+        final String pi = "p" + endpointIdx;
        final String ni = "n" + endpointIdx;
-        final String idx = "[" + endpointIdx + "]";
+        final String ti = "t" + endpointIdx;

        sb.append("    // Endpoint ").append(endpointIdx).append(' ').append(offsetExpr).append('\n');

-        sb.append("    v_Color = v_Color_gs").append(idx).append(";\n");
+        sb.append("    v_Color = ").append(lerp("v_Color_gs", ti)).append(";\n");
        if (key.separateSpecular()) {
-            sb.append("    v_SpecularColor = v_SpecularColor_gs").append(idx).append(";\n");
+            sb.append("    v_SpecularColor = ").append(lerp("v_SpecularColor_gs", ti)).append(";\n");
        }
-        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("    v_TexCoord0 = v_TexCoord0_gs").append(idx).append(";\n");
-        if (key.lightmapEnabled())            sb.append("    v_TexCoord1 = v_TexCoord1_gs").append(idx).append(";\n");
-        if (key.unitTexCoordEnabled(2))       sb.append("    v_TexCoord2 = v_TexCoord2_gs").append(idx).append(";\n");
-        if (key.unitTexCoordEnabled(3))       sb.append("    v_TexCoord3 = v_TexCoord3_gs").append(idx).append(";\n");
+        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("    v_TexCoord0 = ").append(lerp("v_TexCoord0_gs", ti)).append(";\n");
+        if (key.lightmapEnabled())            sb.append("    v_TexCoord1 = ").append(lerp("v_TexCoord1_gs", ti)).append(";\n");
+        if (key.unitTexCoordEnabled(2))       sb.append("    v_TexCoord2 = ").append(lerp("v_TexCoord2_gs", ti)).append(";\n");
+        if (key.unitTexCoordEnabled(3))       sb.append("    v_TexCoord3 = ").append(lerp("v_TexCoord3_gs", ti)).append(";\n");
        if (key.fogEnabled()) {
-            sb.append("    v_FogCoord = v_FogCoord_gs").append(idx).append(";\n");
+            sb.append("    v_FogCoord = ").append(lerp("v_FogCoord_gs", ti)).append(";\n");
        }
        if (key.lineStipple()) {
            sb.append("    v_LineStart = v_LineStart_gs[0];\n");
@@ -97,11 +105,15 @@ public final class GeometryShaderGenerator {

        if (key.clipPlanesEnabled()) {
            for (int i = 0; i < 8; i++) {
-                sb.append("    gl_ClipDistance[").append(i).append("] = gl_in").append(idx).append(".gl_ClipDistance[").append(i).append("];\n");
+                sb.append("    gl_ClipDistance[").append(i).append("] = mix(gl_in[0].gl_ClipDistance[").append(i).append("], gl_in[1].gl_ClipDistance[").append(i).append("], ").append(ti).append(");\n");
            }
        }

-        sb.append("    gl_Position = vec4((").append(ni).append(' ').append(offsetExpr).append(") * ").append(ci).append(".w, ").append(ci).append(".z, ").append(ci).append(".w);\n");
+        sb.append("    gl_Position = vec4((").append(ni).append(' ').append(offsetExpr).append(") * ").append(pi).append(".w, ").append(pi).append(".z, ").append(pi).append(".w);\n");
        sb.append("    EmitVertex();\n\n");
    }
+
+    private static String lerp(String input, String t) {
+        return "mix(" + input + "[0], " + input + "[1], " + t + ")";
+    }
 }
@@ -85,6 +85,11 @@ public final class EcosystemNarrowRules {
            "com.tihyo.legends.management.asm.AbstractTransformer",
            "com.tihyo.legends.management.asm.ASMHelper",
            "com.tihyo.legends.management.asm.Transformer"
+        )),
+
+        new NarrowRule("PowerConverters", "covers1624.powerconverters.", List.of(
+            "covers1624.powerconverters.asm",
+            "covers1624.powerconverters.randomdebugshit.CoFHDevEnvHacks"
        ))
    );

@@ -3,7 +3,7 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.GLTypes;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -28,7 +28,7 @@ public record TexImage2DCmd(
    int format,
    int type,
    @Nullable ByteBuffer pixels,
-    @Nullable PixelUnpackState unpack
+    @Nullable PixelStoreState unpack
 ) implements DisplayListCommand {

    public TexImage2DCmd {
@@ -37,19 +37,19 @@ public record TexImage2DCmd(
        }
    }

-    public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels, PixelUnpackState unpack) {
+    public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels, PixelUnpackState unpack) {
+    public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels, PixelUnpackState unpack) {
+    public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels, PixelUnpackState unpack) {
+    public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

@@ -3,7 +3,7 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.GLTypes;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -28,7 +28,7 @@ public record TexSubImage2DCmd(
    int format,
    int type,
    @Nullable ByteBuffer pixels,
-    @Nullable PixelUnpackState unpack
+    @Nullable PixelStoreState unpack
 ) implements DisplayListCommand {

    public TexSubImage2DCmd {
@@ -37,19 +37,19 @@ public record TexSubImage2DCmd(
        }
    }

-    public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels, PixelUnpackState unpack) {
+    public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels, PixelUnpackState unpack) {
+    public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels, PixelUnpackState unpack) {
+    public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels, PixelUnpackState unpack) {
+    public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

@@ -626,6 +626,7 @@ public class GLSMRedirector {
            .add("glGenRenderbuffers")
            .add("glRenderbufferStorage")
            .add("glFramebufferRenderbuffer")
+            .add("glGenerateMipmap")
        );
        methodRedirects.put(EXTFramebufferObject, RedirectMap.newMap()
            .add("glBindFramebufferEXT", "glBindFramebuffer")
@@ -638,6 +639,7 @@ public class GLSMRedirector {
            .add("glGenRenderbuffersEXT", "glGenRenderbuffers")
            .add("glRenderbufferStorageEXT", "glRenderbufferStorage")
            .add("glFramebufferRenderbufferEXT", "glFramebufferRenderbuffer")
+            .add("glGenerateMipmapEXT", "glGenerateMipmap")
        );
        methodRedirects.put(ARBOcclusionQuery, RedirectMap.newMap()
            .add("glGenQueriesARB", "glGenQueries")
@@ -0,0 +1,255 @@
+package com.gtnewhorizons.angelica.glsm.shader;
+
+import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
+import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
+import com.gtnewhorizons.angelica.glsm.threading.AngelicaWorkers;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.GL41;
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+/**
+ * Saves linked GL programs to disk and loads them back with glProgramBinary, skipping compile and link.
+ */
+public final class ProgramBinaryCache {
+    private static final Logger LOGGER = LogManager.getLogger("ProgramBinaryCache");
+    static final String LAYER = "gl-program";
+    private static final int PACKS_KEPT = 3;
+
+    private static volatile boolean enabled;
+    private static volatile String packLayer;
+    private static String driverId;
+    private static String fullCompileLayer;
+    private static Set<String> keysInUse;
+    private static List<CompletableFuture<Boolean>> fullCompileWrites;
+    private static Object fullCompileGeneration;
+    private static final AtomicBoolean rejectWarned = new AtomicBoolean();
+    private static final Object WRITE_LOCK = new Object();
+    private static final Map<String, Object> compileGenerations = new HashMap<>();
+    private static int deleteCount;
+
+    private ProgramBinaryCache() {}
+
+    public static void setEnabled(boolean value) {
+        enabled = value;
+    }
+
+    public static boolean isEnabled() {
+        return enabled && packLayer != null && RenderSystem.supportsProgramBinary() && ShaderDiskCache.isEnabled();
+    }
+
+    public static void usePack(String packName) {
+        if (packName == null) {
+            packLayer = null;
+            return;
+        }
+        final String layer = LAYER + '/' + folderName(packName);
+        packLayer = layer;
+        if (!enabled) return;
+        ShaderDiskCache.touchLayer(layer);
+        AngelicaWorkers.run(() -> ShaderDiskCache.keepNewestSubLayers(LAYER, PACKS_KEPT));
+    }
+
+    public static Key key() {
+        return new Key(ShaderDiskCache.key(packLayer).str(driverId()).b(ShaderManager.isEnabled()));
+    }
+
+    public static void markRetrievable(int program) {
+        GLStateManager.glProgramParameteri(program, GL41.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL11.GL_TRUE);
+    }
+
+    public static int load(Key key) {
+        final ShaderDiskCache.Key diskKey = key.diskKey;
+        final ShaderDiskCache.Blob blob = ShaderDiskCache.getBlob(diskKey);
+        if (blob == null) return 0;
+        final int format;
+        try {
+            format = Integer.parseInt(blob.tag());
+        } catch (NumberFormatException e) {
+            ShaderDiskCache.remove(diskKey);
+            return 0;
+        }
+        final int program = GLStateManager.glCreateProgram();
+        final ByteBuffer data = MemoryUtilities.memAlloc(blob.data().length);
+        try {
+            data.put(blob.data()).flip();
+            GLStateManager.glProgramBinary(program, format, data);
+        } finally {
+            MemoryUtilities.memFree(data);
+        }
+        if (GLStateManager.glGetProgrami(program, GL20.GL_LINK_STATUS) != GL11.GL_TRUE) {
+            GLStateManager.glDeleteProgram(program);
+            ShaderDiskCache.remove(diskKey);
+            if (rejectWarned.compareAndSet(false, true)) LOGGER.error("Driver rejected a saved shader program!! Recompiling rejected programs from source");
+            return 0;
+        }
+        keep(diskKey);
+        return program;
+    }
+
+    public static void save(Key key, int program) {
+        if (!saveBinary(key, program) && fullCompileWrites != null) {
+            fullCompileWrites.add(CompletableFuture.completedFuture(false));
+        }
+    }
+
+    private static boolean saveBinary(Key key, int program) {
+        final int length = GLStateManager.glGetProgrami(program, GL41.GL_PROGRAM_BINARY_LENGTH);
+        if (length <= 0) return false;
+        final ByteBuffer data = MemoryUtilities.memAlloc(length);
+        final IntBuffer written = MemoryUtilities.memAllocInt(1);
+        final IntBuffer format = MemoryUtilities.memAllocInt(1);
+        try {
+            GLStateManager.glGetProgramBinary(program, written, format, data);
+            if (written.get(0) <= 0) return false;
+            data.limit(written.get(0));
+            final byte[] binary = ShaderCacheIO.toHeap(data);
+            final String formatTag = Integer.toString(format.get(0));
+            final ShaderDiskCache.Key diskKey = key.diskKey;
+            keep(diskKey);
+            final int deletesBefore;
+            synchronized (WRITE_LOCK) {
+                deletesBefore = deleteCount;
+            }
+            final CompletableFuture<Boolean> write = AngelicaWorkers.submit(() -> {
+                synchronized (WRITE_LOCK) {
+                    return deletesBefore == deleteCount && ShaderDiskCache.putBlob(diskKey, formatTag, binary);
+                }
+            });
+            final List<CompletableFuture<Boolean>> writes = fullCompileWrites;
+            if (writes != null) writes.add(write);
+            return true;
+        } finally {
+            MemoryUtilities.memFree(data);
+            MemoryUtilities.memFree(written);
+            MemoryUtilities.memFree(format);
+        }
+    }
+
+    public static boolean isFullCompileRunning() {
+        return keysInUse != null;
+    }
+
+    public static boolean saveRetained(Key key, int program) {
+        if (ShaderDiskCache.getBlob(key.diskKey) != null) {
+            keep(key.diskKey);
+            return true;
+        }
+        return saveBinary(key, program);
+    }
+
+    public static void beginFullCompile() {
+        fullCompileLayer = packLayer;
+        keysInUse = new HashSet<>();
+        fullCompileWrites = new ArrayList<>();
+        synchronized (WRITE_LOCK) {
+            fullCompileGeneration = new Object();
+            if (fullCompileLayer != null) compileGenerations.put(fullCompileLayer, fullCompileGeneration);
+        }
+    }
+    public static void finishFullCompile(@Nullable String completedSettings) {
+        final String layer = fullCompileLayer;
+        final Set<String> used = keysInUse;
+        final List<CompletableFuture<Boolean>> writes = fullCompileWrites;
+        final Object generation = fullCompileGeneration;
+        fullCompileLayer = null;
+        keysInUse = null;
+        fullCompileWrites = null;
+        fullCompileGeneration = null;
+        if (layer == null || used == null || writes == null) return;
+
+        final ShaderDiskCache.Key marker = completedSettings != null ? compiledSettingsKey(layer, completedSettings) : null;
+        final String markerHex = marker != null ? marker.hex() : null;
+        CompletableFuture.allOf(writes.toArray(new CompletableFuture<?>[0])).whenComplete((ignored, failure) -> {
+            synchronized (WRITE_LOCK) {
+                if (compileGenerations.get(layer) != generation) return;
+                if (marker == null || failure != null) return;
+                for (CompletableFuture<Boolean> write : writes) {
+                    if (!write.join()) return;
+                }
+                ShaderDiskCache.retainLayer(layer, used);
+                ShaderDiskCache.retainLayer(layer + "/settings", Collections.singleton(markerHex));
+                ShaderDiskCache.putString(marker, "");
+            }
+        });
+    }
+
+    public static void deleteAll() {
+        synchronized (WRITE_LOCK) {
+            deleteCount++;
+            compileGenerations.clear();
+            ShaderDiskCache.deleteLayer(LAYER);
+        }
+    }
+
+    public static boolean wasCompiledFor(String settings) {
+        final String layer = packLayer;
+        return layer != null && ShaderDiskCache.getString(compiledSettingsKey(layer, settings)) != null;
+    }
+
+    private static ShaderDiskCache.Key compiledSettingsKey(String layer, String settings) {
+        return ShaderDiskCache.key(layer + "/settings").str(driverId()).b(ShaderManager.isEnabled()).str(settings);
+    }
+
+    private static String folderName(String packName) {
+        final StringBuilder name = new StringBuilder(Math.min(packName.length(), 64));
+        for (int i = 0; i < packName.length() && name.length() < 64; i++) {
+            final char c = packName.charAt(i);
+            name.append(c < 128 && (Character.isLetterOrDigit(c) || c == '.' || c == '-' || c == '_') ? c : '_');
+        }
+        return name.toString();
+    }
+
+    private static void keep(ShaderDiskCache.Key diskKey) {
+        final String hex = diskKey.hex();
+        final Set<String> used = keysInUse;
+        if (used != null) used.add(hex);
+    }
+
+    private static String driverId() {
+        String id = driverId;
+        if (id == null) {
+            id = RENDER_BACKEND.getString(GL11.GL_VENDOR) + '|' + RENDER_BACKEND.getString(GL11.GL_RENDERER) + '|'
+                + RENDER_BACKEND.getString(GL11.GL_VERSION) + '|' + RENDER_BACKEND.getString(GL20.GL_SHADING_LANGUAGE_VERSION) + '|'
+                + RenderSystem.isGLES() + '|' + RENDER_BACKEND.getMinGLSLVersion();
+            driverId = id;
+        }
+        return id;
+    }
+
+    public static final class Key {
+        private final ShaderDiskCache.Key diskKey;
+
+        private Key(ShaderDiskCache.Key diskKey) {
+            this.diskKey = diskKey;
+        }
+
+        public Key stage(int shaderType, String source) {
+            diskKey.str("stage").i(shaderType).str(source);
+            return this;
+        }
+
+        public Key attribute(String name, int index) {
+            diskKey.str("attribute").str(name).i(index);
+            return this;
+        }
+    }
+}
@@ -19,14 +19,18 @@ import java.nio.file.SimpleFileVisitor;
 import java.nio.file.StandardCopyOption;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Stream;
@@ -49,7 +53,10 @@ public final class ShaderDiskCache {

    private ShaderDiskCache() {}

-    public static void configure(Path dir, String salt) {
+    private static String configuredSalt;
+
+    public static synchronized void configure(Path dir, String salt) {
+        if (dir.equals(root) && salt.equals(configuredSalt)) return;
        try {
            Files.createDirectories(dir);
            final Path saltFile = dir.resolve("salt");
@@ -59,6 +66,7 @@ public final class ShaderDiskCache {
                Files.write(saltFile, salt.getBytes(StandardCharsets.UTF_8));
            }
            root = dir;
+            configuredSalt = salt;
            AngelicaWorkers.run(() -> enforceCap(dir, MAX_BYTES));
            LOGGER.info("Shader disk cache at {}", dir);
        } catch (IOException | RuntimeException e) {
@@ -116,9 +124,9 @@ public final class ShaderDiskCache {
        }
    }

-    public static void put(Key key, byte[] payload) {
+    public static boolean put(Key key, byte[] payload) {
        final Path r = root;
-        if (r == null) return;
+        if (r == null) return false;
        final Path target = key.path(r);
        final Path tmp = target.resolveSibling(key.hex() + '.' + TMP_SEQ.getAndIncrement() + ".tmp");
        try {
@@ -129,11 +137,13 @@ public final class ShaderDiskCache {
                write(tmp, payload);
            }
            Files.move(tmp, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            return true;
        } catch (IOException e) {
            try {
                Files.deleteIfExists(tmp);
            } catch (IOException ignored) {}
            if (writeWarned.compareAndSet(false, true)) LOGGER.warn("Shader disk cache write failed for {}", target, e);
+            return false;
        }
    }

@@ -202,7 +212,7 @@ public final class ShaderDiskCache {
        }
    }

-    public static void putBlob(Key key, String tag, byte[] data) {
+    public static boolean putBlob(Key key, String tag, byte[] data) {
        final ByteArrayOutputStream bytes = new ByteArrayOutputStream(data.length + 64);
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            writeStr(out, tag);
@@ -210,11 +220,101 @@ public final class ShaderDiskCache {
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
-        put(key, bytes.toByteArray());
+        return put(key, bytes.toByteArray());
    }

    public record Blob(String tag, byte[] data) {}

+    public static void remove(Key key) {
+        final Path r = root;
+        if (r == null) return;
+        try {
+            Files.deleteIfExists(key.path(r));
+        } catch (IOException ignored) {}
+    }
+
+    public static void retainLayer(String layer, Set<String> keep) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        if (!Files.isDirectory(dir)) return;
+        final List<Path> files = new ArrayList<>();
+        try (Stream<Path> list = Files.list(dir)) {
+            list.forEach(files::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        for (Path p : files) {
+            final String name = p.getFileName().toString();
+            if (!name.endsWith(".bin")) continue; // in-flight writes are still .tmp
+            if (keep != null && keep.contains(name.substring(0, name.length() - 4))) continue;
+            try {
+                Files.deleteIfExists(p);
+            } catch (IOException ignored) {}
+        }
+    }
+
+    public static void touchLayer(String layer) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        try {
+            Files.createDirectories(dir);
+            Files.setLastModifiedTime(dir, FileTime.fromMillis(System.currentTimeMillis()));
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not mark {} as used", dir, e);
+        }
+    }
+
+    public static void keepNewestSubLayers(String layer, int keep) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        if (!Files.isDirectory(dir)) return;
+        final List<Path> subLayers = new ArrayList<>();
+        try (Stream<Path> list = Files.list(dir)) {
+            list.filter(Files::isDirectory).forEach(subLayers::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        subLayers.sort(Comparator.comparingLong(ShaderDiskCache::lastModifiedMillis).reversed());
+        for (int i = keep; i < subLayers.size(); i++) {
+            deleteRecursively(subLayers.get(i));
+        }
+    }
+
+    public static void deleteLayer(String layer) {
+        final Path r = root;
+        if (r != null) deleteRecursively(r.resolve(layer));
+    }
+
+    private static long lastModifiedMillis(Path path) {
+        try {
+            return Files.getLastModifiedTime(path).toMillis();
+        } catch (IOException e) {
+            return 0L;
+        }
+    }
+
+    private static void deleteRecursively(Path dir) {
+        if (!Files.exists(dir)) return;
+        final List<Path> paths = new ArrayList<>();
+        try (Stream<Path> walk = Files.walk(dir)) {
+            walk.forEach(paths::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        Collections.reverse(paths);
+        for (Path p : paths) {
+            try {
+                Files.deleteIfExists(p);
+            } catch (IOException ignored) {}
+        }
+    }
+
    static void enforceCap(Path dir, long maxBytes) {
        try {
            final long[] total = {0};
@@ -14,8 +14,8 @@ public final class AlphaStateStack extends AlphaState implements CowStateStack<A

    public AlphaStateStack(int id) {
        cow.id = id;
-        stack = new AlphaState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new AlphaState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new AlphaState();
        }
    }
@@ -25,6 +25,11 @@ public final class AlphaStateStack extends AlphaState implements CowStateStack<A
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -17,8 +17,8 @@ public final class BlendStateStack extends BlendState implements CowStateStack<B

    public BlendStateStack(int id) {
        cow.id = id;
-        stack = new BlendState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new BlendState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new BlendState();
        }
    }
@@ -28,6 +28,11 @@ public final class BlendStateStack extends BlendState implements CowStateStack<B
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return funcUnknown || VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -44,7 +44,7 @@ public class BooleanStateStack extends BooleanState implements CowStateStack<Boo
    public BooleanStateStack(int glCap, boolean initialState, boolean ffpStateOnly) {
        super(glCap, ffpStateOnly);
        this.enabled = initialState;
-        stack = new boolean[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
+        stack = new boolean[GLStateManager.STATE_SLOTS];
    }

    @Override
@@ -52,6 +52,11 @@ public class BooleanStateStack extends BooleanState implements CowStateStack<Boo
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return stateUnknown || (vanillaLayer != null && vanillaLayer.isOverrideHeld()) || enabled != stack[slot];
+    }
+
    @Override
    public void captureSlot(int slot) {
        stack[slot] = vanillaValue();
@@ -10,8 +10,8 @@ public final class Color4Stack extends Color4 implements CowStateStack<Color4Sta

    public Color4Stack(int id) {
        cow.id = id;
-        stack = new Color4[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new Color4[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new Color4();
        }
    }
@@ -33,6 +33,11 @@ public final class Color4Stack extends Color4 implements CowStateStack<Color4Sta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -15,8 +15,8 @@ public final class ColorMaskStack extends ColorMask implements CowStateStack<Col

    public ColorMaskStack(int id) {
        cow.id = id;
-        stack = new ColorMask[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ColorMask[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ColorMask();
        }
    }
@@ -26,6 +26,11 @@ public final class ColorMaskStack extends ColorMask implements CowStateStack<Col
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -101,6 +101,36 @@ public final class CowDispatch {
        };
    }

+    public static boolean slotChanged(byte kind, CowStateStack<?> s, int slot) {
+        return switch (kind) {
+            case BLEND -> ((BlendStateStack) s).slotChanged(slot);
+            case BOOLEAN -> ((BooleanStateStack) s).slotChanged(slot);
+            case CLIP_PLANE_BOOLEAN -> ((ClipPlaneBooleanState) s).slotChanged(slot);
+            case TEXTURE_UNIT_BOOLEAN -> ((TextureUnitBooleanStateStack) s).slotChanged(slot);
+            case COLOR_MASK -> ((ColorMaskStack) s).slotChanged(slot);
+            case LIGHT_STATE -> ((LightStateStack) s).slotChanged(slot);
+            case MATERIAL -> ((MaterialStateStack) s).slotChanged(slot);
+            case STENCIL -> ((StencilStateStack) s).slotChanged(slot);
+            case MATRIX_MODE -> ((MatrixModeStack) s).slotChanged(slot);
+            case LIGHT_MODEL -> ((LightModelStateStack) s).slotChanged(slot);
+            case ALPHA -> ((AlphaStateStack) s).slotChanged(slot);
+            case POINT -> ((PointStateStack) s).slotChanged(slot);
+            case FOG -> ((FogStateStack) s).slotChanged(slot);
+            case VEC4F -> ((Vec4fStack) s).slotChanged(slot);
+            case VEC3F -> ((Vec3fStack) s).slotChanged(slot);
+            case INTEGER -> ((IntegerStateStack) s).slotChanged(slot);
+            case DEPTH -> ((DepthStateStack) s).slotChanged(slot);
+            case VIEWPORT -> ((ViewPortStateStack) s).slotChanged(slot);
+            case POLYGON -> ((PolygonStateStack) s).slotChanged(slot);
+            case COLOR4 -> ((Color4Stack) s).slotChanged(slot);
+            case LINE -> ((LineStateStack) s).slotChanged(slot);
+            case TEXTURE_BINDING -> ((TextureBindingStack) s).slotChanged(slot);
+            case TEX_ENV -> ((TexEnvState) s).slotChanged(slot);
+            case SCISSOR -> ((ScissorStateStack) s).slotChanged(slot);
+            default -> throw new IllegalStateException("Unknown kind: " + kind);
+        };
+    }
+
    public static void restoreSlot(byte kind, CowStateStack<?> s, int slot) {
        switch (kind) {
            case BLEND -> ((BlendStateStack) s).restoreSlot(slot);
@@ -20,6 +20,8 @@ public interface CowStateStack<T> extends IStateStack<T> {

    void restoreSlot(int slot);

+    boolean slotChanged(int slot);
+
    default int stackId() {
        return cowDepths().id;
    }
@@ -17,8 +17,8 @@ public final class DepthStateStack extends DepthState implements CowStateStack<D

    public DepthStateStack(int id) {
        cow.id = id;
-        stack = new DepthState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new DepthState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new DepthState();
        }
    }
@@ -28,6 +28,11 @@ public final class DepthStateStack extends DepthState implements CowStateStack<D
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -10,8 +10,8 @@ public final class FogStateStack extends FogState implements CowStateStack<FogSt

    public FogStateStack(int id) {
        cow.id = id;
-        stack = new FogState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new FogState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new FogState();
        }
    }
@@ -21,6 +21,11 @@ public final class FogStateStack extends FogState implements CowStateStack<FogSt
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class IntegerStateStack extends IntegerState implements CowStateSta
    public IntegerStateStack(int val, int id) {
        cow.id = id;
        setValue(val);
-        stack = new IntegerState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new IntegerState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new IntegerState();
            stack[i].setValue(val);
        }
@@ -30,6 +30,11 @@ public final class IntegerStateStack extends IntegerState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LightModelStateStack extends LightModelState implements CowSt
    public LightModelStateStack(int id) {
        super();
        cow.id = id;
-        stack = new LightModelState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LightModelState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LightModelState();
        }
    }
@@ -22,6 +22,11 @@ public final class LightModelStateStack extends LightModelState implements CowSt
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LightStateStack extends LightState implements CowStateStack<L
    public LightStateStack(int light, int id) {
        super(light);
        cow.id = id;
-        stack = new LightState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LightState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LightState(light);
        }
    }
@@ -22,6 +22,11 @@ public final class LightStateStack extends LightState implements CowStateStack<L
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LineStateStack extends LineState implements CowStateStack<Lin

    public LineStateStack(int id) {
        cow.id = id;
-        stack = new LineState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LineState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LineState();
        }
    }
@@ -22,6 +22,11 @@ public final class LineStateStack extends LineState implements CowStateStack<Lin
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class MaterialStateStack extends MaterialState implements CowStateS
    public MaterialStateStack(int face, int id) {
        super(face);
        cow.id = id;
-        stack = new MaterialState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new MaterialState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new MaterialState(face);
        }
    }
@@ -22,6 +22,11 @@ public final class MaterialStateStack extends MaterialState implements CowStateS
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -10,8 +10,8 @@ public final class MatrixModeStack extends MatrixMode implements CowStateStack<M

    public MatrixModeStack(int id) {
        cow.id = id;
-        stack = new MatrixMode[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new MatrixMode[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new MatrixMode();
        }
    }
@@ -21,6 +21,11 @@ public final class MatrixModeStack extends MatrixMode implements CowStateStack<M
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class PointStateStack extends PointState implements CowStateStack<P

    public PointStateStack(int id) {
        cow.id = id;
-        stack = new PointState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new PointState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new PointState();
        }
    }
@@ -22,6 +22,11 @@ public final class PointStateStack extends PointState implements CowStateStack<P
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class PolygonStateStack extends PolygonState implements CowStateSta

    public PolygonStateStack(int id) {
        cow.id = id;
-        stack = new PolygonState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new PolygonState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new PolygonState();
        }
    }
@@ -22,6 +22,11 @@ public final class PolygonStateStack extends PolygonState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -0,0 +1,12 @@
+package com.gtnewhorizons.angelica.glsm.stacks;
+
+public final class RetainedState {
+    public int[] ids = new int[64];
+    public int count;
+    public int program;
+    public long programGen;
+
+    public void ensureCapacity(int capacity) {
+        if (ids.length < capacity) ids = new int[capacity];
+    }
+}
@@ -11,8 +11,8 @@ public final class ScissorStateStack extends ScissorState implements CowStateSta

    public ScissorStateStack(int id) {
        cow.id = id;
-        stack = new ScissorState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ScissorState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ScissorState();
        }
    }
@@ -22,6 +22,11 @@ public final class ScissorStateStack extends ScissorState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class StencilStateStack extends StencilState implements CowStateSta

    public StencilStateStack(int id) {
        cow.id = id;
-        stack = new StencilState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new StencilState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new StencilState();
        }
    }
@@ -22,6 +22,11 @@ public final class StencilStateStack extends StencilState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -12,8 +12,8 @@ public final class TextureBindingStack extends TextureBinding implements CowStat
    public TextureBindingStack(int id, int unit) {
        cow = new CowDepths(StateSet.R_TEXTURE, unit);
        cow.id = id;
-        stack = new TextureBinding[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new TextureBinding[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new TextureBinding();
        }
    }
@@ -23,6 +23,11 @@ public final class TextureBindingStack extends TextureBinding implements CowStat
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -15,7 +15,7 @@ public final class Vec3fStack implements CowStateStack<Vec3fStack> {
    public Vec3fStack(Vector3f value, int id) {
        this.value = value;
        cow.id = id;
-        stack = new float[GLStateManager.MAX_ATTRIB_STACK_DEPTH][3];
+        stack = new float[GLStateManager.STATE_SLOTS][3];
    }

    @Override
@@ -23,6 +23,11 @@ public final class Vec3fStack implements CowStateStack<Vec3fStack> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return value.x != stack[slot][0] || value.y != stack[slot][1] || value.z != stack[slot][2];
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s][0] = value.x;
@@ -15,7 +15,7 @@ public final class Vec4fStack implements CowStateStack<Vec4fStack> {
    public Vec4fStack(Vector4f value, int id) {
        this.value = value;
        cow.id = id;
-        stack = new float[GLStateManager.MAX_ATTRIB_STACK_DEPTH][4];
+        stack = new float[GLStateManager.STATE_SLOTS][4];
    }

    @Override
@@ -23,6 +23,11 @@ public final class Vec4fStack implements CowStateStack<Vec4fStack> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return value.x != stack[slot][0] || value.y != stack[slot][1] || value.z != stack[slot][2] || value.w != stack[slot][3];
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s][0] = value.x;
@@ -11,8 +11,8 @@ public final class ViewPortStateStack extends ViewportState implements CowStateS

    public ViewPortStateStack(int id) {
        cow.id = id;
-        stack = new ViewportState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ViewportState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ViewportState();
        }
    }
@@ -22,6 +22,11 @@ public final class ViewPortStateStack extends ViewportState implements CowStateS
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -0,0 +1,57 @@
+package com.gtnewhorizons.angelica.glsm.states;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+public record PixelStoreState(
+    int alignment,
+    int rowLength,
+    int skipRows,
+    int skipPixels,
+    int imageHeight,
+    int skipImages,
+    boolean swapBytes,
+    boolean lsbFirst
+) {
+    public static final PixelStoreState DEFAULT = new PixelStoreState(4, 0, 0, 0, 0, 0, false, false);
+
+    public boolean isDefault() {
+        return this.equals(DEFAULT);
+    }
+
+    public static boolean isPack(int pname) {
+        return switch (pname) {
+            case GL11.GL_PACK_ALIGNMENT, GL11.GL_PACK_ROW_LENGTH, GL11.GL_PACK_SKIP_ROWS, GL11.GL_PACK_SKIP_PIXELS,
+                 GL12.GL_PACK_IMAGE_HEIGHT, GL12.GL_PACK_SKIP_IMAGES, GL11.GL_PACK_SWAP_BYTES, GL11.GL_PACK_LSB_FIRST -> true;
+            default -> false;
+        };
+    }
+
+    public PixelStoreState with(int pname, int param) {
+        return switch (pname) {
+            case GL11.GL_UNPACK_ALIGNMENT, GL11.GL_PACK_ALIGNMENT -> (param == alignment || (param != 1 && param != 2 && param != 4 && param != 8)) ? this : new PixelStoreState(param, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_ROW_LENGTH, GL11.GL_PACK_ROW_LENGTH -> (param == rowLength || param < 0) ? this : new PixelStoreState(alignment, param, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SKIP_ROWS, GL11.GL_PACK_SKIP_ROWS -> (param == skipRows || param < 0) ? this : new PixelStoreState(alignment, rowLength, param, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SKIP_PIXELS, GL11.GL_PACK_SKIP_PIXELS -> (param == skipPixels || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, param, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL12.GL_UNPACK_IMAGE_HEIGHT, GL12.GL_PACK_IMAGE_HEIGHT -> (param == imageHeight || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, param, skipImages, swapBytes, lsbFirst);
+            case GL12.GL_UNPACK_SKIP_IMAGES, GL12.GL_PACK_SKIP_IMAGES -> (param == skipImages || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, param, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SWAP_BYTES, GL11.GL_PACK_SWAP_BYTES -> (param != 0) == swapBytes ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, param != 0, lsbFirst);
+            case GL11.GL_UNPACK_LSB_FIRST, GL11.GL_PACK_LSB_FIRST -> (param != 0) == lsbFirst ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, param != 0);
+            default -> this;
+        };
+    }
+
+    public static void applyDiff(PixelStoreState from, PixelStoreState to, boolean pack) {
+        if (from == to) return;
+        if (from.alignment != to.alignment) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_ALIGNMENT : GL11.GL_UNPACK_ALIGNMENT, to.alignment);
+        if (from.rowLength != to.rowLength) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_ROW_LENGTH : GL11.GL_UNPACK_ROW_LENGTH, to.rowLength);
+        if (from.skipRows != to.skipRows) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SKIP_ROWS : GL11.GL_UNPACK_SKIP_ROWS, to.skipRows);
+        if (from.skipPixels != to.skipPixels) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SKIP_PIXELS : GL11.GL_UNPACK_SKIP_PIXELS, to.skipPixels);
+        if (from.imageHeight != to.imageHeight) RENDER_BACKEND.pixelStorei(pack ? GL12.GL_PACK_IMAGE_HEIGHT : GL12.GL_UNPACK_IMAGE_HEIGHT, to.imageHeight);
+        if (from.skipImages != to.skipImages) RENDER_BACKEND.pixelStorei(pack ? GL12.GL_PACK_SKIP_IMAGES : GL12.GL_UNPACK_SKIP_IMAGES, to.skipImages);
+        if (from.swapBytes != to.swapBytes) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SWAP_BYTES : GL11.GL_UNPACK_SWAP_BYTES, to.swapBytes ? 1 : 0);
+        if (from.lsbFirst != to.lsbFirst) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_LSB_FIRST : GL11.GL_UNPACK_LSB_FIRST, to.lsbFirst ? 1 : 0);
+    }
+}
@@ -1,51 +0,0 @@
-package com.gtnewhorizons.angelica.glsm.states;
-
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-
-import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
-
-/**
- * Immutable client-side pixel unpack state (glPixelStore UNPACK_* params)
- */
-public record PixelUnpackState(
-    int alignment,
-    int rowLength,
-    int skipRows,
-    int skipPixels,
-    int imageHeight,
-    int skipImages,
-    boolean swapBytes,
-    boolean lsbFirst
-) {
-    public static final PixelUnpackState DEFAULT = new PixelUnpackState(4, 0, 0, 0, 0, 0, false, false);
-
-    public boolean isDefault() {
-        return this.equals(DEFAULT);
-    }
-
-    public PixelUnpackState with(int pname, int param) {
-        return switch (pname) {
-            case GL11.GL_UNPACK_ALIGNMENT -> (param == 1 || param == 2 || param == 4 || param == 8) ? new PixelUnpackState(param, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
-            case GL11.GL_UNPACK_ROW_LENGTH -> param >= 0 ? new PixelUnpackState(alignment, param, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
-            case GL11.GL_UNPACK_SKIP_ROWS -> param >= 0 ? new PixelUnpackState(alignment, rowLength, param, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
-            case GL11.GL_UNPACK_SKIP_PIXELS -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, param, imageHeight, skipImages, swapBytes, lsbFirst) : this;
-            case GL12.GL_UNPACK_IMAGE_HEIGHT -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, param, skipImages, swapBytes, lsbFirst) : this;
-            case GL12.GL_UNPACK_SKIP_IMAGES -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, param, swapBytes, lsbFirst) : this;
-            case GL11.GL_UNPACK_SWAP_BYTES -> new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, param != 0, lsbFirst);
-            case GL11.GL_UNPACK_LSB_FIRST -> new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, param != 0);
-            default -> this;
-        };
-    }
-
-    public static void applyDiff(PixelUnpackState from, PixelUnpackState to) {
-        if (from.alignment != to.alignment) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_ALIGNMENT, to.alignment);
-        if (from.rowLength != to.rowLength) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_ROW_LENGTH, to.rowLength);
-        if (from.skipRows != to.skipRows) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SKIP_ROWS, to.skipRows);
-        if (from.skipPixels != to.skipPixels) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SKIP_PIXELS, to.skipPixels);
-        if (from.imageHeight != to.imageHeight) RENDER_BACKEND.pixelStorei(GL12.GL_UNPACK_IMAGE_HEIGHT, to.imageHeight);
-        if (from.skipImages != to.skipImages) RENDER_BACKEND.pixelStorei(GL12.GL_UNPACK_SKIP_IMAGES, to.skipImages);
-        if (from.swapBytes != to.swapBytes) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SWAP_BYTES, to.swapBytes ? 1 : 0);
-        if (from.lsbFirst != to.lsbFirst) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_LSB_FIRST, to.lsbFirst ? 1 : 0);
-    }
-}
@@ -6,6 +6,8 @@ import com.gtnewhorizons.angelica.glsm.stacks.CowStateStack;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;

+import java.util.Arrays;
+
 /**
 * Per-texture-unit GL_TEXTURE_ENV state for FFP emulation. Tracks the simple texenv mode and all GL_COMBINE sub-parameters.
 */
@@ -45,8 +47,8 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
            stack = null;
            cow = null;
        } else {
-            stack = new TexEnvState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-            for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+            stack = new TexEnvState[GLStateManager.STATE_SLOTS];
+            for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
                stack[i] = new TexEnvState(true);
            }
            cow = new CowDepths();
@@ -70,6 +72,14 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
        this.envColorA = other.envColorA;
    }

+    private boolean sameAs(TexEnvState other) {
+        return mode == other.mode && combineRgb == other.combineRgb && combineAlpha == other.combineAlpha
+            && Arrays.equals(sourceRgb, other.sourceRgb) && Arrays.equals(sourceAlpha, other.sourceAlpha)
+            && Arrays.equals(operandRgb, other.operandRgb) && Arrays.equals(operandAlpha, other.operandAlpha)
+            && scaleRgb == other.scaleRgb && scaleAlpha == other.scaleAlpha
+            && envColorR == other.envColorR && envColorG == other.envColorG && envColorB == other.envColorB && envColorA == other.envColorA;
+    }
+
    public void reset() {
        mode = GL11.GL_MODULATE;
        combineRgb = GL11.GL_MODULATE;
@@ -89,6 +99,11 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].copyFrom(this);
@@ -8,6 +8,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
@@ -16,6 +17,7 @@ import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;

 public final class AngelicaWorkers {
@@ -153,6 +155,51 @@ public final class AngelicaWorkers {
        }
    }

+    /**
+     * Runs every task and returns the results in task order.
+     */
+    public static <T> List<T> invokeAll(List<? extends Supplier<? extends T>> tasks) {
+        final int count = tasks.size();
+        final Object[] results = new Object[count];
+        if (count == 0) return new ArrayList<>();
+        final AtomicInteger next = new AtomicInteger();
+        final CountDownLatch finished = new CountDownLatch(count);
+        final AtomicReference<Throwable> failure = new AtomicReference<>();
+        final Runnable drain = () -> {
+            int i;
+            while ((i = next.getAndIncrement()) < count) {
+                try {
+                    results[i] = tasks.get(i).get();
+                } catch (Throwable t) {
+                    failure.compareAndSet(null, t);
+                } finally {
+                    finished.countDown();
+                }
+            }
+        };
+        final int helpers = Math.min(threads(), count - 1);
+        for (int h = 0; h < helpers; h++) {
+            run(drain);
+        }
+        drain.run();
+        try {
+            finished.await();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new IllegalStateException("Interrupted waiting for worker tasks", e);
+        }
+        final Throwable t = failure.get();
+        if (t instanceof RuntimeException re) throw re;
+        if (t instanceof Error err) throw err;
+        if (t != null) throw new IllegalStateException(t);
+        final List<T> out = new ArrayList<>(count);
+        for (Object result : results) {
+            @SuppressWarnings("unchecked") final T typed = (T) result;
+            out.add(typed);
+        }
+        return out;
+    }
+
    private static void checkIdleShutdown() {
        synchronized (lock) {
            final ExecutorService current = executor;
@@ -0,0 +1,83 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL14;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@GLCoreTest
+public class GLSM_HudCacheBlendOverride_GLTest {
+
+    private static void assertDriverFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
+        assertEquals(srcRgb, GL11.glGetInteger(GL14.GL_BLEND_SRC_RGB));
+        assertEquals(dstRgb, GL11.glGetInteger(GL14.GL_BLEND_DST_RGB));
+        assertEquals(srcAlpha, GL11.glGetInteger(GL14.GL_BLEND_SRC_ALPHA));
+        assertEquals(dstAlpha, GL11.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
+    }
+
+    private static void assertCachedFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha) {
+        assertEquals(srcRgb, GLStateManager.glGetInteger(GL14.GL_BLEND_SRC_RGB));
+        assertEquals(dstRgb, GLStateManager.glGetInteger(GL14.GL_BLEND_DST_RGB));
+        assertEquals(srcAlpha, GLStateManager.glGetInteger(GL14.GL_BLEND_SRC_ALPHA));
+        assertEquals(dstAlpha, GLStateManager.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
+    }
+
+    @Test
+    void overrideChangesTheDriverFuncButNotTheCache() {
+        try {
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+
+            GLStateManager.setHudCacheOverride(true);
+            assertCachedFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+            GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
+            assertCachedFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_SRC_ALPHA, GL11.GL_ONE);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ZERO, GL11.GL_ONE);
+            assertCachedFunc(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ZERO, GL11.GL_ONE);
+            assertDriverFunc(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+            GLStateManager.setHudCacheOverride(false);
+            assertCachedFunc(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ZERO, GL11.GL_ONE);
+            assertDriverFunc(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ZERO, GL11.GL_ONE);
+        } finally {
+            GLStateManager.setHudCacheOverride(false);
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        }
+    }
+
+    @Test
+    void popUnderOverrideKeepsTheOverriddenAlphaOnTheDriver() {
+        try {
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+            final int d = GLStateManager.pushState(StateSet.BLEND);
+            GLStateManager.setHudCacheOverride(true);
+            GLStateManager.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE);
+            GLStateManager.popStateTo(d);
+            assertCachedFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            GLStateManager.setHudCacheOverride(false);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        } finally {
+            GLStateManager.setHudCacheOverride(false);
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        }
+    }
+
+    @Test
+    void separateAlphaIsForcedEvenWhenDstAlphaAlreadyMatches() {
+        try {
+            GLStateManager.setHudCacheOverride(true);
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            assertCachedFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO, GL11.GL_ONE_MINUS_SRC_ALPHA);
+            assertDriverFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ONE, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        } finally {
+            GLStateManager.setHudCacheOverride(false);
+            GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        }
+    }
+}
@@ -0,0 +1,737 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
+import com.gtnewhorizons.angelica.glsm.ffp.VertexKey;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL14;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.GL21;
+import org.lwjgl.opengl.GL30;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+@GLCoreTest
+public class GLSM_LegacyStackQueries_GLTest {
+
+    private static final int[] SINGLE_VALUE_QUERIES = {
+        GL11.GL_ATTRIB_STACK_DEPTH,
+        GL11.GL_CLIENT_ATTRIB_STACK_DEPTH,
+        GL11.GL_TEXTURE_STACK_DEPTH,
+        GL11.GL_MAX_ATTRIB_STACK_DEPTH,
+        GL11.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH,
+        GL11.GL_MAX_MODELVIEW_STACK_DEPTH,
+        GL11.GL_MAX_PROJECTION_STACK_DEPTH,
+        GL11.GL_MAX_TEXTURE_STACK_DEPTH,
+        GL13.GL_MAX_TEXTURE_UNITS,
+        GL11.GL_MAX_LIGHTS,
+        GL11.GL_STENCIL_BITS,
+        GL11.GL_DEPTH_BITS,
+    };
+
+    private static boolean positionArrayEnabled() {
+        final VAOManager.Attrib position = GLStateManager.ctx().vaos.attrib(Usage.POSITION.getAttributeLocation());
+        return position != null && position.enabled;
+    }
+
+    private static boolean colorArrayEnabled() {
+        return (GLStateManager.ctx().vaos.getVertexFlags() & VertexFlags.COLOR_BIT) != 0;
+    }
+
+    private static void drainErrors() {
+        while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+    }
+
+    private static void drainClientAttribStack() {
+        while (GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH) > 0) {
+            GLStateManager.glPopClientAttrib();
+        }
+    }
+
+    private static void drainAttribStack() {
+        while (GLStateManager.getAttribDepth() > 0) {
+            GLStateManager.glPopAttrib();
+        }
+    }
+
+    private static int pushToLimit(int depthPname, int maxPname) {
+        final int max = GLStateManager.glGetInteger(maxPname);
+        for (int i = 0; i < max + 4; i++) {
+            GLStateManager.glPushMatrix();
+        }
+        return GLStateManager.glGetInteger(depthPname);
+    }
+
+    private static void popToBase(int depthPname) {
+        for (int i = 0; i < 128 && GLStateManager.glGetInteger(depthPname) > 1; i++) {
+            GLStateManager.glPopMatrix();
+        }
+    }
+
+    @Test
+    void attribDepthTracksPushAndPop() {
+        final int base = GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH);
+        try {
+            GLStateManager.glPushAttrib(GL11.GL_ENABLE_BIT);
+            assertEquals(base + 1, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPushAttrib(GL11.GL_COLOR_BUFFER_BIT);
+            assertEquals(base + 2, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopAttrib();
+            assertEquals(base + 1, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopAttrib();
+            assertEquals(base, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            assertEquals(GLStateManager.MAX_ATTRIB_STACK_DEPTH, GLStateManager.glGetInteger(GL11.GL_MAX_ATTRIB_STACK_DEPTH));
+        } finally {
+            while (GLStateManager.getAttribDepth() > base) {
+                GLStateManager.glPopAttrib();
+            }
+        }
+    }
+
+    @Test
+    void clientAttribDepthTracksPushAndPop() {
+        try {
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_VERTEX_ARRAY_BIT);
+            assertEquals(2, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopClientAttrib();
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopClientAttrib();
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopClientAttrib();
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+
+            final int max = GLStateManager.glGetInteger(GL11.GL_MAX_CLIENT_ATTRIB_STACK_DEPTH);
+            for (int i = 0; i < max + 2; i++) {
+                GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            }
+            assertEquals(max, GLStateManager.glGetInteger(GL11.GL_CLIENT_ATTRIB_STACK_DEPTH));
+        } finally {
+            drainClientAttribStack();
+        }
+    }
+
+    @Test
+    void textureStackDepthIsPerActiveUnit() {
+        try {
+            GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
+            GLStateManager.glPushMatrix();
+            assertEquals(2, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
+            assertEquals(2, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+            GLStateManager.glPopMatrix();
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+        } finally {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
+            GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
+            popToBase(GL11.GL_TEXTURE_STACK_DEPTH);
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        }
+    }
+
+    @Test
+    void maxModelviewStackDepthIsExactlyReachable() {
+        try {
+            GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_MODELVIEW_STACK_DEPTH));
+            assertEquals(GLStateManager.glGetInteger(GL11.GL_MAX_MODELVIEW_STACK_DEPTH), pushToLimit(GL11.GL_MODELVIEW_STACK_DEPTH, GL11.GL_MAX_MODELVIEW_STACK_DEPTH));
+        } finally {
+            GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+            popToBase(GL11.GL_MODELVIEW_STACK_DEPTH);
+        }
+    }
+
+    @Test
+    void maxProjectionStackDepthIsExactlyReachable() {
+        try {
+            GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_PROJECTION_STACK_DEPTH));
+            assertEquals(GLStateManager.glGetInteger(GL11.GL_MAX_PROJECTION_STACK_DEPTH), pushToLimit(GL11.GL_PROJECTION_STACK_DEPTH, GL11.GL_MAX_PROJECTION_STACK_DEPTH));
+        } finally {
+            GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+            popToBase(GL11.GL_PROJECTION_STACK_DEPTH);
+            GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        }
+    }
+
+    @Test
+    void maxTextureStackDepthIsExactlyReachable() {
+        try {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
+            assertEquals(1, GLStateManager.glGetInteger(GL11.GL_TEXTURE_STACK_DEPTH));
+            assertEquals(GLStateManager.glGetInteger(GL11.GL_MAX_TEXTURE_STACK_DEPTH), pushToLimit(GL11.GL_TEXTURE_STACK_DEPTH, GL11.GL_MAX_TEXTURE_STACK_DEPTH));
+        } finally {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glMatrixMode(GL11.GL_TEXTURE);
+            popToBase(GL11.GL_TEXTURE_STACK_DEPTH);
+            GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        }
+    }
+
+    @Test
+    void constantQueriesReportEmulatedLimits() {
+        assertEquals(Math.min(VertexKey.MAX_UNITS, GLStateManager.MAX_TEXTURE_UNITS), GLStateManager.glGetInteger(GL13.GL_MAX_TEXTURE_UNITS));
+        assertEquals(8, GLStateManager.glGetInteger(GL11.GL_MAX_LIGHTS));
+    }
+
+    @Test
+    void stencilAndDepthBitsMatchDefaultFramebuffer() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        final int savedDraw = glCtx.drawFramebuffer;
+        final int savedRead = glCtx.readFramebuffer;
+        try {
+            GLStateManager.glBindFramebuffer(GL30.GL_FRAMEBUFFER, 0);
+            drainErrors();
+            assertEquals(
+                GL30.glGetFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE),
+                GLStateManager.glGetInteger(GL11.GL_STENCIL_BITS));
+            assertEquals(
+                GL30.glGetFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE),
+                GLStateManager.glGetInteger(GL11.GL_DEPTH_BITS));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            GLStateManager.glBindFramebuffer(GL30.GL_DRAW_FRAMEBUFFER, savedDraw);
+            GLStateManager.glBindFramebuffer(GL30.GL_READ_FRAMEBUFFER, savedRead);
+        }
+    }
+
+    @Test
+    void stencilAndDepthBitsFollowBoundDrawFramebuffer() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        final int savedDraw = glCtx.drawFramebuffer;
+        final int savedRead = glCtx.readFramebuffer;
+        final int fbo = GLStateManager.glGenFramebuffers();
+        final int depthOnly = GLStateManager.glGenRenderbuffers();
+        final int depthStencil = GLStateManager.glGenRenderbuffers();
+        try {
+            drainErrors();
+            GLStateManager.glBindRenderbuffer(GL30.GL_RENDERBUFFER, depthOnly);
+            GLStateManager.glRenderbufferStorage(GL30.GL_RENDERBUFFER, GL14.GL_DEPTH_COMPONENT24, 16, 16);
+            GLStateManager.glBindRenderbuffer(GL30.GL_RENDERBUFFER, depthStencil);
+            GLStateManager.glRenderbufferStorage(GL30.GL_RENDERBUFFER, GL30.GL_DEPTH24_STENCIL8, 16, 16);
+            GLStateManager.glBindRenderbuffer(GL30.GL_RENDERBUFFER, 0);
+
+            GLStateManager.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_STENCIL_BITS));
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_DEPTH_BITS));
+
+            GLStateManager.glFramebufferRenderbuffer(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_RENDERBUFFER, depthOnly);
+            assertEquals(0, GLStateManager.glGetInteger(GL11.GL_STENCIL_BITS));
+            final int depthOnlyBits = GL30.glGetFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
+            assertTrue(depthOnlyBits >= 24, "driver depth size " + depthOnlyBits);
+            assertEquals(depthOnlyBits, GLStateManager.glGetInteger(GL11.GL_DEPTH_BITS));
+
+            GLStateManager.glFramebufferRenderbuffer(GL30.GL_FRAMEBUFFER, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_RENDERBUFFER, depthStencil);
+            GLStateManager.glFramebufferRenderbuffer(GL30.GL_FRAMEBUFFER, GL30.GL_STENCIL_ATTACHMENT, GL30.GL_RENDERBUFFER, depthStencil);
+            assertEquals(8, GLStateManager.glGetInteger(GL11.GL_STENCIL_BITS));
+            assertEquals(24, GLStateManager.glGetInteger(GL11.GL_DEPTH_BITS));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            GLStateManager.glBindFramebuffer(GL30.GL_DRAW_FRAMEBUFFER, savedDraw);
+            GLStateManager.glBindFramebuffer(GL30.GL_READ_FRAMEBUFFER, savedRead);
+            GLStateManager.glDeleteFramebuffers(fbo);
+            GLStateManager.glDeleteRenderbuffers(depthOnly);
+            GLStateManager.glDeleteRenderbuffers(depthStencil);
+        }
+    }
+
+    @Test
+    void intBufferOverloadMatchesAndDriverIsNotAsked() {
+        final int base = GLStateManager.getAttribDepth();
+        final IntBuffer buf = BufferUtils.createIntBuffer(16);
+        try {
+            GLStateManager.glPushAttrib(GL11.GL_ENABLE_BIT);
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE1);
+            drainErrors();
+            GL11.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH);
+            assumeTrue(GL11.glGetError() != GL11.GL_NO_ERROR, "driver accepts GL_ATTRIB_STACK_DEPTH, so a clean error state proves nothing");
+            for (final int pname : SINGLE_VALUE_QUERIES) {
+                final int direct = GLStateManager.glGetInteger(pname);
+                buf.put(0, -12345);
+                GLStateManager.glGetInteger(pname, buf);
+                assertEquals(direct, buf.get(0), "IntBuffer overload for 0x" + Integer.toHexString(pname));
+                assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "driver error after querying 0x" + Integer.toHexString(pname));
+            }
+        } finally {
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE0);
+            drainClientAttribStack();
+            while (GLStateManager.getAttribDepth() > base) {
+                GLStateManager.glPopAttrib();
+            }
+        }
+    }
+
+    @Test
+    void attribDepthUnchangedWhileCompilingDisplayList() {
+        final int base = GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH);
+        final int list = GLStateManager.glGenLists(1);
+        try {
+            GLStateManager.glNewList(list, GL11.GL_COMPILE);
+            GLStateManager.glPushAttrib(GL11.GL_ENABLE_BIT);
+            assertEquals(base, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            GLStateManager.glPopAttrib();
+            assertEquals(base, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+            GLStateManager.glEndList();
+            assertEquals(base, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+        } finally {
+            if (DisplayListManager.isRecording()) {
+                GLStateManager.glEndList();
+            }
+            GLStateManager.glDeleteLists(list, 1);
+        }
+    }
+
+    @Test
+    void popAttribOnEmptyStackIsIgnored() {
+        drainAttribStack();
+        drainErrors();
+        assertEquals(0, GLStateManager.getAttribDepth());
+        assertDoesNotThrow(GLStateManager::glPopAttrib);
+        assertEquals(0, GLStateManager.glGetInteger(GL11.GL_ATTRIB_STACK_DEPTH));
+        assertDoesNotThrow(GLStateManager::glPopAttrib);
+        assertEquals(0, GLStateManager.getAttribDepth());
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+    }
+
+    @Test
+    void pixelStoreBitRestoresPixelStoreAndPboBindings() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        final int unpackBuffer = GLStateManager.glGenBuffers();
+        final int packBuffer = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+            final PixelStoreState unpackBefore = glCtx.pixelUnpackState;
+            final PixelStoreState packBefore = glCtx.pixelPackState;
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 2);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 7);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, unpackBuffer);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, packBuffer);
+            assertEquals(1, glCtx.pixelUnpackState.alignment());
+            assertEquals(2, glCtx.pixelPackState.alignment());
+            assertEquals(7, glCtx.pixelPackState.rowLength());
+            assertEquals(2, GL11.glGetInteger(GL11.GL_PACK_ALIGNMENT));
+            GLStateManager.glPopClientAttrib();
+
+            assertSame(unpackBefore, glCtx.pixelUnpackState);
+            assertSame(packBefore, glCtx.pixelPackState);
+            assertEquals(4, GLStateManager.glGetInteger(GL11.GL_UNPACK_ALIGNMENT));
+            assertEquals(0, GLStateManager.glGetInteger(GL21.GL_PIXEL_UNPACK_BUFFER_BINDING));
+            assertEquals(0, GLStateManager.glGetInteger(GL21.GL_PIXEL_PACK_BUFFER_BINDING));
+            assertEquals(4, GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT));
+            assertEquals(4, GL11.glGetInteger(GL11.GL_PACK_ALIGNMENT));
+            assertEquals(0, GL11.glGetInteger(GL11.GL_PACK_ROW_LENGTH));
+            assertEquals(0, GL11.glGetInteger(GL21.GL_PIXEL_UNPACK_BUFFER_BINDING));
+            assertEquals(0, GL11.glGetInteger(GL21.GL_PIXEL_PACK_BUFFER_BINDING));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            drainClientAttribStack();
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+            GLStateManager.glDeleteBuffers(unpackBuffer);
+            GLStateManager.glDeleteBuffers(packBuffer);
+        }
+    }
+
+    @Test
+    void pixelStoreIsNotRestoredWithoutPixelStoreBit() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        final int unpackBuffer = GLStateManager.glGenBuffers();
+        final int packBuffer = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_VERTEX_ARRAY_BIT);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 2);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, unpackBuffer);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, packBuffer);
+            GLStateManager.glPopClientAttrib();
+
+            assertEquals(1, glCtx.pixelUnpackState.alignment());
+            assertEquals(2, glCtx.pixelPackState.alignment());
+            assertEquals(unpackBuffer, GLStateManager.glGetInteger(GL21.GL_PIXEL_UNPACK_BUFFER_BINDING));
+            assertEquals(packBuffer, GLStateManager.glGetInteger(GL21.GL_PIXEL_PACK_BUFFER_BINDING));
+            assertEquals(1, GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT));
+            assertEquals(2, GL11.glGetInteger(GL11.GL_PACK_ALIGNMENT));
+            assertEquals(unpackBuffer, GL11.glGetInteger(GL21.GL_PIXEL_UNPACK_BUFFER_BINDING));
+            assertEquals(packBuffer, GL11.glGetInteger(GL21.GL_PIXEL_PACK_BUFFER_BINDING));
+        } finally {
+            drainClientAttribStack();
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+            GLStateManager.glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+            GLStateManager.glDeleteBuffers(unpackBuffer);
+            GLStateManager.glDeleteBuffers(packBuffer);
+        }
+    }
+
+    @Test
+    void pixelStoreWithReturnsSameInstanceForUnchangedValue() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        try {
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 9);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 11);
+            final PixelStoreState unpack = glCtx.pixelUnpackState;
+            final PixelStoreState pack = glCtx.pixelPackState;
+
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 9);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, unpack.alignment());
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_SWAP_BYTES, 0);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 11);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, pack.alignment());
+            GLStateManager.glPixelStorei(GL11.GL_PACK_LSB_FIRST, 0);
+
+            assertSame(unpack, glCtx.pixelUnpackState);
+            assertSame(pack, glCtx.pixelPackState);
+            assertSame(unpack, unpack.with(GL11.GL_UNPACK_ROW_LENGTH, 9));
+            assertSame(pack, pack.with(GL11.GL_PACK_ROW_LENGTH, 11));
+        } finally {
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 0);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ROW_LENGTH, 0);
+        }
+    }
+
+    @Test
+    void packAndUnpackRestoreToTheirOwnPriorValues() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        try {
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 2);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 8);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_SKIP_ROWS, 3);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_SKIP_ROWS, 5);
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_SKIP_ROWS, 6);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_SKIP_ROWS, 7);
+            assertEquals(1, glCtx.pixelUnpackState.alignment());
+            assertEquals(4, glCtx.pixelPackState.alignment());
+            assertEquals(6, glCtx.pixelUnpackState.skipRows());
+            assertEquals(7, glCtx.pixelPackState.skipRows());
+            assertEquals(6, GL11.glGetInteger(GL11.GL_UNPACK_SKIP_ROWS));
+            assertEquals(7, GL11.glGetInteger(GL11.GL_PACK_SKIP_ROWS));
+            GLStateManager.glPopClientAttrib();
+
+            assertEquals(2, glCtx.pixelUnpackState.alignment());
+            assertEquals(8, glCtx.pixelPackState.alignment());
+            assertEquals(3, glCtx.pixelUnpackState.skipRows());
+            assertEquals(5, glCtx.pixelPackState.skipRows());
+            assertEquals(2, GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT));
+            assertEquals(8, GL11.glGetInteger(GL11.GL_PACK_ALIGNMENT));
+            assertEquals(3, GL11.glGetInteger(GL11.GL_UNPACK_SKIP_ROWS));
+            assertEquals(5, GL11.glGetInteger(GL11.GL_PACK_SKIP_ROWS));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            drainClientAttribStack();
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_ALIGNMENT, 4);
+            GLStateManager.glPixelStorei(GL11.GL_UNPACK_SKIP_ROWS, 0);
+            GLStateManager.glPixelStorei(GL11.GL_PACK_SKIP_ROWS, 0);
+        }
+    }
+
+    @Test
+    void vertexArrayEnableRestoredOnlyWithVertexArrayBit() {
+        final int savedVao = GLStateManager.getBoundVAO();
+        final int vao = GLStateManager.glGenVertexArrays();
+        final IntBuffer enabled = BufferUtils.createIntBuffer(16);
+        final int position = Usage.POSITION.getAttributeLocation();
+        try {
+            GLStateManager.glBindVertexArray(vao);
+            drainErrors();
+            assertFalse(positionArrayEnabled());
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_VERTEX_ARRAY_BIT);
+            GLStateManager.glEnableClientState(GL11.GL_VERTEX_ARRAY);
+            assertTrue(positionArrayEnabled());
+            GLStateManager.glPopClientAttrib();
+            assertFalse(positionArrayEnabled());
+            GL20.glGetVertexAttrib(position, GL20.GL_VERTEX_ATTRIB_ARRAY_ENABLED, enabled);
+            assertEquals(GL11.GL_FALSE, enabled.get(0));
+
+            GLStateManager.glEnableClientState(GL11.GL_VERTEX_ARRAY);
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_VERTEX_ARRAY_BIT);
+            GLStateManager.glDisableClientState(GL11.GL_VERTEX_ARRAY);
+            GLStateManager.glPopClientAttrib();
+            assertTrue(positionArrayEnabled());
+            GL20.glGetVertexAttrib(position, GL20.GL_VERTEX_ATTRIB_ARRAY_ENABLED, enabled);
+            assertEquals(GL11.GL_TRUE, enabled.get(0));
+            GLStateManager.glDisableClientState(GL11.GL_VERTEX_ARRAY);
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            GLStateManager.glEnableClientState(GL11.GL_VERTEX_ARRAY);
+            GLStateManager.glPopClientAttrib();
+            assertTrue(positionArrayEnabled());
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            drainClientAttribStack();
+            GLStateManager.glDisableClientState(GL11.GL_VERTEX_ARRAY);
+            GLStateManager.glBindVertexArray(savedVao);
+            GLStateManager.glDeleteVertexArrays(vao);
+        }
+    }
+
+    @Test
+    void vertexArrayStateRestoredOnlyWithVertexArrayBit() {
+        final int savedVao = GLStateManager.getBoundVAO();
+        final int vao = GLStateManager.glGenVertexArrays();
+        try {
+            GLStateManager.glBindVertexArray(vao);
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE0);
+            final int flagsBefore = GLStateManager.ctx().vaos.getVertexFlags();
+            assertFalse(colorArrayEnabled());
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_VERTEX_ARRAY_BIT);
+            GLStateManager.glEnableClientState(GL11.GL_COLOR_ARRAY);
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE1);
+            assertTrue(colorArrayEnabled());
+            GLStateManager.glPopClientAttrib();
+            assertFalse(colorArrayEnabled());
+            assertEquals(flagsBefore, GLStateManager.ctx().vaos.getVertexFlags());
+            assertEquals(0, GLStateManager.getClientActiveTextureUnit());
+
+            GLStateManager.glPushClientAttrib(GL11.GL_CLIENT_PIXEL_STORE_BIT);
+            GLStateManager.glEnableClientState(GL11.GL_COLOR_ARRAY);
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE1);
+            GLStateManager.glPopClientAttrib();
+            assertTrue(colorArrayEnabled());
+            assertEquals(1, GLStateManager.getClientActiveTextureUnit());
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            drainClientAttribStack();
+            GLStateManager.glClientActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glDisableClientState(GL11.GL_COLOR_ARRAY);
+            GLStateManager.glBindVertexArray(savedVao);
+            GLStateManager.glDeleteVertexArrays(vao);
+        }
+    }
+
+    @Test
+    void intLightGettersConvertLikeMesa() {
+        final FloatBuffer savedDiffuse = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedPosition = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedDirection = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedCutoff = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedAttenuation = BufferUtils.createFloatBuffer(16);
+        GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, savedDiffuse);
+        GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_POSITION, savedPosition);
+        GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_SPOT_DIRECTION, savedDirection);
+        GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_SPOT_CUTOFF, savedCutoff);
+        GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_LINEAR_ATTENUATION, savedAttenuation);
+        final IntBuffer ints = BufferUtils.createIntBuffer(16);
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glPushMatrix();
+        try {
+            GLStateManager.glLoadIdentity();
+            final FloatBuffer values = BufferUtils.createFloatBuffer(4);
+            values.put(0, 0.25f).put(1, 0.5f).put(2, 1.0f).put(3, -0.5f);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, values);
+            values.put(0, 3.9f).put(1, -2.7f).put(2, 0.5f).put(3, 1.0f);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_POSITION, values);
+            values.put(0, 2.5f).put(1, -1.5f).put(2, -3.9f).put(3, 0.0f);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_SPOT_DIRECTION, values);
+            GLStateManager.glLightf(GL11.GL_LIGHT1, GL11.GL_SPOT_CUTOFF, 45.75f);
+            GLStateManager.glLightf(GL11.GL_LIGHT1, GL11.GL_LINEAR_ATTENUATION, 2.5f);
+            drainErrors();
+
+            ints.position(2);
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, ints);
+            assertEquals(2, ints.position());
+            assertEquals(536870911, ints.get(2));
+            assertEquals(1073741823, ints.get(3));
+            assertEquals(2147483647, ints.get(4));
+            assertEquals(-1073741823, ints.get(5));
+            ints.position(0);
+
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_POSITION, ints);
+            assertEquals(3, ints.get(0));
+            assertEquals(-2, ints.get(1));
+            assertEquals(0, ints.get(2));
+            assertEquals(1, ints.get(3));
+
+            ints.put(3, -777);
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_SPOT_DIRECTION, ints);
+            assertEquals(2, ints.get(0));
+            assertEquals(-1, ints.get(1));
+            assertEquals(-3, ints.get(2));
+            assertEquals(-777, ints.get(3));
+
+            ints.put(1, -777);
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_SPOT_CUTOFF, ints);
+            assertEquals(45, ints.get(0));
+            assertEquals(-777, ints.get(1));
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_LINEAR_ATTENUATION, ints);
+            assertEquals(2, ints.get(0));
+
+            ints.put(0, -777);
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_EMISSION, ints);
+            assertEquals(-777, ints.get(0));
+            GLStateManager.glGetLight(GL11.GL_LIGHT1, GL11.GL_SHININESS, ints);
+            assertEquals(-777, ints.get(0));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            GLStateManager.glLoadIdentity();
+            savedDiffuse.limit(4);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_DIFFUSE, savedDiffuse);
+            savedPosition.limit(4);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_POSITION, savedPosition);
+            savedDirection.limit(4);
+            GLStateManager.glLight(GL11.GL_LIGHT1, GL11.GL_SPOT_DIRECTION, savedDirection);
+            GLStateManager.glLightf(GL11.GL_LIGHT1, GL11.GL_SPOT_CUTOFF, savedCutoff.get(0));
+            GLStateManager.glLightf(GL11.GL_LIGHT1, GL11.GL_LINEAR_ATTENUATION, savedAttenuation.get(0));
+            GLStateManager.glPopMatrix();
+        }
+    }
+
+    @Test
+    void intMaterialGettersConvertLikeMesa() {
+        final FloatBuffer savedSpecular = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedShininess = BufferUtils.createFloatBuffer(16);
+        final FloatBuffer savedIndexes = BufferUtils.createFloatBuffer(16);
+        GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_SPECULAR, savedSpecular);
+        GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_SHININESS, savedShininess);
+        GLStateManager.glGetMaterial(GL11.GL_BACK, GL11.GL_COLOR_INDEXES, savedIndexes);
+        final IntBuffer ints = BufferUtils.createIntBuffer(16);
+        try {
+            final FloatBuffer values = BufferUtils.createFloatBuffer(4);
+            values.put(0, 0.5f).put(1, 0.75f).put(2, 1.0f).put(3, 0.0f);
+            GLStateManager.glMaterial(GL11.GL_FRONT, GL11.GL_SPECULAR, values);
+            GLStateManager.glMaterialf(GL11.GL_FRONT, GL11.GL_SHININESS, 12.6f);
+            values.put(0, 2.5f).put(1, -2.5f).put(2, 7.4f).put(3, 0.0f);
+            GLStateManager.glMaterial(GL11.GL_BACK, GL11.GL_COLOR_INDEXES, values);
+            drainErrors();
+
+            ints.position(1);
+            GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_SPECULAR, ints);
+            assertEquals(1, ints.position());
+            assertEquals(1073741823, ints.get(1));
+            assertEquals(1610612735, ints.get(2));
+            assertEquals(2147483647, ints.get(3));
+            assertEquals(0, ints.get(4));
+            ints.position(0);
+
+            ints.put(1, -777);
+            GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_SHININESS, ints);
+            assertEquals(13, ints.get(0));
+            assertEquals(-777, ints.get(1));
+
+            ints.put(3, -777);
+            GLStateManager.glGetMaterial(GL11.GL_BACK, GL11.GL_COLOR_INDEXES, ints);
+            assertEquals(3, ints.get(0));
+            assertEquals(-3, ints.get(1));
+            assertEquals(7, ints.get(2));
+            assertEquals(-777, ints.get(3));
+
+            ints.put(0, -777);
+            GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_POSITION, ints);
+            assertEquals(-777, ints.get(0));
+            GLStateManager.glGetMaterial(GL11.GL_FRONT, GL11.GL_SPOT_CUTOFF, ints);
+            assertEquals(-777, ints.get(0));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            savedSpecular.limit(4);
+            GLStateManager.glMaterial(GL11.GL_FRONT, GL11.GL_SPECULAR, savedSpecular);
+            GLStateManager.glMaterialf(GL11.GL_FRONT, GL11.GL_SHININESS, savedShininess.get(0));
+            savedIndexes.limit(4);
+            GLStateManager.glMaterial(GL11.GL_BACK, GL11.GL_COLOR_INDEXES, savedIndexes);
+        }
+    }
+
+    @Test
+    void currentTextureCoordsFollowActiveUnit() {
+        final FloatBuffer buf = BufferUtils.createFloatBuffer(16);
+        final float[][] saved = new float[4][4];
+        try {
+            for (int unit = 0; unit < 4; unit++) {
+                GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit);
+                GLStateManager.glGetFloat(GL11.GL_CURRENT_TEXTURE_COORDS, buf);
+                for (int i = 0; i < 4; i++) {
+                    saved[unit][i] = buf.get(i);
+                }
+            }
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE0, 0.25f, 0.5f);
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE1, 240.0f, 16.0f);
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE2, 0.75f, 0.125f);
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE3, 0.375f, 0.625f);
+            drainErrors();
+
+            final float[][] expected = { { 0.25f, 0.5f }, { 240.0f, 16.0f }, { 0.75f, 0.125f }, { 0.375f, 0.625f } };
+            for (int unit = 0; unit < 4; unit++) {
+                GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit);
+                GLStateManager.glGetFloat(GL11.GL_CURRENT_TEXTURE_COORDS, buf);
+                assertEquals(expected[unit][0], buf.get(0), "s of unit " + unit);
+                assertEquals(expected[unit][1], buf.get(1), "t of unit " + unit);
+                assertEquals(0.0f, buf.get(2), "r of unit " + unit);
+                assertEquals(1.0f, buf.get(3), "q of unit " + unit);
+            }
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            for (int unit = 0; unit < 4; unit++) {
+                GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE0 + unit, saved[unit][0], saved[unit][1]);
+            }
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        }
+    }
+
+    @Test
+    void currentTextureCoordsOfUntrackedUnitAreInitialValue() {
+        final FloatBuffer buf = BufferUtils.createFloatBuffer(16);
+        final int unit = GLStateManager.ctx().ffp.currentTexCoords.length + 1;
+        try {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE0, 0.25f, 0.5f);
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + unit);
+            drainErrors();
+            for (int i = 0; i < 4; i++) {
+                buf.put(i, -7.0f);
+            }
+            GLStateManager.glGetFloat(GL11.GL_CURRENT_TEXTURE_COORDS, buf);
+            assertEquals(0.0f, buf.get(0));
+            assertEquals(0.0f, buf.get(1));
+            assertEquals(0.0f, buf.get(2));
+            assertEquals(1.0f, buf.get(3));
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+            GLStateManager.glMultiTexCoord2f(GL13.GL_TEXTURE0, 0.0f, 0.0f);
+        }
+    }
+}
@@ -0,0 +1,75 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizons.angelica.glsm.testutil.TestThreads;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.Display;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.SharedDrawable;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@GLCoreTest
+public class GLSM_OffContextCreation_GLTest {
+
+    private SharedDrawable sharedDrawable;
+
+    @AfterEach
+    void cleanup() {
+        if (sharedDrawable != null) {
+            DrawableContexts.destroy(sharedDrawable);
+            sharedDrawable = null;
+        }
+    }
+
+    private static Map<String, Executable> creationCalls() {
+        final Map<String, Executable> calls = new LinkedHashMap<>();
+        calls.put("glGenTextures()", GLStateManager::glGenTextures);
+        calls.put("glGenTextures(IntBuffer)", () -> GLStateManager.glGenTextures(BufferUtils.createIntBuffer(1)));
+        calls.put("glGenSamplers()", GLStateManager::glGenSamplers);
+        calls.put("glGenSamplers(IntBuffer)", () -> GLStateManager.glGenSamplers(BufferUtils.createIntBuffer(1)));
+        calls.put("glGenSamplers(int[])", () -> GLStateManager.glGenSamplers(new int[1]));
+        calls.put("glGenBuffers()", GLStateManager::glGenBuffers);
+        calls.put("glGenBuffers(IntBuffer)", () -> GLStateManager.glGenBuffers(BufferUtils.createIntBuffer(1)));
+        calls.put("glGenBuffers(int[])", () -> GLStateManager.glGenBuffers(new int[1]));
+        calls.put("glCreateBuffers()", GLStateManager::glCreateBuffers);
+        calls.put("glCreateBuffers(IntBuffer)", () -> GLStateManager.glCreateBuffers(BufferUtils.createIntBuffer(1)));
+        calls.put("glCreateBuffers(int[])", () -> GLStateManager.glCreateBuffers(new int[1]));
+        calls.put("glGenVertexArrays()", GLStateManager::glGenVertexArrays);
+        calls.put("glGenFramebuffers()", GLStateManager::glGenFramebuffers);
+        calls.put("glGenRenderbuffers()", GLStateManager::glGenRenderbuffers);
+        calls.put("glGenQueries()", GLStateManager::glGenQueries);
+        calls.put("glGenQueries(IntBuffer)", () -> GLStateManager.glGenQueries(BufferUtils.createIntBuffer(1)));
+        calls.put("glCreateShader", () -> GLStateManager.glCreateShader(GL20.GL_VERTEX_SHADER));
+        calls.put("glCreateProgram", GLStateManager::glCreateProgram);
+        calls.put("RenderSystem.createTexture", () -> RenderSystem.createTexture(GL11.GL_TEXTURE_2D));
+        calls.put("RenderSystem.createFramebuffer", RenderSystem::createFramebuffer);
+        return calls;
+    }
+
+    @Test
+    void creationWithoutContextThrows() throws InterruptedException {
+        TestThreads.run("glsm-no-context", () -> {
+            for (Map.Entry<String, Executable> call : creationCalls().entrySet()) {
+                assertThrows(IllegalStateException.class, call.getValue(), call.getKey() + " did not throw off-context");
+            }
+        });
+    }
+
+    @Test
+    void creationOnSharedContextThreadPasses() throws Exception {
+        sharedDrawable = new SharedDrawable(Display.getDrawable());
+        DrawableContexts.run(sharedDrawable, "glsm-shared-context", () -> {
+            final int texture = GLStateManager.glGenTextures();
+            assertNotEquals(0, texture, "no texture name on a thread that owns a shared context");
+            GLStateManager.glDeleteTextures(texture);
+        });
+    }
+}
@@ -0,0 +1,256 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizons.angelica.glsm.stacks.RetainedState;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL14;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+public class GLSM_RetainedState_GLTest {
+
+    private static final StateSet ALL = StateSet.forMask(GL11.GL_ALL_ATTRIB_BITS);
+
+    private static int driverTextureBinding(int unit) {
+        final int saved = GL11.glGetInteger(GL13.GL_ACTIVE_TEXTURE);
+        GL13.glActiveTexture(GL13.GL_TEXTURE0 + unit);
+        final int binding = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
+        GL13.glActiveTexture(saved);
+        return binding;
+    }
+
+    private static void baseline() {
+        GLStateManager.enableCull();
+        GLStateManager.disableBlend();
+        GLStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+        GLStateManager.glDepthMask(true);
+        GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
+        GLStateManager.glAlphaFunc(GL11.GL_GREATER, 0.1F);
+        GLStateManager.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+    }
+
+    private static void mutate(int texture) {
+        GLStateManager.disableCull();
+        GLStateManager.enableBlend();
+        GLStateManager.tryBlendFuncSeparate(GL11.GL_DST_COLOR, GL11.GL_ZERO, GL11.GL_ONE, GL11.GL_ONE);
+        GLStateManager.glDepthMask(false);
+        GLStateManager.glDepthFunc(GL11.GL_ALWAYS);
+        GLStateManager.glAlphaFunc(GL11.GL_GEQUAL, 0.5F);
+        GLStateManager.glColor4f(0.25F, 0.5F, 0.75F, 0.5F);
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
+    }
+
+    private static void assertBaseline() {
+        assertTrue(GLStateManager.glIsEnabled(GL11.GL_CULL_FACE));
+        assertTrue(GL11.glIsEnabled(GL11.GL_CULL_FACE));
+        assertFalse(GLStateManager.glIsEnabled(GL11.GL_BLEND));
+        assertFalse(GL11.glIsEnabled(GL11.GL_BLEND));
+        assertEquals(GL11.GL_SRC_ALPHA, GL11.glGetInteger(GL14.GL_BLEND_SRC_RGB));
+        assertEquals(GL11.GL_ZERO, GL11.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
+        assertTrue(GL11.glGetBoolean(GL11.GL_DEPTH_WRITEMASK));
+        assertEquals(GL11.GL_LEQUAL, GL11.glGetInteger(GL11.GL_DEPTH_FUNC));
+        assertEquals(GL11.GL_GREATER, GLStateManager.glGetInteger(GL11.GL_ALPHA_TEST_FUNC));
+        assertEquals(1.0F, GLStateManager.getColor().getRed(), 0.0F);
+        assertEquals(0, driverTextureBinding(0));
+    }
+
+    private static void assertMutated(int texture) {
+        assertFalse(GLStateManager.glIsEnabled(GL11.GL_CULL_FACE));
+        assertFalse(GL11.glIsEnabled(GL11.GL_CULL_FACE));
+        assertTrue(GLStateManager.glIsEnabled(GL11.GL_BLEND));
+        assertTrue(GL11.glIsEnabled(GL11.GL_BLEND));
+        assertEquals(GL11.GL_DST_COLOR, GL11.glGetInteger(GL14.GL_BLEND_SRC_RGB));
+        assertEquals(GL11.GL_ZERO, GL11.glGetInteger(GL14.GL_BLEND_DST_RGB));
+        assertEquals(GL11.GL_ONE, GL11.glGetInteger(GL14.GL_BLEND_SRC_ALPHA));
+        assertEquals(GL11.GL_ONE, GL11.glGetInteger(GL14.GL_BLEND_DST_ALPHA));
+        assertEquals(GL11.GL_DST_COLOR, GLStateManager.glGetInteger(GL14.GL_BLEND_SRC_RGB));
+        assertFalse(GL11.glGetBoolean(GL11.GL_DEPTH_WRITEMASK));
+        assertEquals(GL11.GL_ALWAYS, GL11.glGetInteger(GL11.GL_DEPTH_FUNC));
+        assertEquals(GL11.GL_GEQUAL, GLStateManager.glGetInteger(GL11.GL_ALPHA_TEST_FUNC));
+        assertEquals(0.25F, GLStateManager.getColor().getRed(), 0.0F);
+        assertEquals(0.5F, GLStateManager.getColor().getAlpha(), 0.0F);
+        assertEquals(texture, driverTextureBinding(0));
+        assertEquals(texture, GLStateManager.getBoundTextureForServerState(0));
+    }
+
+    @Test
+    void retainedDeltaReappliesAfterPop() {
+        final int texture = GL11.glGenTextures();
+        final RetainedState retained = new RetainedState();
+        try {
+            baseline();
+            final int d = GLStateManager.pushState(ALL);
+            mutate(texture);
+            GLStateManager.retainModifiedState(d, retained);
+            GLStateManager.popStateTo(d);
+            assertBaseline();
+
+            GLStateManager.applyRetainedState(retained);
+            assertMutated(texture);
+
+            baseline();
+            assertBaseline();
+            GLStateManager.applyRetainedState(retained);
+            assertMutated(texture);
+        } finally {
+            baseline();
+            GL11.glDeleteTextures(texture);
+        }
+    }
+
+    @Test
+    void appliedDeltaIsRestoredByAnEnclosingPush() {
+        final int texture = GL11.glGenTextures();
+        final RetainedState retained = new RetainedState();
+        try {
+            baseline();
+            final int d = GLStateManager.pushState(ALL);
+            mutate(texture);
+            GLStateManager.retainModifiedState(d, retained);
+            GLStateManager.popStateTo(d);
+
+            final int outer = GLStateManager.pushState(ALL);
+            GLStateManager.applyRetainedState(retained);
+            assertMutated(texture);
+            GLStateManager.popStateTo(outer);
+            assertBaseline();
+        } finally {
+            baseline();
+            GL11.glDeleteTextures(texture);
+        }
+    }
+
+    @Test
+    void statesRestoredByANestedPushAreNotRetained() {
+        final RetainedState retained = new RetainedState();
+        try {
+            baseline();
+            final int d = GLStateManager.pushState(ALL);
+            GLStateManager.enableBlend();
+            final int nested = GLStateManager.pushState(ALL);
+            GLStateManager.disableCull();
+            GLStateManager.popStateTo(nested);
+            GLStateManager.retainModifiedState(d, retained);
+            GLStateManager.popStateTo(d);
+
+            GLStateManager.applyRetainedState(retained);
+            assertTrue(GL11.glIsEnabled(GL11.GL_BLEND));
+            assertTrue(GL11.glIsEnabled(GL11.GL_CULL_FACE));
+            assertTrue(GLStateManager.glIsEnabled(GL11.GL_CULL_FACE));
+        } finally {
+            baseline();
+        }
+    }
+
+    @Test
+    void onlyDifferingStateIsReissued() {
+        final int texture = GL11.glGenTextures();
+        final RetainedState retained = new RetainedState();
+        try {
+            baseline();
+            final int d = GLStateManager.pushState(ALL);
+            mutate(texture);
+            GLStateManager.retainModifiedState(d, retained);
+            GLStateManager.popStateTo(d);
+            GLStateManager.applyRetainedState(retained);
+
+            final GLContextState glCtx = GLStateManager.ctx();
+            final long backendCalls = GLStateManager.attribBackendCalls;
+            final int colorGen = glCtx.colorGeneration;
+            final int fragmentGen = glCtx.fragmentGeneration;
+            final int batchGen = glCtx.batchStateGeneration;
+            GLStateManager.applyRetainedState(retained);
+            assertEquals(backendCalls, GLStateManager.attribBackendCalls);
+            assertEquals(colorGen, glCtx.colorGeneration);
+            assertEquals(fragmentGen, glCtx.fragmentGeneration);
+            assertEquals(batchGen, glCtx.batchStateGeneration);
+
+            GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
+            GLStateManager.applyRetainedState(retained);
+            assertEquals(backendCalls + 3, GLStateManager.attribBackendCalls);
+            assertMutated(texture);
+        } finally {
+            baseline();
+            GL11.glDeleteTextures(texture);
+        }
+    }
+
+    @Test
+    void aSecondCaptureInvalidatesTheFirst() {
+        final RetainedState first = new RetainedState();
+        final RetainedState second = new RetainedState();
+        try {
+            baseline();
+            int d = GLStateManager.pushState(ALL);
+            GLStateManager.enableBlend();
+            GLStateManager.retainModifiedState(d, first);
+            GLStateManager.popStateTo(d);
+
+            d = GLStateManager.pushState(ALL);
+            GLStateManager.disableCull();
+            GLStateManager.retainModifiedState(d, second);
+            GLStateManager.popStateTo(d);
+
+            GLStateManager.applyRetainedState(first);
+            assertFalse(GL11.glIsEnabled(GL11.GL_BLEND));
+            assertTrue(GL11.glIsEnabled(GL11.GL_CULL_FACE));
+            GLStateManager.applyRetainedState(second);
+            assertFalse(GL11.glIsEnabled(GL11.GL_BLEND));
+            assertFalse(GL11.glIsEnabled(GL11.GL_CULL_FACE));
+        } finally {
+            baseline();
+        }
+    }
+
+    @Test
+    void writesInAnOuterPushAreNotRetained() {
+        final RetainedState retained = new RetainedState();
+        try {
+            baseline();
+            GLStateManager.glClearColor(0.25F, 0.5F, 0.75F, 1.0F);
+            final int outer = GLStateManager.pushState(ALL);
+            GLStateManager.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
+            final int inner = GLStateManager.pushState(ALL);
+            GLStateManager.enableBlend();
+            GLStateManager.retainModifiedState(inner, retained);
+            GLStateManager.popStateTo(outer);
+
+            GLStateManager.applyRetainedState(retained);
+            assertTrue(GL11.glIsEnabled(GL11.GL_BLEND));
+            assertEquals(0.25F, GLStateManager.getClearColor().getRed(), 0.0F);
+            assertEquals(1.0F, GLStateManager.getClearColor().getAlpha(), 0.0F);
+        } finally {
+            baseline();
+            GLStateManager.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
+        }
+    }
+
+    @Test
+    void aDeletedProgramIsNotRebound() {
+        final RetainedState retained = new RetainedState();
+        final int program = GLSM_StateSet_GLTest.linkTrivialProgram();
+        try {
+            baseline();
+            final int d = GLStateManager.pushState(ALL);
+            GLStateManager.glUseProgram(program);
+            GLStateManager.retainModifiedState(d, retained);
+            GLStateManager.popStateTo(d);
+            GLStateManager.glUseProgram(0);
+            GLStateManager.glDeleteProgram(program);
+            while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+
+            GLStateManager.applyRetainedState(retained);
+            assertEquals(0, GLStateManager.getActiveProgram());
+            assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+        } finally {
+            GLStateManager.glUseProgram(0);
+            baseline();
+        }
+    }
+}
@@ -45,7 +45,7 @@ public class GLSM_StateSet_GLTest {
    private static final String TRIVIAL_VS = "#version 330 core\nvoid main(){ gl_Position = vec4(0.0); }\n";
    private static final String TRIVIAL_FS = "#version 330 core\nout vec4 o;\nvoid main(){ o = vec4(1.0); }\n";

-    private static int linkTrivialProgram() {
+    static int linkTrivialProgram() {
        final int v = compileShader(GL20.GL_VERTEX_SHADER, TRIVIAL_VS);
        final int f = compileShader(GL20.GL_FRAGMENT_SHADER, TRIVIAL_FS);
        final int p = GL20.glCreateProgram();
@@ -89,33 +89,41 @@ public class GLSM_StateSet_GLTest {
    }

    @Test
-    void fontRestoresDepthAxisAndShadeModelButNotCull() {
+    void fontRestoresDepthAxisShadeModelAndPolygonOffsetButNotStencil() {
        try {
            GLStateManager.enableDepthTest();
            GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
            GLStateManager.glShadeModel(GL11.GL_SMOOTH);
-            GLStateManager.enableCull();
-            GLStateManager.glCullFace(GL11.GL_BACK);
+            GLStateManager.glDisable(GL11.GL_POLYGON_OFFSET_FILL);
+            GLStateManager.glPolygonOffset(0.0f, 0.0f);
+            GLStateManager.glEnable(GL11.GL_STENCIL_TEST);

            final int d = GLStateManager.pushState(StateSet.FONT);
            GLStateManager.disableDepthTest();
            GLStateManager.glDepthFunc(GL11.GL_ALWAYS);
            GLStateManager.glShadeModel(GL11.GL_FLAT);
-            GLStateManager.glCullFace(GL11.GL_FRONT);
+            GLStateManager.glEnable(GL11.GL_POLYGON_OFFSET_FILL);
+            GLStateManager.glPolygonOffset(-10.0f, -10.0f);
+            GLStateManager.glDisable(GL11.GL_STENCIL_TEST);
            GLStateManager.popStateTo(d);

            verifyIsEnabled(GL11.GL_DEPTH_TEST, true, "Depth test enable - restored by FONT pop");
            assertEquals(GL11.GL_LEQUAL, GLStateManager.getDepthState().getFunc(), "cache depth func");
            assertEquals(GL11.GL_LEQUAL, GL11.glGetInteger(GL11.GL_DEPTH_FUNC), "driver depth func");
            assertEquals(GL11.GL_SMOOTH, GLStateManager.getShadeModelState().getValue(), "cache shade model");
-            assertEquals(GL11.GL_FRONT, GLStateManager.getPolygonState().getCullFaceMode(), "cache cull face mode - not a FONT member, must stay toggled");
-            assertEquals(GL11.GL_FRONT, GL11.glGetInteger(GL11.GL_CULL_FACE_MODE), "driver cull face mode - not a FONT member, must stay toggled");
+            verifyIsEnabled(GL11.GL_POLYGON_OFFSET_FILL, false, "Polygon offset fill - restored by FONT pop");
+            assertEquals(0.0f, GLStateManager.getPolygonState().getOffsetFactor(), "cache polygon offset factor");
+            assertEquals(0.0f, GL11.glGetFloat(GL11.GL_POLYGON_OFFSET_FACTOR), "driver polygon offset factor");
+            assertEquals(0.0f, GLStateManager.getPolygonState().getOffsetUnits(), "cache polygon offset units");
+            assertEquals(0.0f, GL11.glGetFloat(GL11.GL_POLYGON_OFFSET_UNITS), "driver polygon offset units");
+            verifyIsEnabled(GL11.GL_STENCIL_TEST, false, "Stencil test - not a FONT member, must stay toggled");
        } finally {
            GLStateManager.disableDepthTest();
            GLStateManager.glDepthFunc(GL11.GL_LESS);
            GLStateManager.glShadeModel(GL11.GL_SMOOTH);
-            GLStateManager.disableCull();
-            GLStateManager.glCullFace(GL11.GL_BACK);
+            GLStateManager.glDisable(GL11.GL_POLYGON_OFFSET_FILL);
+            GLStateManager.glPolygonOffset(0.0f, 0.0f);
+            GLStateManager.glDisable(GL11.GL_STENCIL_TEST);
        }
    }

@@ -0,0 +1,65 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BackendStartGuardTest {
+
+    private static File marker(Path dir) {
+        return dir.resolve("angelica").resolve("sdlgpu-starting").toFile();
+    }
+
+    @Test
+    void firstStartCreatesTheMarkerAndFinishRemovesIt(@TempDir Path dir) {
+        final File marker = marker(dir);
+        assertFalse(BackendStartGuard.begin(marker, true, false));
+        assertFalse(BackendStartGuard.tripped());
+        assertTrue(marker.isFile());
+        BackendStartGuard.finish();
+        assertFalse(marker.exists());
+    }
+
+    @Test
+    void leftoverMarkerTripsOnceAndIsRemoved(@TempDir Path dir) {
+        final File marker = marker(dir);
+        assertFalse(BackendStartGuard.begin(marker, true, false));
+        assertTrue(BackendStartGuard.begin(marker, true, false));
+        assertTrue(BackendStartGuard.tripped());
+        assertFalse(marker.exists());
+        BackendStartGuard.finish();
+        assertFalse(marker.exists());
+        assertFalse(BackendStartGuard.begin(marker, true, false));
+        assertFalse(BackendStartGuard.tripped());
+        BackendStartGuard.finish();
+    }
+
+    @Test
+    void openGlConfigWritesNoMarkerAndClearsAStaleOne(@TempDir Path dir) throws IOException {
+        final File marker = marker(dir);
+        assertFalse(BackendStartGuard.begin(marker, false, false));
+        assertFalse(marker.exists());
+        assertTrue(marker.getParentFile().mkdirs());
+        assertTrue(marker.createNewFile());
+        assertFalse(BackendStartGuard.begin(marker, false, false));
+        assertFalse(BackendStartGuard.tripped());
+        assertFalse(marker.exists());
+    }
+
+    @Test
+    void forcedFlagNeverTripsOrWrites(@TempDir Path dir) throws IOException {
+        final File marker = marker(dir);
+        assertFalse(BackendStartGuard.begin(marker, true, true));
+        assertFalse(marker.exists());
+        assertTrue(marker.getParentFile().mkdirs());
+        assertTrue(marker.createNewFile());
+        assertFalse(BackendStartGuard.begin(marker, true, true));
+        assertFalse(BackendStartGuard.tripped());
+    }
+}
@@ -0,0 +1,77 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MoltenVKTest {
+
+    private static final String PRESENT_RESOURCE = "/com/gtnewhorizons/angelica/glsm/backend/MoltenVK.class";
+    private static final String ABSENT_RESOURCE = "/macos/arm64/org/lwjgl/vulkan/absent.dylib";
+
+    @Test
+    void detectOrderIsEnvThenJarThenSystem(@TempDir Path dir) throws IOException {
+        final String[] system = { Files.createFile(dir.resolve("system.dylib")).toString() };
+        final String[] none = { dir.resolve("missing.dylib").toString() };
+        assertEquals(MoltenVK.Source.NONE, MoltenVK.detect(false, "/env/lib.dylib", true, system));
+        assertEquals(MoltenVK.Source.ENV, MoltenVK.detect(true, "/env/lib.dylib", true, system));
+        assertEquals(MoltenVK.Source.JAR, MoltenVK.detect(true, "", true, system));
+        assertEquals(MoltenVK.Source.SYSTEM, MoltenVK.detect(true, null, false, system));
+        assertEquals(MoltenVK.Source.NONE, MoltenVK.detect(true, null, false, none));
+        assertEquals(1, dir.toFile().list().length);
+    }
+
+    @Test
+    void jarIsExtractedOnceAndNotRewritten(@TempDir Path dir) throws IOException {
+        final File out = dir.resolve("natives").toFile();
+        final String first = MoltenVK.resolve(MoltenVK.Source.JAR, null, PRESENT_RESOURCE, out, "arm64", new String[0]);
+        final File extracted = new File(out, "libMoltenVK-arm64.dylib");
+        assertEquals(extracted.getAbsolutePath(), first);
+        assertTrue(extracted.length() > 0);
+        assertTrue(extracted.setLastModified(1_000_000L));
+        assertEquals(first, MoltenVK.resolve(MoltenVK.Source.JAR, null, PRESENT_RESOURCE, out, "arm64", new String[0]));
+        assertEquals(1_000_000L, extracted.lastModified());
+        assertEquals(1, out.list().length);
+    }
+
+    @Test
+    void changedFileIsRewritten(@TempDir Path dir) throws IOException {
+        final File extracted = new File(dir.toFile(), "libMoltenVK-arm64.dylib");
+        Files.write(extracted.toPath(), new byte[] { 1, 2, 3 });
+        MoltenVK.resolve(MoltenVK.Source.JAR, null, PRESENT_RESOURCE, dir.toFile(), "arm64", new String[0]);
+        assertTrue(extracted.length() > 3);
+    }
+
+    @Test
+    void failedExtractionFallsBackToTheSystemInstall(@TempDir Path dir) throws IOException {
+        final Path system = Files.createFile(dir.resolve("system.dylib"));
+        final File notADirectory = Files.createFile(dir.resolve("blocker")).toFile();
+        assertEquals(system.toString(), MoltenVK.resolve(MoltenVK.Source.JAR, null, PRESENT_RESOURCE, notADirectory, "arm64", new String[] { system.toString() }));
+        assertNull(MoltenVK.resolve(MoltenVK.Source.JAR, null, ABSENT_RESOURCE, dir.toFile(), "arm64", new String[0]));
+    }
+
+    @Test
+    void envAndSystemAndNoneResolveWithoutExtracting(@TempDir Path dir) throws IOException {
+        final Path system = Files.createFile(dir.resolve("system.dylib"));
+        final File out = dir.resolve("natives").toFile();
+        assertEquals("/env/lib.dylib", MoltenVK.resolve(MoltenVK.Source.ENV, "/env/lib.dylib", PRESENT_RESOURCE, out, "arm64", new String[0]));
+        assertEquals(system.toString(), MoltenVK.resolve(MoltenVK.Source.SYSTEM, null, PRESENT_RESOURCE, out, "arm64", new String[] { system.toString() }));
+        assertNull(MoltenVK.resolve(MoltenVK.Source.NONE, null, PRESENT_RESOURCE, out, "arm64", new String[] { system.toString() }));
+        assertFalse(out.exists());
+    }
+
+    @Test
+    void archNames() {
+        assertEquals("arm64", MoltenVK.archName("aarch64"));
+        assertEquals("x64", MoltenVK.archName("x86_64"));
+    }
+}
@@ -0,0 +1,114 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import com.gtnewhorizons.angelica.glsm.GLCoreTest;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+
+import java.nio.FloatBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+@GLCoreTest
+class WideLineClipGLTest {
+
+    private static final int SIZE = 64;
+    private static final double NEAR = 0.05;
+    private static final float LINE_WIDTH = 3.0f;
+    private static final int BACKGROUND = 0xFF000000;
+
+    private static final float[] IN_FRONT = { 0f, -1f, -2f };
+    private static final float[] BEHIND = { 0f, 0.8f, 2f };
+
+    private boolean savedEmulation;
+    private int vao;
+    private int vbo;
+
+    @BeforeEach
+    void setUp() {
+        assumeTrue(GLStateManager.supportsGeometryShaders());
+        savedEmulation = GLStateManager.wideLineEmulationEnabled;
+        GLStateManager.wideLineEmulationEnabled = true;
+
+        FfpFixture.resetFfpState();
+        ShaderManager.enable();
+        ShaderManager.getInstance().activate();
+        GLStateManager.glViewport(0, 0, SIZE, SIZE);
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glFrustum(-NEAR, NEAR, -NEAR, NEAR, NEAR, 100.0);
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glDisable(GL11.GL_DEPTH_TEST);
+        GLStateManager.glLineWidth(LINE_WIDTH);
+    }
+
+    @AfterEach
+    void tearDown() {
+        GLStateManager.wideLineEmulationEnabled = savedEmulation;
+        GLStateManager.glLineWidth(1.0f);
+        if (vbo != 0) { GLStateManager.glDeleteBuffers(vbo); vbo = 0; }
+        if (vao != 0) { GLStateManager.glDeleteVertexArrays(vao); vao = 0; }
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        FfpFixture.resetFfpState();
+        while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+    }
+
+    @Test
+    void lineEndingBehindTheCameraKeepsItsWidth() {
+        assertConstantWidth(IN_FRONT, BEHIND);
+    }
+
+    @Test
+    void lineStartingBehindTheCameraKeepsItsWidth() {
+        assertConstantWidth(BEHIND, IN_FRONT);
+    }
+
+    @Test
+    void lineFullyBehindTheCameraDrawsNothing() {
+        final int[] pixels = drawLine(new float[] { 0f, -1f, 2f }, BEHIND);
+        for (int px : pixels) {
+            assertEquals(BACKGROUND, px);
+        }
+    }
+
+    private void assertConstantWidth(float[] start, float[] end) {
+        final int[] pixels = drawLine(start, end);
+        for (int row = 0; row < SIZE / 4; row++) {
+            int lit = 0;
+            for (int x = 0; x < SIZE; x++) {
+                if (pixels[row * SIZE + x] != BACKGROUND) lit++;
+            }
+            final int y = row, count = lit;
+            assertTrue(count > 0 && count <= LINE_WIDTH + 1, () -> "row " + y + " is " + count + " pixels wide");
+        }
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError());
+    }
+
+    private int[] drawLine(float[] start, float[] end) {
+        vao = GLStateManager.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(vao);
+        vbo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        final FloatBuffer positions = BufferUtils.createFloatBuffer(6);
+        positions.put(start).put(end).flip();
+        GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, positions, GL15.GL_STATIC_DRAW);
+        FfpFixture.attrib(0, 3, GL11.GL_FLOAT, false, 12, 0);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        VAOManager.setCurrentVertexFlags(0);
+
+        FfpFixture.clear();
+        GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        GLStateManager.glDrawArrays(GL11.GL_LINES, 0, 2);
+        GLStateManager.glBindVertexArray(0);
+        return FfpFixture.readRegion(SIZE);
+    }
+}
@@ -252,6 +252,32 @@ class GLSMRedirectorTest {
        assertTrue(unmappedSeen().isEmpty());
    }

+    @Test
+    void arbGenerateMipmapAliasIsRedirected() {
+        final ClassNode cn = makeClassWithMethodCall("org/lwjgl/opengl/ARBFramebufferObject", "glGenerateMipmap", "(I)V");
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertTrue(changed);
+        assertEquals(GLSM, firstCall(cn).owner);
+        assertEquals("glGenerateMipmap", firstCall(cn).name);
+        assertEquals("(I)V", firstCall(cn).desc);
+        assertTrue(unmappedSeen().isEmpty());
+    }
+
+    @Test
+    void extGenerateMipmapAliasIsRedirected() {
+        final ClassNode cn = makeClassWithMethodCall("org/lwjgl/opengl/EXTFramebufferObject", "glGenerateMipmapEXT", "(I)V");
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertTrue(changed);
+        assertEquals(GLSM, firstCall(cn).owner);
+        assertEquals("glGenerateMipmap", firstCall(cn).name);
+        assertEquals("(I)V", firstCall(cn).desc);
+        assertTrue(unmappedSeen().isEmpty());
+    }
+
    @Test
    void newlyMappedReadPixelsIsRedirected() {
        final ClassNode cn = makeClassWithMethodCall("org/lwjgl/opengl/GL11", "glReadPixels", "(IIIIIILjava/nio/IntBuffer;)V");
@@ -10,6 +10,7 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Stream;

 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
@@ -122,4 +123,27 @@ class ShaderDiskCacheTest {
        ShaderDiskCache.put(ShaderDiskCache.key("t").i(9), new byte[] {5});
        assertArrayEquals(new byte[] {5}, ShaderDiskCache.get(ShaderDiskCache.key("t").i(9)));
    }
+
+    @Test
+    void retainLayerKeepsListedEntriesOtherLayersAndInFlightWrites() throws IOException {
+        ShaderDiskCache.configure(dir, "a");
+        final ShaderDiskCache.Key kept = ShaderDiskCache.key("p").str("kept");
+        final ShaderDiskCache.Key dropped = ShaderDiskCache.key("p").str("dropped");
+        final ShaderDiskCache.Key otherLayer = ShaderDiskCache.key("q").str("dropped");
+        ShaderDiskCache.put(kept, new byte[] {1});
+        ShaderDiskCache.put(dropped, new byte[] {2});
+        ShaderDiskCache.put(otherLayer, new byte[] {3});
+        final Path inFlight = dir.resolve("p").resolve(dropped.hex() + ".7.tmp");
+        Files.write(inFlight, new byte[] {4});
+
+        ShaderDiskCache.retainLayer("p", Set.of(kept.hex()));
+        assertArrayEquals(new byte[] {1}, ShaderDiskCache.get(kept));
+        assertNull(ShaderDiskCache.get(dropped));
+        assertArrayEquals(new byte[] {3}, ShaderDiskCache.get(otherLayer));
+        assertTrue(Files.exists(inFlight));
+
+        ShaderDiskCache.retainLayer("p", null);
+        assertNull(ShaderDiskCache.get(kept));
+        assertArrayEquals(new byte[] {3}, ShaderDiskCache.get(otherLayer));
+    }
 }
@@ -0,0 +1,115 @@
+package com.gtnewhorizons.angelica.glsm.states;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class PixelStoreStateTest {
+
+    @Test
+    void defaults() {
+        assertTrue(PixelStoreState.DEFAULT.isDefault());
+        assertEquals(4, PixelStoreState.DEFAULT.alignment());
+        assertEquals(0, PixelStoreState.DEFAULT.rowLength());
+        assertFalse(PixelStoreState.DEFAULT.swapBytes());
+        assertFalse(PixelStoreState.DEFAULT.lsbFirst());
+    }
+
+    @Test
+    void withUpdatesUnpackParams() {
+        PixelStoreState s = PixelStoreState.DEFAULT
+            .with(GL11.GL_UNPACK_ALIGNMENT, 1)
+            .with(GL11.GL_UNPACK_ROW_LENGTH, 64)
+            .with(GL11.GL_UNPACK_SKIP_ROWS, 2)
+            .with(GL11.GL_UNPACK_SKIP_PIXELS, 3)
+            .with(GL12.GL_UNPACK_IMAGE_HEIGHT, 32)
+            .with(GL12.GL_UNPACK_SKIP_IMAGES, 1)
+            .with(GL11.GL_UNPACK_SWAP_BYTES, 1)
+            .with(GL11.GL_UNPACK_LSB_FIRST, 1);
+        assertEquals(new PixelStoreState(1, 64, 2, 3, 32, 1, true, true), s);
+        assertFalse(s.isDefault());
+    }
+
+    @Test
+    void invalidValuesIgnored() {
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 3));
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 0));
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_ROW_LENGTH, -1));
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_SKIP_ROWS, -5));
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL12.GL_UNPACK_IMAGE_HEIGHT, -1));
+    }
+
+    @Test
+    void booleansAcceptAnyNonzero() {
+        assertTrue(PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 2).swapBytes());
+        assertTrue(PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_LSB_FIRST, -1).lsbFirst());
+        PixelStoreState on = PixelStoreState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 1);
+        assertFalse(on.with(GL11.GL_UNPACK_SWAP_BYTES, 0).swapBytes());
+    }
+
+    @Test
+    void packPnamesSetTheSameFields() {
+        PixelStoreState s = PixelStoreState.DEFAULT
+            .with(GL11.GL_PACK_ALIGNMENT, 1)
+            .with(GL11.GL_PACK_ROW_LENGTH, 64)
+            .with(GL11.GL_PACK_SKIP_ROWS, 2)
+            .with(GL11.GL_PACK_SKIP_PIXELS, 3)
+            .with(GL12.GL_PACK_IMAGE_HEIGHT, 32)
+            .with(GL12.GL_PACK_SKIP_IMAGES, 1)
+            .with(GL11.GL_PACK_SWAP_BYTES, 1)
+            .with(GL11.GL_PACK_LSB_FIRST, 1);
+        assertEquals(new PixelStoreState(1, 64, 2, 3, 32, 1, true, true), s);
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_PACK_ALIGNMENT, 3));
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(GL11.GL_PACK_ROW_LENGTH, -1));
+    }
+
+    @Test
+    void unknownPnamesIgnored() {
+        assertSame(PixelStoreState.DEFAULT, PixelStoreState.DEFAULT.with(0x1234, 1));
+    }
+
+    @Test
+    void unchangedValueReturnsSameInstance() {
+        final PixelStoreState s = new PixelStoreState(1, 64, 2, 3, 32, 1, true, true);
+        assertSame(s, s.with(GL11.GL_UNPACK_ALIGNMENT, 1));
+        assertSame(s, s.with(GL11.GL_PACK_ALIGNMENT, 1));
+        assertSame(s, s.with(GL11.GL_UNPACK_ROW_LENGTH, 64));
+        assertSame(s, s.with(GL11.GL_PACK_ROW_LENGTH, 64));
+        assertSame(s, s.with(GL11.GL_UNPACK_SKIP_ROWS, 2));
+        assertSame(s, s.with(GL11.GL_PACK_SKIP_ROWS, 2));
+        assertSame(s, s.with(GL11.GL_UNPACK_SKIP_PIXELS, 3));
+        assertSame(s, s.with(GL11.GL_PACK_SKIP_PIXELS, 3));
+        assertSame(s, s.with(GL12.GL_UNPACK_IMAGE_HEIGHT, 32));
+        assertSame(s, s.with(GL12.GL_PACK_IMAGE_HEIGHT, 32));
+        assertSame(s, s.with(GL12.GL_UNPACK_SKIP_IMAGES, 1));
+        assertSame(s, s.with(GL12.GL_PACK_SKIP_IMAGES, 1));
+        assertSame(s, s.with(GL11.GL_UNPACK_SWAP_BYTES, 5));
+        assertSame(s, s.with(GL11.GL_PACK_SWAP_BYTES, 5));
+        assertSame(s, s.with(GL11.GL_UNPACK_LSB_FIRST, 1));
+        assertSame(s, s.with(GL11.GL_PACK_LSB_FIRST, 1));
+    }
+
+    @Test
+    void isPackSeparatesTheFamilies() {
+        final int[] pack = {
+            GL11.GL_PACK_ALIGNMENT, GL11.GL_PACK_ROW_LENGTH, GL11.GL_PACK_SKIP_ROWS, GL11.GL_PACK_SKIP_PIXELS,
+            GL12.GL_PACK_IMAGE_HEIGHT, GL12.GL_PACK_SKIP_IMAGES, GL11.GL_PACK_SWAP_BYTES, GL11.GL_PACK_LSB_FIRST,
+        };
+        final int[] unpack = {
+            GL11.GL_UNPACK_ALIGNMENT, GL11.GL_UNPACK_ROW_LENGTH, GL11.GL_UNPACK_SKIP_ROWS, GL11.GL_UNPACK_SKIP_PIXELS,
+            GL12.GL_UNPACK_IMAGE_HEIGHT, GL12.GL_UNPACK_SKIP_IMAGES, GL11.GL_UNPACK_SWAP_BYTES, GL11.GL_UNPACK_LSB_FIRST,
+        };
+        for (final int pname : pack) {
+            assertTrue(PixelStoreState.isPack(pname));
+        }
+        for (final int pname : unpack) {
+            assertFalse(PixelStoreState.isPack(pname));
+        }
+        assertFalse(PixelStoreState.isPack(0x1234));
+    }
+}
@@ -1,61 +0,0 @@
-package com.gtnewhorizons.angelica.glsm.states;
-
-import org.junit.jupiter.api.Test;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertSame;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class PixelUnpackStateTest {
-
-    @Test
-    void defaults() {
-        assertTrue(PixelUnpackState.DEFAULT.isDefault());
-        assertEquals(4, PixelUnpackState.DEFAULT.alignment());
-        assertEquals(0, PixelUnpackState.DEFAULT.rowLength());
-        assertFalse(PixelUnpackState.DEFAULT.swapBytes());
-        assertFalse(PixelUnpackState.DEFAULT.lsbFirst());
-    }
-
-    @Test
-    void withUpdatesUnpackParams() {
-        PixelUnpackState s = PixelUnpackState.DEFAULT
-            .with(GL11.GL_UNPACK_ALIGNMENT, 1)
-            .with(GL11.GL_UNPACK_ROW_LENGTH, 64)
-            .with(GL11.GL_UNPACK_SKIP_ROWS, 2)
-            .with(GL11.GL_UNPACK_SKIP_PIXELS, 3)
-            .with(GL12.GL_UNPACK_IMAGE_HEIGHT, 32)
-            .with(GL12.GL_UNPACK_SKIP_IMAGES, 1)
-            .with(GL11.GL_UNPACK_SWAP_BYTES, 1)
-            .with(GL11.GL_UNPACK_LSB_FIRST, 1);
-        assertEquals(new PixelUnpackState(1, 64, 2, 3, 32, 1, true, true), s);
-        assertFalse(s.isDefault());
-    }
-
-    @Test
-    void invalidValuesIgnored() {
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 3));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 0));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ROW_LENGTH, -1));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SKIP_ROWS, -5));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL12.GL_UNPACK_IMAGE_HEIGHT, -1));
-    }
-
-    @Test
-    void booleansAcceptAnyNonzero() {
-        assertTrue(PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 2).swapBytes());
-        assertTrue(PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_LSB_FIRST, -1).lsbFirst());
-        PixelUnpackState on = PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 1);
-        assertFalse(on.with(GL11.GL_UNPACK_SWAP_BYTES, 0).swapBytes());
-    }
-
-    @Test
-    void packAndUnknownPnamesIgnored() {
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_PACK_ALIGNMENT, 1));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_PACK_ROW_LENGTH, 16));
-        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(0x1234, 1));
-    }
-}
@@ -2,6 +2,9 @@
 # LOCAL to test local config updates.
 gtnh.settings.blowdryerTag = 0.2.2

+# See mod-version-gradle.kts
+gtnh.modules.gitVersion = false
+
 # Human-readable mod name, available for mcmod.info population.
 modName = Angelica

@@ -8,6 +8,8 @@ launchwrapper = "1.12"
 # End Frozen

 lwjgl3 = "3.4.2-SNAPSHOT"
+# Must equal the LWJGL release shipped by lwjgl3ify. Do not bump without bumping lwjgl3ify.
+lwjgl3Release = "3.4.2"
 lwjgl3ify = "3.0.31"

 celeritas = "2.5.12-GTNH"
@@ -75,6 +77,7 @@ lwjgl3-opengl = { module = "org.lwjgl:lwjgl-opengl", version.ref = "lwjgl3" }
 lwjgl3-sdl = { module = "org.lwjgl:lwjgl-sdl", version.ref = "lwjgl3" }
 lwjgl3-spvc = { module = "org.lwjgl:lwjgl-spvc", version.ref = "lwjgl3" }
 lwjgl3-shaderc = { module = "org.lwjgl:lwjgl-shaderc", version.ref = "lwjgl3" }
+lwjgl3-vulkan = { module = "org.lwjgl:lwjgl-vulkan", version.ref = "lwjgl3Release" }

 # Consumed with an explicit :dev / :universal / :downgraded-8 classifier at the call site.
 gtnhlib = { module = "com.github.GTNewHorizons:GTNHLib", version.ref = "gtnhlib" }
@@ -0,0 +1,37 @@
+// Replaces GTNHGradle's GitVersionModule (gtnh.modules.gitVersion = false): same version format, but only
+// x.y.z[-suffix] tags count, so additional tags (moltenvk-v*, tracy-v*) on master never become the mod version.
+
+fun git(vararg args: String): String? = try {
+    val exec = providers.exec {
+        commandLine("git", *args)
+        workingDir = rootDir
+        isIgnoreExitValue = true
+    }
+    if (exec.result.get().exitValue == 0) exec.standardOutput.asText.get().trim() else null
+} catch (e: Exception) {
+    null
+}
+
+fun gitVersion(): String {
+    val described = git("describe", "--tags", "--long", "--first-parent", "--abbrev=7", "--match=[0-9]*.[0-9]*.[0-9]*", "HEAD")
+    val match = described?.let { Regex("(.*)-([0-9]+)-g[0-9a-f]+").matchEntire(it) }
+    val tag = match?.groupValues?.get(1)
+    val distance = match?.groupValues?.get(2)?.toInt() ?: 0
+    val hash = git("rev-parse", "HEAD")?.take(10)?.ifEmpty { null }
+    val base = tag ?: hash
+    if (base == null) {
+        logger.error("No git repository found; set the VERSION environment variable to version this build.")
+        return "NO-GIT-TAG-SET"
+    }
+    val dirty = !git("status", "--porcelain").isNullOrEmpty()
+    val branch = (git("branch", "--show-current")?.ifEmpty { null } ?: System.getenv("GIT_BRANCH") ?: "git")
+        .removePrefix("origin/")
+        .replace(Regex("[^a-zA-Z0-9-]+"), "-")
+    return when {
+        distance > 0 -> "$base-$branch.$distance+$hash${if (dirty) "-dirty" else ""}"
+        dirty -> "$base-$branch+$hash-dirty"
+        else -> base
+    }
+}
+
+extra["modVersion"] = providers.environmentVariable("VERSION").orNull ?: gitVersion()
@@ -28,6 +28,7 @@ import org.lwjgl.opengl.GL31C;
 import org.lwjgl.opengl.GL32C;
 import org.lwjgl.opengl.GL33C;
 import org.lwjgl.opengl.GL40C;
+import org.lwjgl.opengl.GL41C;
 import org.lwjgl.opengl.GL42C;
 import org.lwjgl.opengl.GL43C;
 import org.lwjgl.opengl.GL44C;
@@ -965,6 +966,27 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
        return GL20C.glIsProgram(obj);
    }

+    @Override
+    public boolean supportsProgramBinary() {
+        return !RenderSystem.isGLES() && (caps.OpenGL41 || caps.GL_ARB_get_program_binary)
+            && GL11C.glGetInteger(GL41C.GL_NUM_PROGRAM_BINARY_FORMATS) > 0;
+    }
+
+    @Override
+    public void programParameteri(int program, int pname, int value) {
+        GL41C.glProgramParameteri(program, pname, value);
+    }
+
+    @Override
+    public void getProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {
+        GL41C.glGetProgramBinary(program, length, binaryFormat, binary);
+    }
+
+    @Override
+    public void programBinary(int program, int binaryFormat, ByteBuffer binary) {
+        GL41C.glProgramBinary(program, binaryFormat, binary);
+    }
+
    @Override
    public void validateProgram(int program) {
        GL20C.glValidateProgram(program);
@@ -0,0 +1,112 @@
+plugins {
+    `java-library`
+    `maven-publish`
+}
+
+version = rootProject.version
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.release.set(8)
+}
+
+val rfgObfAttr = Attribute.of("com.gtnewhorizons.retrofuturagradle.obfuscation", String::class.java)
+val rfgTransformedAttr = Attribute.of("rfgDeobfuscatorTransformed", Boolean::class.javaObjectType)
+
+configurations {
+    listOf("apiElements", "runtimeElements").forEach { name ->
+        named(name) {
+            attributes {
+                attribute(rfgObfAttr, "mcp")
+                attribute(rfgTransformedAttr, true)
+            }
+        }
+    }
+}
+
+val moltenvkVersion = (findProperty("moltenvkVersion") as String?) ?: libs.versions.lwjgl3Release.get()
+
+repositories {
+    maven {
+        name = "Forge"
+        url = uri("https://maven.minecraftforge.net/")
+    }
+    maven {
+        name = "Forge artifact-only"
+        url = uri("https://maven.minecraftforge.net/")
+        metadataSources { artifact() }
+        content { includeModule("net.minecraftforge", "forge") }
+    }
+    mavenCentral()
+}
+
+val moltenvkNatives by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+}
+
+dependencies {
+    compileOnly("net.minecraftforge:forge:1.7.10-10.13.4.1614-1.7.10:universal") { isTransitive = false }
+
+    listOf("natives-macos", "natives-macos-arm64").forEach { nativesClassifier ->
+        moltenvkNatives(libs.lwjgl3.vulkan) {
+            artifact { classifier = nativesClassifier }
+            isTransitive = false
+        }
+    }
+}
+
+val extractMoltenVK = tasks.register<Sync>("extractMoltenVK") {
+    val outDir = layout.buildDirectory.dir("generated/resources/moltenvk")
+    from(provider { moltenvkNatives.files.map { zipTree(it) } }) {
+        include("macos/**/libMoltenVK.dylib")
+    }
+    includeEmptyDirs = false
+    into(outDir)
+    doLast {
+        listOf("macos/x64", "macos/arm64").forEach { dir ->
+            val rel = "$dir/org/lwjgl/vulkan/libMoltenVK.dylib"
+            if (!outDir.get().file(rel).asFile.isFile) {
+                throw GradleException("MoltenVK dylib missing after extraction: $rel")
+            }
+        }
+    }
+}
+sourceSets["main"].resources.srcDir(extractMoltenVK)
+
+val distJar = tasks.register<Jar>("distJar") {
+    archiveBaseName.set("angelica-moltenvk")
+    archiveVersion.set(moltenvkVersion)
+    from(sourceSets["main"].output)
+    manifest {
+        attributes(
+            "FMLCorePlugin" to "com.gtnewhorizons.angelica.moltenvk.loading.MoltenVKCorePlugin"
+        )
+    }
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            groupId = "com.gtnewhorizons.angelica"
+            artifactId = "angelica-moltenvk"
+            version = moltenvkVersion
+            artifact(distJar)
+        }
+    }
+    repositories {
+        if (hasProperty("publishMoltenVK") && System.getenv("MAVEN_USER") != null) {
+            maven {
+                name = "GTNHMaven"
+                url = uri(rootProject.findProperty("mavenPublishUrl")?.toString() ?: "https://nexus.gtnewhorizons.com/repository/releases/")
+                credentials {
+                    username = System.getenv("MAVEN_USER")
+                    password = System.getenv("MAVEN_PASSWORD")
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,32 @@
+package com.gtnewhorizons.angelica.moltenvk.loading;
+
+import cpw.mods.fml.relauncher.IFMLLoadingPlugin;
+
+import java.util.Map;
+
+@IFMLLoadingPlugin.MCVersion("1.7.10")
+public class MoltenVKCorePlugin implements IFMLLoadingPlugin {
+
+    @Override
+    public String[] getASMTransformerClass() {
+        return null;
+    }
+
+    @Override
+    public String getModContainerClass() {
+        return null;
+    }
+
+    @Override
+    public String getSetupClass() {
+        return null;
+    }
+
+    @Override
+    public void injectData(Map<String, Object> data) {}
+
+    @Override
+    public String getAccessTransformerClass() {
+        return null;
+    }
+}
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -9,6 +9,7 @@
 #   route  - straight | pan | circuit | static
 #   length - Units: blocks (straight), blocks per leg (circuit), degrees (pan), ticks (static).
 #   extra  - passed through to gradle; -Dangelica.* reaches the client (e.g. -Dangelica.flyby.timeOfDay=1500).
+#            -Dangelica.flyby.camera=FIRST_PERSON|THIRD_PERSON_BACK|THIRD_PERSON_FRONT (default FIRST_PERSON).
 #
 #   FLYBY_SPEED     - blocks per tick. (0.5 ~= creative flight).
 #   FLYBY_PACING    - UNCAPPED | CONFIGURED. Passed through when set.
@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.sdlgpu;

 import static org.lwjgl.sdl.SDLVideo.SDL_PROP_WINDOW_CREATE_METAL_BOOLEAN;

-import com.gtnewhorizons.angelica.config.SystemProperties;
+import com.gtnewhorizons.angelica.glsm.backend.BackendOptions;
 import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
 import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
 import com.gtnewhorizons.angelica.glsm.loading.DependencyVerifier;
@@ -83,7 +83,7 @@ public final class SDLGPUGate {

    private static synchronized boolean probe() {
        if (deviceReady != null) return deviceReady;
-        if (!SystemProperties.USE_SDL_GPU || !isSDLGPUAvailable()) {
+        if (!BackendOptions.sdlGpuRequested() || !isSDLGPUAvailable()) {
            deviceReady = false;
            return false;
        }
@@ -7,6 +7,7 @@ import com.gtnewhorizons.angelica.glsm.CaptureGate;
 import com.gtnewhorizons.angelica.glsm.GLContextState;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
+import com.gtnewhorizons.angelica.glsm.backend.BackendOptions;
 import com.gtnewhorizons.angelica.glsm.backend.GLDebugMessageListener;
 import com.gtnewhorizons.angelica.glsm.backend.MainThreadPump;
 import me.eigenraven.lwjgl3ify.client.MainThreadExec;
@@ -40,6 +41,7 @@ import com.gtnewhorizons.angelica.sdlgpu.resource.FBOClearTracker;
 import com.gtnewhorizons.angelica.sdlgpu.resource.FboState;
 import com.gtnewhorizons.angelica.sdlgpu.resource.FormatMap;
 import com.gtnewhorizons.angelica.sdlgpu.resource.Image3DClear;
+import com.gtnewhorizons.angelica.sdlgpu.resource.MappedRange;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PersistentBufferSync;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PackState;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PersistentMapping;
@@ -63,6 +65,7 @@ import com.gtnewhorizons.angelica.sdlgpu.util.ThreadRegistry;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import it.unimi.dsi.fastutil.longs.LongArrayFIFOQueue;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;

 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -167,6 +170,7 @@ public class SDLGPURenderBackend extends RenderBackend {
    private final FFPTrace ffpTrace = SystemProperties.FFP_TRACE ? new FFPTrace(resourceManager) : null;

    private final IntOpenHashSet missingProgramWarned = new IntOpenHashSet();
+    private final LongOpenHashSet warnedBufferOps = new LongOpenHashSet();

    private boolean droppedCopyWarned;
    private boolean droppedSsboWriteWarned;
@@ -247,7 +251,9 @@ public class SDLGPURenderBackend extends RenderBackend {


    @Override public void onPersistentBufferWrite(int glId, long offset, long size) {
-        persistentSync.onPersistentBufferWrite(glId, offset, size);
+        if (!persistentSync.onPersistentBufferWrite(glId, offset, size)) {
+            warnInvalidBufferOp("persistent write out of range", glId);
+        }
    }

    @Override public void onPostWindowCreate(long window) {
@@ -514,14 +520,13 @@ public class SDLGPURenderBackend extends RenderBackend {
            st.appliedLogicOpKey = 0;
            st.fragSamplerBindings.free();
            st.vertSamplerBindings.free();
-            if (st.mappedStagingBuffer != null) {
-                MemoryUtil.memFree(st.mappedStagingBuffer);
-            }
-            clearMappedState(st);
        }
        registeredStates.clear();

        drawDispatch.clearWarnedState();
+        synchronized (warnedBufferOps) {
+            warnedBufferOps.clear();
+        }
        attachmentClear.shutdown();
        depthStencilReadback.shutdown();
        textureOps.shutdown();
@@ -532,7 +537,7 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public boolean isAvailable() {
-        return SystemProperties.USE_SDL_GPU && SDLGPUGate.isSDLGPUAvailable() && SDLGPUGate.isEngaged();
+        return BackendOptions.sdlGpuRequested() && SDLGPUGate.isSDLGPUAvailable() && SDLGPUGate.isEngaged();
    }

    @Override public String getName() {
@@ -543,6 +548,10 @@ public class SDLGPURenderBackend extends RenderBackend {
        return device.getDevice() != 0;
    }

+    @Override public boolean hasContextOnThread() {
+        return hasContext() && (Thread.currentThread() == GLStateManager.getMainThread() || tlState.get() != null);
+    }
+
    @Override public boolean isCurrent() {
        return Thread.currentThread() == GLStateManager.getMainThread();
    }
@@ -1328,6 +1337,12 @@ public class SDLGPURenderBackend extends RenderBackend {
        final int srcGlId = getBoundBuffer(readTarget);
        final int dstGlId = getBoundBuffer(writeTarget);
        if (srcGlId == 0 || dstGlId == 0 || size <= 0) return;
+        final long srcSize = resourceManager.getBufferSize(srcGlId);
+        final long dstSize = resourceManager.getBufferSize(dstGlId);
+        if (readOffset < 0 || writeOffset < 0 || (srcSize > 0 && (readOffset > srcSize || size > srcSize - readOffset)) || (dstSize > 0 && (writeOffset > dstSize || size > dstSize - writeOffset))) {
+            warnInvalidBufferOp("glCopyBufferSubData out of range", dstGlId);
+            return;
+        }
        resourceManager.dropArrayShadow(dstGlId);
        resourceManager.dropEboShadow(dstGlId);
        resourceManager.markBufferContentsDefined(dstGlId);
@@ -1342,7 +1357,7 @@ public class SDLGPURenderBackend extends RenderBackend {
                deferredCopyOp.dstHandle = dstHandle;
                deferredCopyOp.writeOffset = writeOffset;
                deferredCopyOp.seq = seq;
-                final boolean handled = resourceManager.enqueuePersistentCopyDeferred(srcGlId, dstGlId, seq, deferredCopyOp);
+                final boolean handled = resourceManager.enqueuePersistentCopyDeferred(srcGlId, dstGlId, seq, readOffset, size, deferredCopyOp);
                if (handled) {
                    wakeTransferThread();
                    return;
@@ -2756,8 +2771,10 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    private void deleteBuffer(int buffer) {
-        dropMappingFor(buffer);
-        if (buffer != 0) unbindDeletedBuffer(s(), buffer);
+        if (buffer != 0) {
+            freePlainMappingFor(buffer, false);
+            unbindDeletedBuffer(s(), buffer);
+        }
        readbackShadows.release(buffer);
        resourceManager.deleteBuffer(buffer);
    }
@@ -2804,12 +2821,6 @@ public class SDLGPURenderBackend extends RenderBackend {
        if (ssboChanged) st.ssboBindGen++;
    }

-    private static void dropMappingFor(int buffer) {
-        final ContextState st = s();
-        if (buffer == 0 || st.mappedBufferGlId != buffer || st.mappedStagingBuffer == null) return;
-        MemoryUtil.memFree(st.mappedStagingBuffer);
-        clearMappedState(st);
-    }
    @Override public void bindBuffer(int target, int buffer) {
        final ContextState st = s();
        switch (target) {
@@ -2909,8 +2920,15 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public void bufferData(int target, long size, int usage) {
-        final int glId = getBoundBuffer(target);
+        final ContextState cs = s();
+        final int glId = cs.getBoundBuffer(target);
        if (glId == 0) return;
+        if (refuseImmutable(glId, "glBufferData on immutable storage")) return;
+        respecifyStore(cs, target, glId, size, usage);
+    }
+
+    private void respecifyStore(ContextState cs, int target, int glId, long size, int usage) {
+        freePlainMappingFor(glId, true);
        resourceManager.recordBufferGlParams(glId, usage, BufferParams.MUTABLE_STORE);
        if (target == GL31.GL_UNIFORM_BUFFER) {
            if (resourceManager.getBufferSize(glId) == size) return;
@@ -2926,14 +2944,45 @@ public class SDLGPURenderBackend extends RenderBackend {
        readbackShadows.release(glId);
        resourceManager.deleteBuffer(glId);
        resourceManager.createBuffer(glId, sdlUsage, size);
-        if (target == GL15.GL_ARRAY_BUFFER) s().bumpAttribStateGen();
+        if (target == GL15.GL_ARRAY_BUFFER) cs.bumpAttribStateGen();
+    }
+
+    private void freePlainMappingFor(int glId, boolean warn) {
+        final ByteBuffer staging = resourceManager.takePlainStaging(glId);
+        if (staging == null) return;
+        MemoryUtil.memFree(staging);
+        if (warn) warnInvalidBufferOp("glBufferData on mapped buffer", glId);
+    }
+
+    private boolean refuseImmutable(int glId, String op) {
+        if (resourceManager.getBufferStorageFlags(glId) == BufferParams.MUTABLE_STORE) return false;
+        warnInvalidBufferOp(op, glId);
+        return true;
+    }
+
+    @Override public boolean isBufferImmutable(int glId) {
+        return resourceManager.getBufferStorageFlags(glId) != BufferParams.MUTABLE_STORE;
+    }
+
+    private void warnInvalidBufferOp(String op, int glId) {
+        synchronized (warnedBufferOps) {
+            if (warnedBufferOps.add(((long) op.hashCode() << 32) | (glId & 0xFFFFFFFFL))) {
+                LOG.warn("{} (buffer {})", op, glId, new Throwable());
+            }
+        }
    }

    @Override public void bufferData(int target, ByteBuffer data, int usage) {
        final ContextState cs = s();
-        final int glId = getBoundBuffer(target);
+        final int glId = cs.getBoundBuffer(target);
        if (glId == 0 || data == null) return;
+        if (refuseImmutable(glId, "glBufferData on immutable storage")) return;
+        respecifyStore(cs, target, glId, data, usage);
+    }
+
+    private void respecifyStore(ContextState cs, int target, int glId, ByteBuffer data, int usage) {
        final long dataSize = data.remaining();
+        freePlainMappingFor(glId, true);
        resourceManager.recordBufferGlParams(glId, usage, BufferParams.MUTABLE_STORE);
        if (target == GL31.GL_UNIFORM_BUFFER) {
            if (dataSize > 0) {
@@ -3023,11 +3072,15 @@ public class SDLGPURenderBackend extends RenderBackend {

    @Override public void bufferSubData(int target, long offset, ByteBuffer data) {
        final ContextState cs = s();
-        final int glId = getBoundBuffer(target);
+        final int glId = cs.getBoundBuffer(target);
        if (glId == 0 || data == null) return;
        if (target == GL31.GL_UNIFORM_BUFFER) {
            final ByteBuffer shadow = resourceManager.getUboShadow(glId);
            if (shadow != null) {
+                if (offset < 0 || offset + data.remaining() > shadow.capacity()) {
+                    warnInvalidBufferOp("glBufferSubData out of range on uniform buffer", glId);
+                    return;
+                }
                shadow.position(0);
                ByteRegionCopy.copyByteRegion(data, data.position(), shadow, (int) offset, data.remaining());
            }
@@ -3096,133 +3149,132 @@ public class SDLGPURenderBackend extends RenderBackend {

    @Override public boolean unmapBuffer(int target) {
        final ContextState cs = s();
-        final int glId = getBoundBuffer(target);
+        final int glId = cs.getBoundBuffer(target);

-        final PersistentMapping pm = resourceManager.removePersistentMapping(glId);
-        if (pm != null) {
-            resourceManager.releasePersistentStaging(pm);
+        if (resourceManager.getPersistentMapping(glId) != null) {
+            final PersistentMapping pm = resourceManager.removePersistentMapping(glId);
+            if (pm != null) resourceManager.releasePersistentStaging(pm, glId, "unmap");
            return true;
        }

-        final ContextState st = cs;
-        if (st.mappedStagingBuffer == null) return false;
+        final MappedRange m = cs.mappingScratch;
+        if (!resourceManager.takePlainMapping(glId, m)) {
+            warnInvalidBufferOp("glUnmapBuffer on unmapped buffer", glId);
+            return false;
+        }

-        final boolean writeMap = (st.mappedAccessFlags & GL30.GL_MAP_WRITE_BIT) != 0;
+        final ByteBuffer staging = m.staging;
+        m.staging = null;
+        final boolean writeMap = (m.accessFlags & GL30.GL_MAP_WRITE_BIT) != 0;

        if (target == GL30.GL_PIXEL_UNPACK_BUFFER) {
-            st.mappedStagingBuffer.position(0).limit((int) st.mappedLength);
-            final long gpuHandle = resourceManager.getBufferHandle(st.mappedBufferGlId);
+            staging.position(0).limit((int) m.length);
+            final long gpuHandle = resourceManager.getBufferHandle(glId);
            if (writeMap && gpuHandle != 0) {
-                if (st.deferUploads) {
-                    enqueuePreCopied(st.mappedStagingBuffer, gpuHandle, st.mappedOffset, false);
+                if (cs.deferUploads) {
+                    enqueuePreCopied(staging, gpuHandle, m.offset, false);
                } else if (frameManager.getCommandBuffer() != 0) {
-                    resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), st.mappedStagingBuffer, gpuHandle, st.mappedOffset, false);
+                    resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), staging, gpuHandle, m.offset, false);
                }
-                resourceManager.markBufferContentsDefined(st.mappedBufferGlId);
+                resourceManager.markBufferContentsDefined(glId);
            }
-            final ByteBuffer old = resourceManager.putPboStaging(glId, st.mappedStagingBuffer);
+            final ByteBuffer old = resourceManager.putPboStaging(glId, staging);
            if (old != null) MemoryUtil.memFree(old);
-            clearMappedState(st);
            return true;
        }

        if (target == GL31.GL_UNIFORM_BUFFER) {
-            final ByteBuffer shadow = resourceManager.getUboShadow(st.mappedBufferGlId);
-            if (writeMap && shadow != null && st.mappedOffset + st.mappedLength <= shadow.capacity()) {
-                st.mappedStagingBuffer.position(0).limit((int) st.mappedLength);
-                shadow.position((int) st.mappedOffset).limit((int) (st.mappedOffset + st.mappedLength));
-                shadow.put(st.mappedStagingBuffer);
+            final ByteBuffer shadow = resourceManager.getUboShadow(glId);
+            if (writeMap && shadow != null && m.offset + m.length <= shadow.capacity()) {
+                staging.position(0).limit((int) m.length);
+                shadow.position((int) m.offset).limit((int) (m.offset + m.length));
+                shadow.put(staging);
                shadow.position(0).limit(shadow.capacity());
-                resourceManager.markBufferContentsDefined(st.mappedBufferGlId);
+                resourceManager.markBufferContentsDefined(glId);
            }
-            MemoryUtil.memFree(st.mappedStagingBuffer);
-            clearMappedState(st);
+            MemoryUtil.memFree(staging);
            return true;
        }

        if (!writeMap) {
-            MemoryUtil.memFree(st.mappedStagingBuffer);
-            clearMappedState(st);
+            MemoryUtil.memFree(staging);
            return true;
        }

-        st.mappedStagingBuffer.position(0).limit((int) st.mappedLength);
+        staging.position(0).limit((int) m.length);
        final long gpuHandle;
-        if (st.mappedInvalidate) {
+        if (m.invalidate) {
            final int sdlUsage = FormatMap.mapBufferUsage(0);
-            final long glSize = Math.max(resourceManager.getBufferSize(st.mappedBufferGlId), st.mappedLength);
-            final int glUsage = resourceManager.getBufferGlUsage(st.mappedBufferGlId);
-            final int storageFlags = resourceManager.getBufferStorageFlags(st.mappedBufferGlId);
-            resourceManager.deleteBuffer(st.mappedBufferGlId);
-            gpuHandle = resourceManager.createBuffer(st.mappedBufferGlId, sdlUsage, glSize);
-            resourceManager.recordBufferGlParams(st.mappedBufferGlId, glUsage, storageFlags);
-            st.bumpAttribStateGen();
+            final long glSize = Math.max(resourceManager.getBufferSize(glId), m.length);
+            final int glUsage = resourceManager.getBufferGlUsage(glId);
+            final int storageFlags = resourceManager.getBufferStorageFlags(glId);
+            resourceManager.deleteBuffer(glId);
+            gpuHandle = resourceManager.createBuffer(glId, sdlUsage, glSize);
+            resourceManager.recordBufferGlParams(glId, glUsage, storageFlags);
+            cs.bumpAttribStateGen();
        } else {
-            gpuHandle = resourceManager.getBufferHandle(st.mappedBufferGlId);
+            gpuHandle = resourceManager.getBufferHandle(glId);
        }
        if (target == GL15.GL_ELEMENT_ARRAY_BUFFER
-                && (cs.primitiveRestartEnabled || resourceManager.hasEboShadow(st.mappedBufferGlId))) {
-            final int len = (int) st.mappedLength;
-            st.mappedStagingBuffer.position(0).limit(len);
-            persistentSync.mirrorEboShadow(st.mappedBufferGlId, st.mappedStagingBuffer, (int) st.mappedOffset, len);
-            st.mappedStagingBuffer.position(0).limit(len);
+                && (cs.primitiveRestartEnabled || resourceManager.hasEboShadow(glId))) {
+            final int len = (int) m.length;
+            staging.position(0).limit(len);
+            persistentSync.mirrorEboShadow(glId, staging, (int) m.offset, len);
+            staging.position(0).limit(len);
        }
-        if (target == GL15.GL_ARRAY_BUFFER && resourceManager.hasArrayShadow(st.mappedBufferGlId)) {
-            final int len = (int) st.mappedLength;
-            st.mappedStagingBuffer.position(0).limit(len);
-            resourceManager.mirrorArrayShadowRegion(st.mappedBufferGlId, st.mappedStagingBuffer, (int) st.mappedOffset);
-            st.mappedStagingBuffer.position(0).limit(len);
+        if (target == GL15.GL_ARRAY_BUFFER && resourceManager.hasArrayShadow(glId)) {
+            final int len = (int) m.length;
+            staging.position(0).limit(len);
+            resourceManager.mirrorArrayShadowRegion(glId, staging, (int) m.offset);
+            staging.position(0).limit(len);
        }
        if (gpuHandle != 0) {
-            if (st.deferUploads) {
-                enqueuePreCopied(st.mappedStagingBuffer, gpuHandle, st.mappedOffset, false);
+            if (cs.deferUploads) {
+                enqueuePreCopied(staging, gpuHandle, m.offset, false);
            } else if (frameManager.getCommandBuffer() != 0) {
-                resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), st.mappedStagingBuffer, gpuHandle, st.mappedOffset, false);
+                resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), staging, gpuHandle, m.offset, false);
            }
-            resourceManager.markBufferContentsDefined(st.mappedBufferGlId);
+            resourceManager.markBufferContentsDefined(glId);
        }

-        MemoryUtil.memFree(st.mappedStagingBuffer);
-        clearMappedState(st);
+        MemoryUtil.memFree(staging);
        return true;
    }

-    private static void clearMappedState(ContextState st) {
-        st.mappedStagingBuffer = null;
-        st.mappedBufferGlId = 0;
-        st.mappedOffset = 0;
-        st.mappedLength = 0;
-        st.mappedInvalidate = false;
-        st.mappedAccessFlags = 0;
-    }
-
    @Override public ByteBuffer mapBufferRange(int target, long offset, long length, int access) {
-        final int glId = getBoundBuffer(target);
+        final ContextState cs = s();
+        final int glId = cs.getBoundBuffer(target);
        if (glId == 0 || length <= 0) return null;

        final boolean persistent = (access & GL44.GL_MAP_PERSISTENT_BIT) != 0;

        if (persistent) {
-            if (target == GL15.GL_ARRAY_BUFFER) resourceManager.dropArrayShadow(glId);
+            final int storageFlags = resourceManager.getBufferStorageFlags(glId);
+            if (storageFlags < 0 || (storageFlags & GL44.GL_MAP_PERSISTENT_BIT) == 0) {
+                warnInvalidBufferOp("glMapBufferRange persistent without persistent storage", glId);
+                return null;
+            }
            final ByteBuffer staging = MemoryUtil.memCalloc((int) length);
            final PersistentMapping fresh = new PersistentMapping(staging, offset, length, access);
-            final PersistentMapping prior = resourceManager.swapPersistentMapping(glId, fresh);
-            if (prior != null) resourceManager.releasePersistentStaging(prior);
+            if (!resourceManager.putPersistentMappingIfAbsent(glId, fresh)) {
+                MemoryUtil.memFree(staging);
+                warnInvalidBufferOp("glMapBufferRange on mapped buffer", glId);
+                return null;
+            }
+            if (target == GL15.GL_ARRAY_BUFFER) resourceManager.dropArrayShadow(glId);
            return staging;
        }

-        final ContextState st = s();
-        if (st.mappedStagingBuffer != null) MemoryUtil.memFree(st.mappedStagingBuffer);
-        st.mappedStagingBuffer = MemoryUtil.memAlloc((int) length);
-        st.mappedBufferGlId = glId;
-        st.mappedOffset = offset;
-        st.mappedLength = length;
-        st.mappedInvalidate = (access & GL30.GL_MAP_INVALIDATE_BUFFER_BIT) != 0;
-        st.mappedAccessFlags = access;
+        final ByteBuffer staging = MemoryUtil.memAlloc((int) length);
        if ((access & (GL30.GL_MAP_INVALIDATE_BUFFER_BIT | GL30.GL_MAP_INVALIDATE_RANGE_BIT)) == 0) {
-            seedMappedStaging(target, glId, offset, length, st.mappedStagingBuffer);
+            seedMappedStaging(target, glId, offset, length, staging);
        }
-        return st.mappedStagingBuffer;
+        if (!resourceManager.putPlainMappingIfAbsent(glId, staging, offset, length, (access & GL30.GL_MAP_INVALIDATE_BUFFER_BIT) != 0, access)) {
+            MemoryUtil.memFree(staging);
+            warnInvalidBufferOp("glMapBufferRange on mapped buffer", glId);
+            return null;
+        }
+        return staging;
    }

    private void seedMappedStaging(int target, int glId, long offset, long length, ByteBuffer staging) {
@@ -3310,22 +3362,31 @@ public class SDLGPURenderBackend extends RenderBackend {
    @Override public void flushMappedBufferRange(int target, long offset, long length) {
        final int glId = getBoundBuffer(target);
        if (glId == 0 || length <= 0) return;
-        persistentSync.onPersistentBufferWrite(glId, offset, length);
+        if (!persistentSync.onPersistentBufferWrite(glId, offset, length)) {
+            warnInvalidBufferOp("glFlushMappedBufferRange out of range", glId);
+        }
    }

    @Override public void bufferStorage(int target, ByteBuffer data, int flags) {
-        bufferData(target, data, GL15.GL_DYNAMIC_DRAW);
-        recordImmutableStorage(target, flags);
+        final ContextState cs = s();
+        final int glId = cs.getBoundBuffer(target);
+        if (glId == 0) return;
+        if (refuseImmutable(glId, "glBufferStorage on immutable storage")) return;
+        if (data != null) respecifyStore(cs, target, glId, data, GL15.GL_DYNAMIC_DRAW);
+        recordImmutableStorage(glId, flags);
    }

    @Override public void bufferStorage(int target, long size, int flags) {
-        bufferData(target, size, GL15.GL_DYNAMIC_DRAW);
-        recordImmutableStorage(target, flags);
+        final ContextState cs = s();
+        final int glId = cs.getBoundBuffer(target);
+        if (glId == 0) return;
+        if (refuseImmutable(glId, "glBufferStorage on immutable storage")) return;
+        respecifyStore(cs, target, glId, size, GL15.GL_DYNAMIC_DRAW);
+        recordImmutableStorage(glId, flags);
    }

-    private void recordImmutableStorage(int target, int flags) {
-        final int glId = getBoundBuffer(target);
-        if (glId != 0) resourceManager.recordBufferGlParams(glId, GL15.GL_DYNAMIC_DRAW, flags);
+    private void recordImmutableStorage(int glId, int flags) {
+        resourceManager.recordBufferGlParams(glId, GL15.GL_DYNAMIC_DRAW, flags);
    }
    @Override public void getBufferSubData(int target, long offset, ByteBuffer data) {
        final int glId = getBoundBuffer(target);
@@ -3341,23 +3402,12 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    private void downloadBufferBlocking(long handle, int offset, int size, ByteBuffer out) {
-        flushDeferredUploadsForRead();
-        frameManager.endCopyPassIfActive();
-        frameManager.endRenderPassIfActive(FrameManager.PASS_END_COPY);
+        flushAndSubmitMidFrame();
        final long cb = SDL_AcquireGPUCommandBuffer(device.getDevice());
        if (cb == 0) return;
        resourceManager.downloadFromBuffer(cb, handle, offset, size, out);
    }

-    private void flushDeferredUploadsForRead() {
-        final ContextState st = s();
-        drainDeferredPersistentRegions(st);
-        resourceManager.flushUploadArena();
-        if (transferThread != null && st.frameHighestEnqueuedSeq > transferThread.getSubmittedSeq()) {
-            transferThread.awaitSubmittedUpTo(st.frameHighestEnqueuedSeq);
-        }
-    }
-
    private static void serveFromShadow(ByteBuffer shadow, int srcOffset, ByteBuffer data, int rem) {
        final int dstPos = data.position();
        if (shadow.isDirect() && data.isDirect()) {
@@ -3394,8 +3444,9 @@ public class SDLGPURenderBackend extends RenderBackend {
        }

        final PersistentMapping pm = resourceManager.getPersistentMapping(glId);
-        final ContextState st = s();
-        final boolean plainMapped = st.mappedStagingBuffer != null && st.mappedBufferGlId == glId;
+        final MappedRange plain = s().mappingScratch;
+        final boolean plainMapped = resourceManager.peekPlainMapping(glId, plain);
+        plain.staging = null;

        final boolean mapped;
        final int accessFlags;
@@ -3408,9 +3459,9 @@ public class SDLGPURenderBackend extends RenderBackend {
            mapLength = pm.length;
        } else if (plainMapped) {
            mapped = true;
-            accessFlags = st.mappedAccessFlags;
-            mapOffset = st.mappedOffset;
-            mapLength = st.mappedLength;
+            accessFlags = plain.accessFlags;
+            mapOffset = plain.offset;
+            mapLength = plain.length;
        } else {
            mapped = false;
            accessFlags = 0;
@@ -3848,14 +3899,18 @@ public class SDLGPURenderBackend extends RenderBackend {
    @Override public int createBuffers() { return resourceManager.genBuffer(); }
    @Override public void namedBufferData(int buffer, long size, int usage) {
        if (buffer == 0 || size <= 0) return;
+        if (refuseImmutable(buffer, "glNamedBufferData on immutable storage")) return;
        final int sdlUsage = FormatMap.mapBufferUsage(GL15.GL_ARRAY_BUFFER);
+        freePlainMappingFor(buffer, true);
        resourceManager.deleteBuffer(buffer);
        resourceManager.createBuffer(buffer, sdlUsage, size);
        resourceManager.recordBufferGlParams(buffer, usage, BufferParams.MUTABLE_STORE);
    }
    @Override public void namedBufferData(int buffer, ByteBuffer data, int usage) {
        if (buffer == 0 || data == null) return;
+        if (refuseImmutable(buffer, "glNamedBufferData on immutable storage")) return;
        final int sdlUsage = FormatMap.mapBufferUsage(GL15.GL_ARRAY_BUFFER);
+        freePlainMappingFor(buffer, true);
        resourceManager.deleteBuffer(buffer);
        final long handle = resourceManager.createBuffer(buffer, sdlUsage, data.remaining());
        resourceManager.recordBufferGlParams(buffer, usage, BufferParams.MUTABLE_STORE);
@@ -4104,36 +4159,53 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    private static final int CLEAR_CHUNK_BYTES = 64 * 1024;
+    private static final int FILL_CHUNK_BYTES = 4 * 1024 * 1024;
+
+    private static boolean isAllZero(ByteBuffer data, int elemBytes) {
+        final int n = Math.min(elemBytes, data.remaining());
+        for (int i = 0; i < n; i++) {
+            if (data.get(data.position() + i) != 0) return false;
+        }
+        return true;
+    }
    @Override public void clearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, ByteBuffer data) {
        final int glId = getBoundBuffer(target);
        if (glId == 0 || size <= 0) return;
+        final long bufSize = resourceManager.getBufferSize(glId);
+        if (offset < 0 || (bufSize > 0 && (offset > bufSize || size > bufSize - offset))) {
+            warnInvalidBufferOp("glClearBufferSubData out of range", glId);
+            return;
+        }
        final long handle = resourceManager.getBufferHandle(glId);
        if (handle == 0 || frameManager.getCommandBuffer() == 0) return;

        final int elemBytes = Math.max(1, PixelOps.glPixelSize(format, type));
-        final int chunkBytes = (int) Math.min(size, CLEAR_CHUNK_BYTES);
+        final boolean defer = s().deferUploads && target != GL43.GL_SHADER_STORAGE_BUFFER;
+        // Undeferred clears stage one large pattern and upload it repeatedly
+        final int chunkBytes = (int) Math.min(size, defer ? CLEAR_CHUNK_BYTES : FILL_CHUNK_BYTES);
        final int alignedChunk = (chunkBytes / elemBytes) * elemBytes;
        if (alignedChunk == 0) return;
        resourceManager.markBufferContentsDefined(glId);
-        final ByteBuffer chunk = MemoryUtil.memAlloc(alignedChunk);
+        final boolean zero = data == null || isAllZero(data, elemBytes);
+        final ByteBuffer chunk = zero ? MemoryUtil.memCalloc(alignedChunk) : MemoryUtil.memAlloc(alignedChunk);
        try {
-            for (int i = 0; i < alignedChunk; i++) {
-                final byte v = (data != null && (i % elemBytes) < data.remaining())
-                    ? data.get(data.position() + (i % elemBytes)) : 0;
-                chunk.put(i, v);
+            if (!zero) {
+                for (int i = 0; i < alignedChunk; i++) {
+                    final byte v = (i % elemBytes) < data.remaining() ? data.get(data.position() + (i % elemBytes)) : 0;
+                    chunk.put(i, v);
+                }
            }
            chunk.position(0).limit(alignedChunk);
+            if (!defer) {
+                resourceManager.fillBuffer(frameManager.ensureCopyPass(), chunk, handle, offset, size);
+                return;
+            }
            long remaining = size;
            long writeOffset = offset;
-            final boolean defer = s().deferUploads && target != GL43.GL_SHADER_STORAGE_BUFFER;
            while (remaining > 0) {
                final int n = (int) Math.min(remaining, alignedChunk);
                chunk.position(0).limit(n);
-                if (defer) {
-                    enqueuePreCopied(chunk, handle, writeOffset, false);
-                } else {
-                    resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), chunk, handle, writeOffset, false);
-                }
+                enqueuePreCopied(chunk, handle, writeOffset, false);
                remaining -= n;
                writeOffset += n;
            }
@@ -4158,11 +4230,14 @@ public class SDLGPURenderBackend extends RenderBackend {
            return;
        }

-        // Volume-sized staging, so it is only reached for 3D formats the compute clear cannot address.
-        final long totalBytes = (long) mipW * mipH * mipD * bpp;
-        if (totalBytes <= 0 || totalBytes > Integer.MAX_VALUE) return;
        final long cp = frameManager.ensureCopyPass();
        if (cp == 0) return;
+        // A volume-sized staging buffer would allocate and upload each byte (1 GB for Euphoria Patches' floodfill!!)
+        if (mipD > 1 && resourceManager.zeroTexture3D(cp, texHandle, mipW, mipH, mipD, level, bpp)) {
+            return;
+        }
+        final long totalBytes = (long) mipW * mipH * mipD * bpp;
+        if (totalBytes <= 0 || totalBytes > Integer.MAX_VALUE) return;
        final ByteBuffer zeros = MemoryUtil.memCalloc((int) totalBytes);
        try {
            if (mipD > 1) {
@@ -4464,8 +4539,8 @@ public class SDLGPURenderBackend extends RenderBackend {
        long readOffset, size, dstHandle, writeOffset, seq;
        @Override
        public void accept(PersistentMapping src, PersistentMapping dst) {
-            enqueueUpload(TransferThread.StagingReadUpload.acquire(src.staging, readOffset, size, dstHandle, writeOffset, seq, false));
-            if (dst != null) PersistentBufferSync.mirrorPersistentCopy(src.staging, readOffset, dst.staging, writeOffset, size);
+            enqueueUpload(TransferThread.StagingReadUpload.acquire(src.staging, src.stagingIndex(readOffset), size, dstHandle, writeOffset, seq, false));
+            if (dst != null) PersistentBufferSync.mirrorPersistentCopy(src, readOffset, dst, writeOffset, size);
        }
    }
 }
@@ -1,6 +1,8 @@
 package com.gtnewhorizons.angelica.sdlgpu.device;

 import com.gtnewhorizons.angelica.config.SystemProperties;
+import com.gtnewhorizons.angelica.glsm.backend.BackendOptions;
+import com.gtnewhorizons.angelica.glsm.backend.MoltenVK;
 import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
 import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
 import com.gtnewhorizons.angelica.sdlgpu.util.DebugMessageRelay;
@@ -20,11 +22,12 @@ import org.lwjgl.system.Platform;
 import org.lwjglx.opengl.Display;

 import java.nio.IntBuffer;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Supplier;

 import static org.lwjgl.sdl.SDLGPU.*;
-import static org.lwjgl.sdl.SDLHints.SDL_HINT_GPU_DRIVER;
+import static org.lwjgl.sdl.SDLHints.SDL_HINT_VULKAN_LIBRARY;
 import static org.lwjgl.sdl.SDLHints.SDL_SetHint;
 import static org.lwjgl.sdl.SDLVideo.*;
 import static org.lwjgl.system.MemoryUtil.memUTF8;
@@ -82,9 +85,23 @@ public final class Device {
        throw new GpuDeviceLostException(operation, err);
    }

-    // Default to vulkan for now until D3D is more tested
-    static String resolveDriverName(String userHint, boolean windows) {
-        return userHint.isEmpty() && windows ? "vulkan" : null;
+    static String[] driverCandidates(String requested, Platform platform) {
+        final String[] platformOrder = switch (platform) {
+            case MACOSX -> new String[] { "metal", "vulkan" };
+            case WINDOWS -> new String[] { "vulkan", "direct3d12" };
+            default -> new String[] { "vulkan" };
+        };
+        if (requested.isEmpty()) return platformOrder;
+        final List<String> candidates = new ArrayList<>(platformOrder.length + 1);
+        candidates.add(requested);
+        for (final String driver : platformOrder) {
+            if (!driver.equalsIgnoreCase(requested)) candidates.add(driver);
+        }
+        return candidates.toArray(new String[0]);
+    }
+
+    static boolean isVulkan(String driverName) {
+        return "vulkan".equalsIgnoreCase(driverName);
    }

    static boolean isMetal(String driverName) {
@@ -103,17 +120,16 @@ public final class Device {
        final int ver = SDLVersion.SDL_GetVersion();
        LOG.info("SDL runtime version {}.{}.{} (raw {})", SDLVersion.SDL_VERSIONNUM_MAJOR(ver), SDLVersion.SDL_VERSIONNUM_MINOR(ver), SDLVersion.SDL_VERSIONNUM_MICRO(ver), ver);

-        final String driverHint = SystemProperties.SDL_GPU_DRIVER;
-        if (!driverHint.isEmpty()) {
-            SDL_SetHint(SDL_HINT_GPU_DRIVER, driverHint);
-            LOG.info("SDL GPU driver hint set to '{}'", driverHint);
+        final String requestedDriver = BackendOptions.sdlGpuDriver();
+        final String[] candidates = driverCandidates(requestedDriver, Platform.get());
+        if (!requestedDriver.isEmpty()) {
+            LOG.info("SDL GPU driver requested: '{}'", requestedDriver);
        }

        final boolean gpuDebug = SystemProperties.LWJGL_DEBUG || SystemProperties.SDL_GPU_DEBUG;
-        final String forcedDriver = resolveDriverName(driverHint, Platform.get() == Platform.WINDOWS);
-        device = createGPUDevice(gpuDebug, forcedDriver);
+        device = createGPUDevice(gpuDebug, candidates);
        if (device == 0 && VideoDriverRecovery.shouldRetryOnX11(SDL_GetCurrentVideoDriver(), vulkanLoaderAvailable(), System.getenv("DISPLAY"))) {
-            device = VideoDriverRecovery.retryUnderX11(() -> createGPUDevice(gpuDebug, forcedDriver));
+            device = VideoDriverRecovery.retryUnderX11(() -> createGPUDevice(gpuDebug, candidates));
        }
        if (device == 0) {
            logDeviceCreationFailure(REQUESTED_SHADER_FORMATS);
@@ -128,7 +144,7 @@ public final class Device {
        driverVersion = SDLProperties.SDL_GetStringProperty(props, SDL_PROP_GPU_DEVICE_DRIVER_VERSION_STRING, "");
        driverInfo = SDLProperties.SDL_GetStringProperty(props, SDL_PROP_GPU_DEVICE_DRIVER_INFO_STRING, "");

-        LOG.info("SDL GPU device created: gpu={}, driver={} {}, video={}, formats=0x{}, debug={}, forcedDriver={}", deviceName, driverName, driverVersion, SDL_GetCurrentVideoDriver(), Integer.toHexString(supportedShaderFormats), gpuDebug, forcedDriver);
+        LOG.info("SDL GPU device created: gpu={}, driver={} {}, video={}, formats=0x{}, debug={}, requestedDriver={}", deviceName, driverName, driverVersion, SDL_GetCurrentVideoDriver(), Integer.toHexString(supportedShaderFormats), gpuDebug, requestedDriver);

        if (metalNeedsNewerSdl(driverName, ver)) {
            LOG.error("SDL GPU on Metal requires SDL 3.4.6 or newer (have {}.{}.{}); falling back to OpenGL", SDLVersion.SDL_VERSIONNUM_MAJOR(ver), SDLVersion.SDL_VERSIONNUM_MINOR(ver), SDLVersion.SDL_VERSIONNUM_MICRO(ver));
@@ -151,13 +167,29 @@ public final class Device {
        }
    }

-    private long createGPUDevice(boolean gpuDebug, String forcedDriver) {
-        long dev = SDL_CreateGPUDevice(REQUESTED_SHADER_FORMATS, gpuDebug, forcedDriver);
-        if (dev == 0 && forcedDriver != null) {
-            LOG.warn("Failed to create a '{}' SDL GPU device ({}); falling back to SDL's default backend. Set -D{} to pin one.", forcedDriver, SDLError.SDL_GetError(), SystemProperties.KEY_SDL_GPU_DRIVER);
-            dev = SDL_CreateGPUDevice(REQUESTED_SHADER_FORMATS, gpuDebug, (CharSequence) null);
+    private static void useMoltenVk() {
+        final String path = MoltenVK.locate();
+        if (path == null || MoltenVK.source() == MoltenVK.Source.ENV) return;
+        if (SDL_SetHint(SDL_HINT_VULKAN_LIBRARY, path)) {
+            LOG.info("MoltenVK: {}", path);
+        } else {
+            LOG.warn("Could not point SDL at MoltenVK {}: {}", path, SDLError.SDL_GetError());
        }
-        return dev;
+    }
+
+    private long createGPUDevice(boolean gpuDebug, String[] candidates) {
+        final boolean macos = Platform.get() == Platform.MACOSX;
+        for (final String driver : candidates) {
+            final boolean macVulkan = macos && isVulkan(driver);
+            if (macVulkan) useMoltenVk();
+            final long dev = SDL_CreateGPUDevice(REQUESTED_SHADER_FORMATS, gpuDebug, driver);
+            if (dev != 0) return dev;
+            LOG.warn("Failed to create a '{}' SDL GPU device: {}", driver, SDLError.SDL_GetError());
+            if (macVulkan && MoltenVK.locate() == null) {
+                LOG.warn("Vulkan on macOS needs MoltenVK. Add {} to the mods folder or install MoltenVK.", MoltenVK.JAR_NAME);
+            }
+        }
+        return 0;
    }

    public void claimWindow(long window) {
@@ -213,7 +245,7 @@ public final class Device {
                }
            }
        }
-        LOG.error("Continuing on OpenGL. Set -D{}=false to skip this probe entirely.", SystemProperties.KEY_USE_SDL_GPU);
+        LOG.error("Continuing on OpenGL. Set Video Settings > Renderer > Backend to OpenGL, or -D{}=false, to skip this probe entirely.", SystemProperties.KEY_USE_SDL_GPU);
    }

    public void destroyDevice() {
@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.sdlgpu.frame;
 import com.gtnewhorizons.angelica.glsm.GLContextState;
 import com.gtnewhorizons.angelica.sdlgpu.SDLGPURenderBackend;
 import com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineCache;
+import com.gtnewhorizons.angelica.sdlgpu.resource.MappedRange;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PackState;
 import com.gtnewhorizons.angelica.sdlgpu.shader.LogicOpVariant;
 import com.gtnewhorizons.angelica.sdlgpu.shader.ShaderManager;
@@ -314,12 +315,7 @@ public final class ContextState {
    public final long[] computeBatchRwTexs = new long[MAX_IMAGE_UNITS];
    public final int[] computeBatchRwTexLevels = new int[MAX_IMAGE_UNITS];

-    public int mappedBufferGlId;
-    public ByteBuffer mappedStagingBuffer;
-    public long mappedOffset;
-    public long mappedLength;
-    public boolean mappedInvalidate;
-    public int mappedAccessFlags;
+    public final MappedRange mappingScratch = new MappedRange();

    public final SDL_GPUTextureSamplerBinding.Buffer fragSamplerBindings = SDL_GPUTextureSamplerBinding.calloc(MAX_SAMPLERS);
    public final SDL_GPUTextureSamplerBinding.Buffer vertSamplerBindings = SDL_GPUTextureSamplerBinding.calloc(MAX_SAMPLERS);
@@ -173,8 +173,9 @@ public final class FFPTrace {
            sb.append(" | ffpUbo=buffer").append(glId).append(" noStaging");
            return;
        }
-        final int base = st.uboRangeOffset[binding];
-        sb.append(" | ffpUbo=buffer").append(glId).append(" base=").append(base);
+        final int rangeOffset = st.uboRangeOffset[binding];
+        final int base = pm != null ? (int) pm.stagingIndex(rangeOffset) : rangeOffset;
+        sb.append(" | ffpUbo=buffer").append(glId).append(" base=").append(rangeOffset);
        appendUboFloat(buf, base, FFPUniformBlock.ALPHA_REF, " u_AlphaRef=");
        appendUboMatrix(buf, base, FFPUniformBlock.MVP_MATRIX, " u_MVPMatrix=");
        appendUboMatrix(buf, base, FFPUniformBlock.LIGHTMAP_TEXTURE_MATRIX, " u_LightmapTextureMatrix=");
@@ -698,8 +698,8 @@ public final class PipelineApplier {
        final int offset = st.uboRangeOffset[binding];
        final PersistentMapping pm = resourceManager.getPersistentMapping(glId);
        if (pm != null) {
-            if (offset < 0 || offset + size > pm.staging.capacity()) return 0L;
-            return MemoryUtil.memAddress0(pm.staging) + offset;
+            if (!pm.covers(offset, size)) return 0L;
+            return MemoryUtil.memAddress0(pm.staging) + pm.stagingIndex(offset);
        }
        final ByteBuffer shadow = resourceManager.getUboShadow(glId);
        if (shadow != null) {
@@ -8,16 +8,13 @@ public final class ByteRegionCopy {
    private ByteRegionCopy() {}

    public static void copyByteRegion(ByteBuffer src, int srcOff, ByteBuffer dst, int dstOff, int len) {
+        if ((srcOff | dstOff | len) < 0 || srcOff + (long) len > src.capacity() || dstOff + (long) len > dst.capacity()) {
+            throw new IllegalStateException("copyByteRegion out of bounds: len=" + len + " srcOff=" + srcOff + " src.capacity=" + src.capacity() + " dstOff=" + dstOff + " dst.capacity=" + dst.capacity());
+        }
        if (src.isDirect() && dst.isDirect()) {
            MemoryUtil.memCopy(MemoryUtil.memAddress(src, srcOff), MemoryUtil.memAddress(dst, dstOff), len);
            return;
        }
-        if (src.hasArray() && dst.hasArray()) {
-            System.arraycopy(src.array(), src.arrayOffset() + srcOff, dst.array(), dst.arrayOffset() + dstOff, len);
-            return;
-        }
-        for (int i = 0; i < len; i++) {
-            dst.put(dstOff + i, src.get(srcOff + i));
-        }
+        dst.put(dstOff, src, srcOff, len);
    }
 }
@@ -0,0 +1,12 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import java.nio.ByteBuffer;
+
+public final class MappedRange {
+    public int glId;
+    public ByteBuffer staging;
+    public long offset;
+    public long length;
+    public boolean invalidate;
+    public int accessFlags;
+}
@@ -33,11 +33,14 @@ public final class PersistentBufferSync {
        this.sink = sink;
    }

-    public void onPersistentBufferWrite(int glId, long offset, long size) {
+    public boolean onPersistentBufferWrite(int glId, long offset, long size) {
        final PersistentMapping pm = resourceManager.getPersistentMapping(glId);
-        if (pm != null && pm.markDirty(offset, size)) {
+        if (pm == null || size == 0) return true;
+        if (offset < 0 || size < 0 || offset > pm.length || size > pm.length - offset) return false;
+        if (pm.markDirty(offset, size)) {
            resourceManager.trackPersistentDirty();
        }
+        return true;
    }

    public void uploadDirtyPersistentRegion()   { processDirtyPersistentRegions(false); }
@@ -59,30 +62,41 @@ public final class PersistentBufferSync {
        for (int i = 0; i < n; i++) {
            final PersistentMapping pm = vals.get(i);
            if (!pm.isDirty()) continue;
-            final long gpuHandle = resourceManager.getBufferHandle(keys.getInt(i));
-            if (gpuHandle == 0) continue;
-            final long claimed = pm.claimDirty();
-            if (PersistentMapping.isClean(claimed)) continue;
-            final long off = PersistentMapping.rangeOffset(claimed);
-            final long size = PersistentMapping.rangeSize(claimed);
-            if (Tracy.ENABLED) frameManager.notePersistentDrain();
-            if (defer) {
-                final long seq = sink.nextSeq();
-                pm.lastEnqueuedSeq = seq;
-                sink.enqueue(TransferThread.StagingReadUpload.acquire(pm.staging, off, size, gpuHandle, off, seq, false));
-                enqueued++;
-            } else {
-                pm.staging.position((int) off).limit((int) (off + size));
-                resourceManager.uploadToBuffer(frameManager.ensureCopyPass(), pm.staging, gpuHandle, off, false);
-                pm.staging.clear();
+            final int glId = keys.getInt(i);
+            long copyPass = 0L;
+            if (!defer) {
+                if (resourceManager.getBufferHandle(glId) == 0) continue;
+                copyPass = frameManager.ensureCopyPass();
+            }
+            resourceManager.beginPersistentDrain();
+            try {
+                if (resourceManager.getPersistentMapping(glId) != pm) continue;
+                final long gpuHandle = resourceManager.getBufferHandle(glId);
+                if (gpuHandle == 0) continue;
+                final long claimed = pm.claimDirty();
+                if (PersistentMapping.isClean(claimed)) continue;
+                resourceManager.clearPersistentDirty();
+                final long off = PersistentMapping.rangeOffset(claimed);
+                final long size = PersistentMapping.rangeSize(claimed);
+                if (Tracy.ENABLED) frameManager.notePersistentDrain();
+                if (defer) {
+                    final long seq = sink.nextSeq();
+                    pm.lastEnqueuedSeq = seq;
+                    sink.enqueue(TransferThread.StagingReadUpload.acquire(pm.staging, off, size, gpuHandle, pm.offset + off, seq, false));
+                    enqueued++;
+                } else {
+                    resourceManager.uploadRangeToBuffer(copyPass, pm.staging, off, size, gpuHandle, pm.offset + off, false);
+                }
+            } finally {
+                resourceManager.endPersistentDrain();
            }
-            resourceManager.clearPersistentDirty();
        }
        return enqueued;
    }

-    public static void mirrorPersistentCopy(ByteBuffer srcStaging, long srcOffset, ByteBuffer dstStaging, long dstOffset, long size) {
-        ByteRegionCopy.copyByteRegion(srcStaging, (int) srcOffset, dstStaging, (int) dstOffset, (int) size);
+    public static void mirrorPersistentCopy(PersistentMapping src, long readOffset, PersistentMapping dst, long writeOffset, long size) {
+        if (!src.covers(readOffset, size) || !dst.covers(writeOffset, size)) return;
+        ByteRegionCopy.copyByteRegion(src.staging, (int) src.stagingIndex(readOffset), dst.staging, (int) dst.stagingIndex(writeOffset), (int) size);
    }

    public void mirrorEboShadow(int glId, ByteBuffer src, int dstOffset, int len) {
@@ -24,6 +24,12 @@ public final class PersistentMapping {
    public static long rangeSize(long packed) { return (packed & 0xFFFFFFFFL) - (packed >>> 32); }
    static long packRange(long min, long max) { return (min << 32) | (max & 0xFFFFFFFFL); }

+    public long stagingIndex(long bufferOffset) { return bufferOffset - offset; }
+
+    public boolean covers(long bufferOffset, long size) {
+        return size >= 0 && bufferOffset >= offset && bufferOffset - offset <= length && size <= length - (bufferOffset - offset);
+    }
+
    public boolean isDirty() { return dirtyRange.get() != CLEAN; }

    public long claimDirty() { return dirtyRange.getAndSet(CLEAN); }
@@ -31,6 +31,7 @@ import java.nio.ByteOrder;
 import java.nio.FloatBuffer;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -96,6 +97,9 @@ public final class ResourceManager {

    private final Int2ObjectOpenHashMap<ContextState.VAOState> vaoStates = new Int2ObjectOpenHashMap<>();
    private final Int2ObjectOpenHashMap<PersistentMapping> persistentMappings = new Int2ObjectOpenHashMap<>();
+    private final Int2ObjectOpenHashMap<MappedRange> plainMappings = new Int2ObjectOpenHashMap<>();
+    private MappedRange[] plainMappingPool = new MappedRange[4];
+    private int plainMappingPoolCount;
    private final Int2ObjectOpenHashMap<ByteBuffer> uboShadows = new Int2ObjectOpenHashMap<>();
    private final Int2ObjectOpenHashMap<ByteBuffer> eboShadows = new Int2ObjectOpenHashMap<>();
    private final IntOpenHashSet eboShadowWanted = new IntOpenHashSet();
@@ -752,6 +756,7 @@ public final class ResourceManager {

    public void deleteBuffer(int glId) {
        final ByteBuffer droppedPboStaging;
+        final ByteBuffer droppedPlainStaging;
        final PersistentMapping droppedPm;
        wLock.lock();
        try {
@@ -763,6 +768,7 @@ public final class ResourceManager {
            undefinedContentBuffers.remove(glId);
            droppedPm = persistentMappings.remove(glId);
            if (droppedPm != null) mappingsVersion++;
+            droppedPlainStaging = removePlainMappingLocked(glId);
            droppedPboStaging = pboStagingData.remove(glId);
            deleteUboShadow(glId);
            deleteEboShadow(glId);
@@ -777,8 +783,11 @@ public final class ResourceManager {
        if (droppedPboStaging != null) {
            memFree(droppedPboStaging);
        }
+        if (droppedPlainStaging != null) {
+            memFree(droppedPlainStaging);
+        }
        untrackPersistentDirty(droppedPm);
-        releasePersistentStaging(droppedPm);
+        releasePersistentStaging(droppedPm, glId, "delete");
    }

    public void flushDeferredReleases() {
@@ -953,10 +962,81 @@ public final class ResourceManager {
        try { vaoStates.remove(glId); } finally { wLock.unlock(); }
    }

-    public void putPersistentMapping(int bufferGlId, PersistentMapping m) {
+    public boolean putPersistentMappingIfAbsent(int glId, PersistentMapping pm) {
        wLock.lock();
-        try { persistentMappings.put(bufferGlId, m); mappingsVersion++; } finally { wLock.unlock(); }
+        try {
+            if (plainMappings.containsKey(glId) || persistentMappings.putIfAbsent(glId, pm) != null) return false;
+            mappingsVersion++;
+            return true;
+        } finally { wLock.unlock(); }
    }
+
+    public boolean putPlainMappingIfAbsent(int glId, ByteBuffer staging, long offset, long length, boolean invalidate, int accessFlags) {
+        wLock.lock();
+        try {
+            if (plainMappings.containsKey(glId) || persistentMappings.containsKey(glId)) return false;
+            final MappedRange m;
+            if (plainMappingPoolCount > 0) {
+                m = plainMappingPool[--plainMappingPoolCount];
+                plainMappingPool[plainMappingPoolCount] = null;
+            } else {
+                m = new MappedRange();
+            }
+            m.glId = glId;
+            m.staging = staging;
+            m.offset = offset;
+            m.length = length;
+            m.invalidate = invalidate;
+            m.accessFlags = accessFlags;
+            plainMappings.put(glId, m);
+            return true;
+        } finally { wLock.unlock(); }
+    }
+
+    public boolean takePlainMapping(int glId, MappedRange out) {
+        wLock.lock();
+        try {
+            final MappedRange m = plainMappings.get(glId);
+            if (m == null) return false;
+            copyMappedRange(m, out);
+            removePlainMappingLocked(glId);
+            return true;
+        } finally { wLock.unlock(); }
+    }
+
+    public ByteBuffer takePlainStaging(int glId) {
+        wLock.lock();
+        try { return removePlainMappingLocked(glId); } finally { wLock.unlock(); }
+    }
+
+    public boolean peekPlainMapping(int glId, MappedRange out) {
+        if (fastRead()) return copyMappedRange(plainMappings.get(glId), out);
+        rLock.lock();
+        try { return copyMappedRange(plainMappings.get(glId), out); } finally { rLock.unlock(); }
+    }
+
+    private static boolean copyMappedRange(MappedRange m, MappedRange out) {
+        if (m == null) return false;
+        out.glId = m.glId;
+        out.staging = m.staging;
+        out.offset = m.offset;
+        out.length = m.length;
+        out.invalidate = m.invalidate;
+        out.accessFlags = m.accessFlags;
+        return true;
+    }
+
+    private ByteBuffer removePlainMappingLocked(int glId) {
+        final MappedRange m = plainMappings.remove(glId);
+        if (m == null) return null;
+        final ByteBuffer staging = m.staging;
+        m.staging = null;
+        if (plainMappingPoolCount == plainMappingPool.length) plainMappingPool = Arrays.copyOf(plainMappingPool, plainMappingPoolCount * 2);
+        plainMappingPool[plainMappingPoolCount++] = m;
+        return staging;
+    }
+    public void beginPersistentDrain() { rLock.lock(); }
+    public void endPersistentDrain() { rLock.unlock(); }
    public PersistentMapping getPersistentMapping(int bufferGlId) {
        if (fastRead()) return persistentMappings.get(bufferGlId);
        rLock.lock();
@@ -965,17 +1045,13 @@ public final class ResourceManager {
    public PersistentMapping removePersistentMapping(int bufferGlId) {
        final PersistentMapping dropped;
        wLock.lock();
-        try { dropped = persistentMappings.remove(bufferGlId); mappingsVersion++; } finally { wLock.unlock(); }
+        try {
+            dropped = persistentMappings.remove(bufferGlId);
+            if (dropped != null) mappingsVersion++;
+        } finally { wLock.unlock(); }
        untrackPersistentDirty(dropped);
        return dropped;
    }
-    public PersistentMapping swapPersistentMapping(int bufferGlId, PersistentMapping fresh) {
-        final PersistentMapping prior;
-        wLock.lock();
-        try { prior = persistentMappings.put(bufferGlId, fresh); mappingsVersion++; } finally { wLock.unlock(); }
-        untrackPersistentDirty(prior);
-        return prior;
-    }

    private volatile int mappingsVersion;

@@ -989,8 +1065,9 @@ public final class ResourceManager {
        if (pm != null && !PersistentMapping.isClean(pm.claimDirty())) persistentDirtyCount.decrementAndGet();
    }

-    public void releasePersistentStaging(PersistentMapping pm) {
+    public void releasePersistentStaging(PersistentMapping pm, int glId, String cause) {
        if (pm == null || pm.staging == null) return;
+        if (LOG.isDebugEnabled()) LOG.debug("Persistent mapping released: buffer {} ({} KiB) via {}", glId, pm.length >> 10, cause);
        final TransferThread tt = transferThread;
        final long seq = pm.lastEnqueuedSeq;
        if (tt != null && seq > tt.getSubmittedSeq()) tt.freeAfterSeq(pm.staging, seq);
@@ -1001,24 +1078,20 @@ public final class ResourceManager {
        rLock.lock();
        try {
            final PersistentMapping srcPm = persistentMappings.get(srcGlId);
-            if (srcPm == null) return false;
-            final ByteBuffer slice = srcPm.staging.duplicate();
-            slice.position((int) readOffset).limit((int) (readOffset + size));
-            uploadToBuffer(copyPass, slice, dstHandle, writeOffset, false);
+            if (srcPm == null || !srcPm.covers(readOffset, size)) return false;
+            uploadRangeToBuffer(copyPass, srcPm.staging, srcPm.stagingIndex(readOffset), size, dstHandle, writeOffset, false);
            final PersistentMapping dstPm = persistentMappings.get(dstGlId);
-            if (dstPm != null) {
-                PersistentBufferSync.mirrorPersistentCopy(srcPm.staging, readOffset, dstPm.staging, writeOffset, size);
-            }
+            if (dstPm != null) PersistentBufferSync.mirrorPersistentCopy(srcPm, readOffset, dstPm, writeOffset, size);
            return true;
        } finally { rLock.unlock(); }
    }

-    public boolean enqueuePersistentCopyDeferred(int srcGlId, int dstGlId, long seq,
+    public boolean enqueuePersistentCopyDeferred(int srcGlId, int dstGlId, long seq, long readOffset, long size,
            BiConsumer<PersistentMapping, PersistentMapping> inLock) {
        rLock.lock();
        try {
            final PersistentMapping srcPm = persistentMappings.get(srcGlId);
-            if (srcPm == null) return false;
+            if (srcPm == null || !srcPm.covers(readOffset, size)) return false;
            final PersistentMapping dstPm = persistentMappings.get(dstGlId);
            srcPm.lastEnqueuedSeq = seq;
            inLock.accept(srcPm, dstPm);
@@ -1192,7 +1265,7 @@ public final class ResourceManager {
    public void mirrorArrayShadowFull(int glId, ByteBuffer data) {
        final int len = data.remaining();
        final ByteBuffer shadow = getOrAllocArrayShadow(glId, len);
-        copyShadowRegion(data, data.position(), shadow, 0, len);
+        ByteRegionCopy.copyByteRegion(data, data.position(), shadow, 0, len);
        shadow.position(0).limit(len);
    }

@@ -1206,7 +1279,7 @@ public final class ResourceManager {
                removeArrayShadowLocked(glId);
                return;
            }
-            copyShadowRegion(data, data.position(), shadow, dstOffset, len);
+            ByteRegionCopy.copyByteRegion(data, data.position(), shadow, dstOffset, len);
        } finally { wLock.unlock(); }
    }

@@ -1226,18 +1299,6 @@ public final class ResourceManager {
        arrayShadowWanted.remove(glId);
    }

-    private static void copyShadowRegion(ByteBuffer src, int srcOff, ByteBuffer dst, int dstOff, int len) {
-        if (src.isDirect() && dst.isDirect()) {
-            MemoryUtil.memCopy(MemoryUtil.memAddress(src) + srcOff, MemoryUtil.memAddress(dst) + dstOff, len);
-            return;
-        }
-        final ByteBuffer s = src.duplicate();
-        s.position(srcOff).limit(srcOff + len);
-        final ByteBuffer d = dst.duplicate();
-        d.position(dstOff);
-        d.put(s);
-    }
-
    public EBOSplitScanner.EboSplit[] getOrScanSplits(int glId, int indexType, int sentinel) {
        if (!hasEboShadow(glId)) return null;
        final long version = getEboShadowVersion(glId);
@@ -1502,10 +1563,10 @@ public final class ResourceManager {
        }
    }

-    public static final int COPY_CALLSITE_UPLOAD_BUFFER = 1;
    public static final int COPY_CALLSITE_UPLOAD_TEX_BATCH = 2;
    public static final int COPY_CALLSITE_UPLOAD_TEX_DIRECT = 3;
    public static final int COPY_CALLSITE_ARENA = 4;
+    public static final int COPY_CALLSITE_FILL_BUFFER = 5;

    public boolean arenaUpload(ByteBuffer data, long dstHandle, long dstOffset, boolean cycle) {
        final FrameManager.FrameState f = frameManager.frame();
@@ -1600,7 +1661,13 @@ public final class ResourceManager {
    }

    public void uploadToBuffer(long copyPass, ByteBuffer data, long gpuBuffer, long offset, boolean cycle) {
-        final long size = data.remaining();
+        uploadRangeToBuffer(copyPass, data, data.position(), data.remaining(), gpuBuffer, offset, cycle);
+    }
+
+    public void uploadRangeToBuffer(long copyPass, ByteBuffer src, long srcOff, long size, long gpuBuffer, long dstOff, boolean cycle) {
+        if (srcOff < 0 || size < 0 || srcOff + size > src.capacity()) {
+            throw new IllegalStateException("uploadRangeToBuffer: bad source range srcOff=" + srcOff + " size=" + size + " src.capacity=" + src.capacity());
+        }
        final long xfer = acquireTransferBuffer(size);
        if (xfer == 0) return;

@@ -1609,28 +1676,102 @@ public final class ResourceManager {
        if (mapped == null || mapped.capacity() < size) {
            SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
            returnTransferBuffer(xfer, size);
-            throw new IllegalStateException("uploadToBuffer: bad mapping size=" + size + " mapSize=" + mapSize + " mapped=" + (mapped == null ? "null" : "cap=" + mapped.capacity()));
+            throw new IllegalStateException("uploadRangeToBuffer: bad mapping size=" + size + " mapSize=" + mapSize + " mapped=" + (mapped == null ? "null" : "cap=" + mapped.capacity()));
+        }
+        if (src.isDirect()) {
+            MemoryUtil.memCopy(MemoryUtil.memAddress0(src) + srcOff, MemoryUtil.memAddress0(mapped), size);
+        } else {
+            mapped.put(0, src, (int) srcOff, (int) size);
        }
-        copyMappedFromData(mapped, data, (int) size, COPY_CALLSITE_UPLOAD_BUFFER);
        SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);

        try (var stack = stackPush()) {
-            final SDL_GPUTransferBufferLocation src = SDL_GPUTransferBufferLocation.calloc(stack)
+            final SDL_GPUTransferBufferLocation srcLoc = SDL_GPUTransferBufferLocation.calloc(stack)
                .transfer_buffer(xfer)
                .offset(0);

            final SDL_GPUBufferRegion dst = SDL_GPUBufferRegion.calloc(stack)
                .buffer(gpuBuffer)
-                .offset((int) offset)
+                .offset((int) dstOff)
                .size((int) size);

-            SDL_UploadToGPUBuffer(copyPass, src, dst, cycle);
+            SDL_UploadToGPUBuffer(copyPass, srcLoc, dst, cycle);
        }

        frameManager.recordUploadCommands(size, 1);
        returnTransferBuffer(xfer, size);
    }

+    /**
+     * Fills {@code size} bytes of a buffer by staging {@code pattern} once and uploading it repeatedly. Staging every
+     * byte instead maps a transfer buffer per chunk, which stalls for seconds on the hundreds of megabytes some shader
+     * packs allocate as storage buffers.
+     */
+    public void fillBuffer(long copyPass, ByteBuffer pattern, long gpuBuffer, long offset, long size) {
+        final int chunk = pattern.remaining();
+        if (chunk <= 0 || size <= 0) return;
+        final long xfer = acquireTransferBuffer(chunk);
+        if (xfer == 0) return;
+        try {
+            final ByteBuffer mapped = SDL_MapGPUTransferBuffer(device.getDevice(), xfer, true, getTransferBufferMapSize(chunk));
+            if (mapped == null || mapped.capacity() < chunk) {
+                SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
+                throw new IllegalStateException("fillBuffer: bad mapping size=" + chunk + " mapped=" + (mapped == null ? "null" : "cap=" + mapped.capacity()));
+            }
+            copyMappedFromData(mapped, pattern, chunk, COPY_CALLSITE_FILL_BUFFER);
+            SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
+
+            int uploads = 0;
+            try (var stack = stackPush()) {
+                final SDL_GPUTransferBufferLocation src = SDL_GPUTransferBufferLocation.calloc(stack).transfer_buffer(xfer).offset(0);
+                final SDL_GPUBufferRegion dst = SDL_GPUBufferRegion.calloc(stack).buffer(gpuBuffer);
+                for (long done = 0; done < size; done += chunk) {
+                    dst.offset((int) (offset + done)).size((int) Math.min(chunk, size - done));
+                    SDL_UploadToGPUBuffer(copyPass, src, dst, false);
+                    uploads++;
+                }
+            }
+            frameManager.recordUploadCommands(size, uploads);
+        } finally {
+            returnTransferBuffer(xfer, chunk);
+        }
+    }
+
+    public boolean zeroTexture3D(long copyPass, long gpuTexture, int w, int h, int d, int level, int bytesPerTexel) {
+        final long sliceBytes = (long) w * h * bytesPerTexel;
+        if (sliceBytes <= 0 || sliceBytes > Integer.MAX_VALUE) return false;
+        final long xfer = acquireTransferBuffer(sliceBytes);
+        if (xfer == 0) return false;
+        try {
+            final ByteBuffer mapped = SDL_MapGPUTransferBuffer(device.getDevice(), xfer, true, getTransferBufferMapSize(sliceBytes));
+            if (mapped == null || mapped.capacity() < sliceBytes) {
+                SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
+                return false;
+            }
+            MemoryUtil.memSet(MemoryUtil.memAddress(mapped), 0, sliceBytes);
+            SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
+
+            flushBatchedUploads(copyPass);
+            try (var stack = stackPush()) {
+                final SDL_GPUTextureTransferInfo src = SDL_GPUTextureTransferInfo.calloc(stack).transfer_buffer(xfer).offset(0);
+                final SDL_GPUTextureRegion dst = SDL_GPUTextureRegion.calloc(stack)
+                    .texture(gpuTexture)
+                    .mip_level(level)
+                    .x(0).y(0)
+                    .w(w).h(h).d(1);
+                for (int z = 0; z < d; z++) {
+                    dst.z(z);
+                    SDL_UploadToGPUTexture(copyPass, src, dst, false);
+                }
+            }
+            markTextureContentDefined(gpuTexture);
+            frameManager.recordUploadCommands(sliceBytes * d, d);
+            return true;
+        } finally {
+            returnTransferBuffer(xfer, sliceBytes);
+        }
+    }
+
    public static final int BATCH_SEGMENT_CAPACITY = 4 * 1024 * 1024;

    public void uploadToTexture(long copyPass, ByteBuffer data, long gpuTexture, int x, int y, int w, int h, int level) {
@@ -2506,12 +2647,20 @@ public final class ResourceManager {
        arrayShadowWanted.clear();
        for (ByteBuffer bb : pboStagingData.values()) memFree(bb);
        pboStagingData.clear();
-        for (PersistentMapping pm : persistentMappings.values()) {
+        for (var e : persistentMappings.int2ObjectEntrySet()) {
+            final PersistentMapping pm = e.getValue();
            untrackPersistentDirty(pm);
-            releasePersistentStaging(pm);
+            releasePersistentStaging(pm, e.getIntKey(), "shutdown");
        }
        persistentMappings.clear();
        mappingsVersion++;
+        for (MappedRange m : plainMappings.values()) {
+            if (m.staging != null) memFree(m.staging);
+            m.staging = null;
+        }
+        plainMappings.clear();
+        Arrays.fill(plainMappingPool, null);
+        plainMappingPoolCount = 0;
    }

    public record TextureMeta(int glTarget, int glFormat, int sdlFormat, int width, int height, int depth, int levels, int usage) {}
@@ -329,11 +329,15 @@ public final class TransferThread {
            final ByteBuffer mapped = SDL_MapGPUTransferBuffer(device.getDevice(), xfer, true, mapSize);
            if (mapped != null) {
                final ByteBuffer src = sr.stagingBuffer;
-                final int prevPos = src.position();
-                final int prevLim = src.limit();
-                src.limit((int) (sr.srcOffset + size)).position((int) sr.srcOffset);
-                mapped.put(src);
-                src.limit(prevLim).position(prevPos);
+                if (sr.srcOffset < 0 || sr.srcOffset + size > src.capacity() || size > mapped.capacity()) {
+                    LOG.error("StagingReadUpload out of bounds: srcOffset={} size={} src.capacity={} mapped.capacity={}; upload dropped", sr.srcOffset, size, src.capacity(), mapped.capacity());
+                    SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
+                    resourceManager.returnTransferBufferThreadSafe(xfer, size);
+                    retireSeq(sr.seq);
+                    StagingReadUpload.release(sr);
+                    return;
+                }
+                MemoryUtil.memCopy(MemoryUtil.memAddress0(src) + sr.srcOffset, MemoryUtil.memAddress0(mapped), size);
            }
            SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
            recordBufferUpload(xfer, size, sr.dstGpuBuffer, sr.dstOffset, sr.seq, sr.cycle);
@@ -53,6 +53,7 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 import java.util.function.IntConsumer;
+import java.util.function.Supplier;

 import static org.lwjgl.sdl.SDLGPU.*;
 import static org.lwjgl.system.MemoryStack.*;
@@ -64,6 +65,7 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntArrays;
 import it.unimi.dsi.fastutil.ints.IntIterator;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
@@ -234,7 +236,35 @@ public final class ShaderManager {
        final int shaderKind = shaderKindFor(obj);
        final int glType = obj.type;
        final String finalSrc = obj.source;
-        obj.spirvFuture = AngelicaWorkers.submit(() -> compileStageAsync(finalSrc, shaderKind, glType, shader));
+        final QueuedCompile compile = new QueuedCompile(() -> compileStageAsync(finalSrc, shaderKind, glType, shader));
+        AngelicaWorkers.run(compile);
+        obj.queuedCompile = compile;
+        obj.spirvFuture = compile.result;
+    }
+
+    private static final class QueuedCompile implements Runnable {
+        private final AtomicBoolean claimed = new AtomicBoolean();
+        private final Supplier<AsyncCompile> work;
+        final CompletableFuture<AsyncCompile> result = new CompletableFuture<>();
+
+        QueuedCompile(Supplier<AsyncCompile> work) {
+            this.work = work;
+        }
+
+        @Override
+        public void run() {
+            if (!claimed.compareAndSet(false, true)) return;
+            try {
+                result.complete(work.get());
+            } catch (Throwable t) {
+                result.completeExceptionally(t);
+            }
+        }
+
+        /** Stops the compile if no thread has started it; false when it is running or done. */
+        boolean cancel() {
+            return claimed.compareAndSet(false, true);
+        }
    }

    private static AsyncCompile compileStageAsync(String src, int shaderKind, int glType, int shader) {
@@ -377,6 +407,10 @@ public final class ShaderManager {
        final SpirvCompiler.Result r;
        final boolean alreadyRemapped;
        if (obj.spirvFuture != null) {
+            if (obj.queuedCompile != null) {
+                obj.queuedCompile.run();
+                obj.queuedCompile = null;
+            }
            final AsyncCompile compiled = obj.spirvFuture.join();
            obj.spirvFuture = null;
            r = compiled.result();
@@ -431,6 +465,9 @@ public final class ShaderManager {
        final CompletableFuture<AsyncCompile> future = obj.spirvFuture;
        if (future == null) return;
        obj.spirvFuture = null;
+        final QueuedCompile queued = obj.queuedCompile;
+        obj.queuedCompile = null;
+        if (queued != null && queued.cancel()) return;
        future.thenAccept(ShaderManager::freeSpirvResult);
    }

@@ -567,7 +604,7 @@ public final class ShaderManager {
        registerExtraNames(prog, vs.reflection);
        registerExtraNames(prog, fs.reflection);

-        for (final String name : prog.allSamplerNames) ensureLocation(prog, name);
+        registerSamplerLocations(prog, vs.reflection, fs.reflection);
        for (final String name : prog.allImageNames) ensureLocation(prog, name);

        prog.buildUniformSlotArrays();
@@ -611,7 +648,7 @@ public final class ShaderManager {

        applyUboMembers(prog, refl, false);
        registerExtraNames(prog, refl);
-        for (final String name : prog.allSamplerNames) ensureLocation(prog, name);
+        registerSamplerLocations(prog, refl);
        for (final String name : prog.allImageNames) ensureLocation(prog, name);
        prog.buildUniformSlotArrays();

@@ -820,8 +857,52 @@ public final class ShaderManager {
        return built;
    }

+    private static ShaderDiskCache.Key variantKey(String vertexSource, List<UscaledRetype.Attrib> attribs) {
+        final ShaderDiskCache.Key key = ShaderDiskCache.key("sdl-vertex-variant").str(SpirvCompiler.toolchainId()).str(CrossCompileUtil.spvcId())
+            .str(vertexSource).i(attribs.size());
+        for (UscaledRetype.Attrib a : attribs) {
+            key.str(a.name()).i(a.location()).i(a.declVecSize()).i(a.boundVecSize()).i(a.signed() ? 1 : 0);
+        }
+        return key;
+    }
+
    private VertexVariant buildVertexVariant(int program, ProgramObject prog, List<UscaledRetype.Attrib> attribs) {
-        final String preprocessed = SpirvCompiler.preprocess(prog.vertexSource, Shaderc.shaderc_vertex_shader, "variant" + program, SpirvCompiler.Options.vulkanForced460Core());
+        final ShaderDiskCache.Key diskKey = ShaderDiskCache.isEnabled() ? variantKey(prog.vertexSource, attribs) : null;
+        final ShaderStageSerializer.Stage cached = diskKey != null ? loadStage(diskKey) : null;
+        final ShaderStageSerializer.Stage stage = cached != null ? cached : compileVertexVariant(program, prog.vertexSource, attribs, diskKey);
+        if (stage == null) return null;
+
+        final StageReflection refl = stage.reflection();
+        if (!sameVaryingLayout(prog.vertexReflection.vsOutputs(), refl.vsOutputs())) {
+            LOG.error("Vertex attribute conversion: program {} variant changed VS output locations; the fragment stage is patched against the base layout. Falling back to normalized coercion.", program);
+            return null;
+        }
+        final VertexVariant v = new VertexVariant();
+        v.spirv = ShaderCacheIO.toNative(stage.spirv());
+
+        final Object2IntOpenHashMap<String> bindings = new Object2IntOpenHashMap<>(prog.attribLocationBindings);
+        bindings.defaultReturnValue(-1);
+        for (UscaledRetype.Attrib a : attribs) bindings.put(a.name() + UscaledRetype.SUFFIX, a.location());
+        v.inputMask = patchAttribLocations(v.spirv, refl, bindings, v.inputVecSize, v.inputBaseType, null, null);
+        if (v.inputMask != prog.vertexInputMask) {
+            memFree(v.spirv);
+            LOG.error("Vertex attribute conversion: program {} variant resolved inputs to 0x{} but the program binds 0x{}; a renamed input landed on the wrong location. Falling back to normalized coercion.",
+                program, Integer.toHexString(v.inputMask), Integer.toHexString(prog.vertexInputMask));
+            return null;
+        }
+        v.sdlShader = createSDLShader(v.spirv, SDL_GPU_SHADERSTAGE_VERTEX, prog.vertexResources.numSamplers(), prog.vertexResources.numUBOs(), prog.vertexResources.numStorageBuffers(), prog.vertexResources.numStorageTextures());
+        if (v.sdlShader == 0) {
+            memFree(v.spirv);
+            LOG.error("Vertex attribute conversion: program {} variant shader creation failed: {}", program, SDLError.SDL_GetError());
+            return null;
+        }
+        LOG.info("Vertex attribute conversion: program {} converted {}", program, attribs);
+        if (SystemProperties.dumpShaders()) dumpVariantSource(program, stage.source());
+        return v;
+    }
+
+    private static ShaderStageSerializer.Stage compileVertexVariant(int program, String vertexSource, List<UscaledRetype.Attrib> attribs, ShaderDiskCache.Key diskKey) {
+        final String preprocessed = SpirvCompiler.preprocess(vertexSource, Shaderc.shaderc_vertex_shader, "variant" + program, SpirvCompiler.Options.vulkanForced460Core());
        if (preprocessed == null) {
            LOG.warn("Vertex attribute conversion: program {} preprocessing failed; falling back to normalized coercion, values will be scaled", program);
            return null;
@@ -839,32 +920,11 @@ public final class ShaderManager {
        try {
            remapSpirvForSDLGPU(r.spirv(), GL20.GL_VERTEX_SHADER);
            final StageReflection refl = reflectStage(r.spirv(), true);
-            if (!sameVaryingLayout(prog.vertexReflection.vsOutputs(), refl.vsOutputs())) {
-                LOG.error("Vertex attribute conversion: program {} variant changed VS output locations; the fragment stage is patched against the base layout. Falling back to normalized coercion.", program);
-                return null;
+            final byte[] heap = ShaderCacheIO.toHeap(r.spirv());
+            if (diskKey != null && refl != StageReflection.EMPTY) {
+                ShaderDiskCache.put(diskKey, ShaderStageSerializer.encode(heap, refl, GraphicsBindingMap.EMPTY, null, src));
            }
-            final VertexVariant v = new VertexVariant();
-            v.spirv = copyBuffer(r.spirv());
-
-            final Object2IntOpenHashMap<String> bindings = new Object2IntOpenHashMap<>(prog.attribLocationBindings);
-            bindings.defaultReturnValue(-1);
-            for (UscaledRetype.Attrib a : attribs) bindings.put(a.name() + UscaledRetype.SUFFIX, a.location());
-            v.inputMask = patchAttribLocations(v.spirv, refl, bindings, v.inputVecSize, v.inputBaseType, null, null);
-            if (v.inputMask != prog.vertexInputMask) {
-                memFree(v.spirv);
-                LOG.error("Vertex attribute conversion: program {} variant resolved inputs to 0x{} but the program binds 0x{}; a renamed input landed on the wrong location. Falling back to normalized coercion.",
-                    program, Integer.toHexString(v.inputMask), Integer.toHexString(prog.vertexInputMask));
-                return null;
-            }
-            v.sdlShader = createSDLShader(v.spirv, SDL_GPU_SHADERSTAGE_VERTEX, prog.vertexResources.numSamplers(), prog.vertexResources.numUBOs(), prog.vertexResources.numStorageBuffers(), prog.vertexResources.numStorageTextures());
-            if (v.sdlShader == 0) {
-                memFree(v.spirv);
-                LOG.error("Vertex attribute conversion: program {} variant shader creation failed: {}", program, SDLError.SDL_GetError());
-                return null;
-            }
-            LOG.info("Vertex attribute conversion: program {} converted {}", program, attribs);
-            if (SystemProperties.dumpShaders()) dumpVariantSource(program, src);
-            return v;
+            return new ShaderStageSerializer.Stage(heap, refl, GraphicsBindingMap.EMPTY, Set.of(), src);
        } finally {
            memFree(r.spirv());
        }
@@ -1476,6 +1536,7 @@ public final class ShaderManager {
        public boolean deletePending;
        public int attachCount;
        public CompletableFuture<AsyncCompile> spirvFuture;
+        QueuedCompile queuedCompile;
        public StageReflection reflection = StageReflection.EMPTY;
        public GraphicsBindingMap graphicsBindingMap = GraphicsBindingMap.EMPTY;
        public Set<String> boolUniforms = Set.of();
@@ -1520,6 +1581,7 @@ public final class ShaderManager {
    public record StageReflection(
        ResourceCounts counts,
        List<String> samplerNames,      // SAMPLED_IMAGE, sorted by binding (post-remap)
+        List<String> unusedSamplerNames, // declared samplers the entry point never reads
        List<String> extraUniformNames, // SEPARATE_SAMPLERS - registered in nameToLocation only
        List<String> storageImageNames, // SEPARATE_IMAGE + STORAGE_IMAGE (RO + RW), sorted by binding (post-remap)
        int uboSize,                    // binding-0 UBO total size in bytes; 0 if absent
@@ -1535,7 +1597,7 @@ public final class ShaderManager {
        BlockReflection[] blocks
    ) {
        public static final StageReflection EMPTY = new StageReflection(
-            ResourceCounts.EMPTY, List.of(), List.of(), List.of(), 0, List.of(), List.of(), List.of(), List.of(),
+            ResourceCounts.EMPTY, List.of(), List.of(), List.of(), List.of(), 0, List.of(), List.of(), List.of(), List.of(),
            -1, 0, 0, 0, 0, BlockReflection.emptyBlocks());
    }

@@ -1739,6 +1801,7 @@ public final class ShaderManager {
        return new StageReflection(
            new ResourceCounts(samplerNames.size(), numUBOs, numStorageBuffers, numStorageTextures),
            samplerNames,
+            unusedSamplerNames(compiler, resources, stack),
            extraNames,
            storageImageNames,
            uboSize,
@@ -1822,6 +1885,36 @@ public final class ShaderManager {
        });
    }

+    private static List<String> unusedSamplerNames(long compiler, long resources, MemoryStack stack) {
+        final PointerBuffer pActive = stack.mallocPointer(1);
+        final PointerBuffer pActiveResources = stack.mallocPointer(1);
+        if (Spvc.spvc_compiler_get_active_interface_variables(compiler, pActive) != Spvc.SPVC_SUCCESS
+            || Spvc.spvc_compiler_create_shader_resources_for_active_variables(compiler, pActiveResources, pActive.get(0)) != Spvc.SPVC_SUCCESS) {
+            return List.of();
+        }
+        final IntOpenHashSet active = new IntOpenHashSet();
+        forEachResource(pActiveResources.get(0), Spvc.SPVC_RESOURCE_TYPE_SAMPLED_IMAGE, stack, (i, r) -> active.add(r.id()));
+        final List<String> unused = new ArrayList<>();
+        forEachResource(resources, Spvc.SPVC_RESOURCE_TYPE_SAMPLED_IMAGE, stack, (i, r) -> {
+            if (active.contains(r.id())) return;
+            final String name = Spvc.spvc_compiler_get_name(compiler, r.id());
+            if (name != null && !name.isEmpty()) unused.add(name);
+        });
+        return unused;
+    }
+
+    private static void registerSamplerLocations(ProgramObject prog, StageReflection... stages) {
+        final Set<String> read = new HashSet<>();
+        for (StageReflection stage : stages) {
+            for (String name : stage.samplerNames()) {
+                if (!stage.unusedSamplerNames().contains(name)) read.add(name);
+            }
+        }
+        for (String name : prog.allSamplerNames) {
+            if (read.contains(name)) ensureLocation(prog, name);
+        }
+    }
+
    private static void collectResourceNames(long resources, long compiler, int resourceType, List<String> out, MemoryStack stack) {
        forEachResource(resources, resourceType, stack, (i, r) -> {
            final String name = r.nameString();
@@ -102,6 +102,7 @@ final class ShaderStageSerializer {
        out.writeInt(r.counts().numStorageBuffers());
        out.writeInt(r.counts().numStorageTextures());
        writeStrList(out, r.samplerNames());
+        writeStrList(out, r.unusedSamplerNames());
        writeStrList(out, r.extraUniformNames());
        writeStrList(out, r.storageImageNames());
        out.writeInt(r.uboSize());
@@ -139,6 +140,7 @@ final class ShaderStageSerializer {
    private static StageReflection readReflection(ByteBuffer in) {
        final ResourceCounts counts = new ResourceCounts(in.getInt(), in.getInt(), in.getInt(), in.getInt());
        final List<String> samplerNames = readStrList(in);
+        final List<String> unusedSamplerNames = readStrList(in);
        final List<String> extraNames = readStrList(in);
        final List<String> storageImageNames = readStrList(in);
        final int uboSize = in.getInt();
@@ -156,7 +158,7 @@ final class ShaderStageSerializer {
        for (int b = 0; b < blockCount; b++) {
            blocks[b] = new BlockReflection(in.getInt(), in.getInt(), readList(in, ShaderStageSerializer::readMember), in.get() != 0);
        }
-        return new StageReflection(counts, samplerNames, extraNames, storageImageNames, uboSize, uboMembers, vsInputs, vsOutputs, fsInputs,
+        return new StageReflection(counts, samplerNames, unusedSamplerNames, extraNames, storageImageNames, uboSize, uboMembers, vsInputs, vsOutputs, fsInputs,
            maxOutputLocation, roBuf, rwBuf, roTex, rwTex, blocks);
    }

@@ -1,32 +1,36 @@
 package com.gtnewhorizons.angelica.sdlgpu.device;

 import org.junit.jupiter.api.Test;
+import org.lwjgl.system.Platform;

+import static com.gtnewhorizons.angelica.sdlgpu.device.Device.driverCandidates;
 import static com.gtnewhorizons.angelica.sdlgpu.device.Device.metalNeedsNewerSdl;
-import static com.gtnewhorizons.angelica.sdlgpu.device.Device.resolveDriverName;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.lwjgl.sdl.SDLVersion.SDL_VERSIONNUM;

 class DriverSelectionTest {

    @Test
-    void windowsWithoutUserHintForcesVulkan() {
-        assertEquals("vulkan", resolveDriverName("", true));
+    void autoUsesThePlatformOrder() {
+        assertArrayEquals(new String[] { "metal", "vulkan" }, driverCandidates("", Platform.MACOSX));
+        assertArrayEquals(new String[] { "vulkan", "direct3d12" }, driverCandidates("", Platform.WINDOWS));
+        assertArrayEquals(new String[] { "vulkan" }, driverCandidates("", Platform.LINUX));
    }

    @Test
-    void userHintWinsOnWindows() {
-        assertNull(resolveDriverName("direct3d12", true));
-        assertNull(resolveDriverName("vulkan", true));
+    void requestedDriverGoesFirstWithoutDuplicates() {
+        assertArrayEquals(new String[] { "vulkan", "metal" }, driverCandidates("vulkan", Platform.MACOSX));
+        assertArrayEquals(new String[] { "direct3d12", "vulkan" }, driverCandidates("direct3d12", Platform.WINDOWS));
+        assertArrayEquals(new String[] { "vulkan" }, driverCandidates("vulkan", Platform.LINUX));
+        assertArrayEquals(new String[] { "Vulkan", "direct3d12" }, driverCandidates("Vulkan", Platform.WINDOWS));
    }

    @Test
-    void nonWindowsIsUntouched() {
-        assertNull(resolveDriverName("", false));
-        assertNull(resolveDriverName("direct3d12", false));
+    void unsupportedDriverStillFallsBack() {
+        assertArrayEquals(new String[] { "metal", "vulkan", "direct3d12" }, driverCandidates("metal", Platform.WINDOWS));
+        assertArrayEquals(new String[] { "bogus", "vulkan" }, driverCandidates("bogus", Platform.LINUX));
    }

    @Test
@@ -0,0 +1,393 @@
+package com.gtnewhorizons.angelica.sdlgpu.glsm;
+
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.opengl.GL31;
+import org.lwjgl.opengl.GL43;
+import org.lwjgl.opengl.GL44;
+import org.lwjgl.system.MemoryUtil;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@Tag("glsm-sdl")
+@ExtendWith(GlsmSdlFrameExtension.class)
+class GlsmSdlBufferMappingLifetimeTest {
+
+    private static final int SIZE = 4096;
+    private static final int PERSISTENT_STORAGE = GL44.GL_MAP_PERSISTENT_BIT | GL30.GL_MAP_WRITE_BIT | GL44.GL_MAP_COHERENT_BIT | GL44.GL_CLIENT_STORAGE_BIT;
+    private static final int PERSISTENT_MAP = GL44.GL_MAP_PERSISTENT_BIT | GL30.GL_MAP_WRITE_BIT | GL44.GL_MAP_COHERENT_BIT;
+    private static final int PLAIN_MAP = GL30.GL_MAP_WRITE_BIT | GL30.GL_MAP_INVALIDATE_BUFFER_BIT;
+
+    @BeforeAll
+    static void boot() {
+        GlsmSdlHeadlessRig.boot();
+    }
+
+    private static void fill(ByteBuffer buf, int seed) {
+        for (int i = 0; i < buf.capacity(); i++) buf.put(i, (byte) (seed * 37 + i * 7 + 1));
+    }
+
+    private static void assertPattern(ByteBuffer actual, int seed) {
+        for (int i = 0; i < actual.capacity(); i++) {
+            assertEquals((byte) (seed * 37 + i * 7 + 1), actual.get(i), "byte " + i + " of pattern " + seed);
+        }
+    }
+
+    private static ByteBuffer readBack(int target, int size) {
+        final ByteBuffer out = MemoryUtil.memAlloc(size);
+        GLStateManager.glGetBufferSubData(target, 0, out);
+        return out;
+    }
+
+    private static ByteBuffer mapPersistent(int target, int id) {
+        GLStateManager.glBindBuffer(target, id);
+        GLStateManager.glBufferStorage(target, SIZE, PERSISTENT_STORAGE);
+        return GLStateManager.glMapBufferRange(target, 0, SIZE, PERSISTENT_MAP);
+    }
+
+    @Test
+    void bufferDataOnPersistentlyMappedBufferIsRefusedAndMappingSurvives() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        ByteBuffer out = null;
+        try {
+            final ByteBuffer mapped = mapPersistent(target, id);
+            assertNotNull(mapped);
+            GLStateManager.glBufferData(target, SIZE * 2L, GL15.GL_STATIC_DRAW);
+            fill(mapped, 1);
+            GLStateManager.glFlushMappedBufferRange(target, 0, SIZE);
+            out = readBack(target, SIZE);
+            assertPattern(out, 1);
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void persistentMapWithoutPersistentStorageReturnsNull() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferData(target, (long) SIZE, GL15.GL_STATIC_DRAW);
+            assertNull(GLStateManager.glMapBufferRange(target, 0, SIZE, PERSISTENT_MAP));
+        } finally {
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void secondPersistentMapReturnsNullAndFirstStillRoundTrips() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        ByteBuffer out = null;
+        try {
+            final ByteBuffer first = mapPersistent(target, id);
+            assertNotNull(first);
+            assertNull(GLStateManager.glMapBufferRange(target, 0, SIZE, PERSISTENT_MAP));
+            fill(first, 2);
+            GLStateManager.glFlushMappedBufferRange(target, 0, SIZE);
+            out = readBack(target, SIZE);
+            assertPattern(out, 2);
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void twoBuffersMappedNonPersistentlyKeepTheirOwnData() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int a = GLStateManager.glGenBuffers();
+        final int b = GLStateManager.glGenBuffers();
+        ByteBuffer outA = null;
+        ByteBuffer outB = null;
+        try {
+            GLStateManager.glBindBuffer(target, a);
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+            GLStateManager.glBindBuffer(target, b);
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+
+            GLStateManager.glBindBuffer(target, a);
+            final ByteBuffer mapA = GLStateManager.glMapBufferRange(target, 0, SIZE, PLAIN_MAP);
+            assertNotNull(mapA);
+            GLStateManager.glBindBuffer(target, b);
+            final ByteBuffer mapB = GLStateManager.glMapBufferRange(target, 0, SIZE, PLAIN_MAP);
+            assertNotNull(mapB);
+            fill(mapA, 3);
+            fill(mapB, 4);
+
+            GLStateManager.glBindBuffer(target, a);
+            assertTrue(GLStateManager.glUnmapBuffer(target));
+            GLStateManager.glBindBuffer(target, b);
+            assertTrue(GLStateManager.glUnmapBuffer(target));
+
+            GLStateManager.glBindBuffer(target, a);
+            outA = readBack(target, SIZE);
+            assertPattern(outA, 3);
+            GLStateManager.glBindBuffer(target, b);
+            outB = readBack(target, SIZE);
+            assertPattern(outB, 4);
+        } finally {
+            if (outA != null) MemoryUtil.memFree(outA);
+            if (outB != null) MemoryUtil.memFree(outB);
+            GLStateManager.glDeleteBuffers(a);
+            GLStateManager.glDeleteBuffers(b);
+        }
+    }
+
+    @Test
+    void unmapOfUnmappedBufferReturnsFalseAndLeavesOtherMappingIntact() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int mappedId = GLStateManager.glGenBuffers();
+        final int idle = GLStateManager.glGenBuffers();
+        ByteBuffer out = null;
+        try {
+            GLStateManager.glBindBuffer(target, mappedId);
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+            final ByteBuffer map = GLStateManager.glMapBufferRange(target, 0, SIZE, PLAIN_MAP);
+            assertNotNull(map);
+            fill(map, 5);
+
+            GLStateManager.glBindBuffer(target, idle);
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+            assertFalse(GLStateManager.glUnmapBuffer(target));
+
+            GLStateManager.glBindBuffer(target, mappedId);
+            assertTrue(GLStateManager.glUnmapBuffer(target));
+            out = readBack(target, SIZE);
+            assertPattern(out, 5);
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            GLStateManager.glDeleteBuffers(mappedId);
+            GLStateManager.glDeleteBuffers(idle);
+        }
+    }
+
+    @Test
+    void outOfRangeUniformSubDataIsIgnored() {
+        final int ubo = GLStateManager.glGenBuffers();
+        final ByteBuffer data = MemoryUtil.memAlloc(256);
+        final ByteBuffer big = MemoryUtil.memAlloc(64);
+        try {
+            fill(data, 6);
+            fill(big, 7);
+            GLStateManager.glBindBuffer(GL31.GL_UNIFORM_BUFFER, ubo);
+            GLStateManager.glBufferData(GL31.GL_UNIFORM_BUFFER, data, GL15.GL_DYNAMIC_DRAW);
+            assertDoesNotThrow(() -> {
+                big.clear();
+                GLStateManager.glBufferSubData(GL31.GL_UNIFORM_BUFFER, 1024, big);
+                big.clear();
+                GLStateManager.glBufferSubData(GL31.GL_UNIFORM_BUFFER, 224, big);
+                big.clear();
+                GLStateManager.glBufferSubData(GL31.GL_UNIFORM_BUFFER, -8, big);
+            });
+        } finally {
+            MemoryUtil.memFree(data);
+            MemoryUtil.memFree(big);
+            GLStateManager.glDeleteBuffers(ubo);
+        }
+    }
+
+    @Test
+    void outOfRangeCopyBufferSubDataIsIgnored() {
+        final int src = GLStateManager.glGenBuffers();
+        final int dst = GLStateManager.glGenBuffers();
+        final ByteBuffer data = MemoryUtil.memAlloc(256);
+        ByteBuffer outDst = null;
+        try {
+            fill(data, 6);
+            GLStateManager.glBindBuffer(GL31.GL_COPY_READ_BUFFER, src);
+            GLStateManager.glBufferData(GL31.GL_COPY_READ_BUFFER, data, GL15.GL_STATIC_DRAW);
+            GLStateManager.glBindBuffer(GL31.GL_COPY_WRITE_BUFFER, dst);
+            data.clear();
+            GLStateManager.glBufferData(GL31.GL_COPY_WRITE_BUFFER, data, GL15.GL_STATIC_DRAW);
+            GLStateManager.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, 200, 0, 128);
+            GLStateManager.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, 0, 200, 128);
+            GLStateManager.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, -4, 0, 16);
+            outDst = readBack(GL31.GL_COPY_WRITE_BUFFER, 256);
+            assertPattern(outDst, 6);
+        } finally {
+            if (outDst != null) MemoryUtil.memFree(outDst);
+            MemoryUtil.memFree(data);
+            GLStateManager.glDeleteBuffers(src);
+            GLStateManager.glDeleteBuffers(dst);
+        }
+    }
+
+    @Test
+    void outOfRangeClearBufferSubDataIsIgnored() {
+        final int clearStart = 64;
+        final int clearEnd = 96;
+        final int ssbo = GLStateManager.glGenBuffers();
+        final ByteBuffer data = MemoryUtil.memAlloc(256);
+        ByteBuffer out = null;
+        try {
+            fill(data, 8);
+            GLStateManager.glBindBuffer(GL43.GL_SHADER_STORAGE_BUFFER, ssbo);
+            GLStateManager.glBufferData(GL43.GL_SHADER_STORAGE_BUFFER, data, GL15.GL_DYNAMIC_DRAW);
+            GLStateManager.glClearBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, GL30.GL_R8, clearStart, clearEnd - clearStart, GL11.GL_RED, GL11.GL_UNSIGNED_BYTE, null);
+            GLStateManager.glClearBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, GL30.GL_R8, 200, 128, GL11.GL_RED, GL11.GL_UNSIGNED_BYTE, null);
+            GLStateManager.glClearBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, GL30.GL_R8, -4, 16, GL11.GL_RED, GL11.GL_UNSIGNED_BYTE, null);
+            GLStateManager.glClearBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, GL30.GL_R8, 1024, 16, GL11.GL_RED, GL11.GL_UNSIGNED_BYTE, null);
+            GlsmSdlHeadlessRig.endFrame();
+            GlsmSdlHeadlessRig.beginFrame();
+            out = readBack(GL43.GL_SHADER_STORAGE_BUFFER, 256);
+            for (int i = 0; i < 256; i++) {
+                final boolean cleared = i >= clearStart && i < clearEnd;
+                assertEquals(cleared ? 0 : data.get(i), out.get(i), cleared ? "in-range clear did not zero byte " + i : "out-of-range clear touched byte " + i);
+            }
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            MemoryUtil.memFree(data);
+            GLStateManager.glDeleteBuffers(ssbo);
+        }
+    }
+
+    @Test
+    void secondBufferStorageIsRefused() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferStorage(target, SIZE, PERSISTENT_STORAGE);
+            GLStateManager.glBufferStorage(target, SIZE * 2L, PERSISTENT_STORAGE);
+            assertEquals(GL11.GL_TRUE, GLStateManager.glGetBufferParameteri(target, GL44.GL_BUFFER_IMMUTABLE_STORAGE));
+            assertEquals(SIZE, GLStateManager.glGetBufferParameteri(target, GL15.GL_BUFFER_SIZE));
+        } finally {
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void namedBufferDataOnImmutableStorageIsRefused() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferStorage(target, SIZE, PERSISTENT_STORAGE);
+            GLStateManager.glNamedBufferData(id, SIZE * 2L, GL15.GL_STATIC_DRAW);
+            assertEquals(SIZE, GLStateManager.glGetBufferParameteri(target, GL15.GL_BUFFER_SIZE));
+        } finally {
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void bufferStorageWithNullDataMarksBufferImmutable() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferStorage(target, (ByteBuffer) null, PERSISTENT_STORAGE);
+            assertEquals(GL11.GL_TRUE, GLStateManager.glGetBufferParameteri(target, GL44.GL_BUFFER_IMMUTABLE_STORAGE));
+        } finally {
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    private static void assertBufferDataUnmapsPlainMapping(int target) {
+        final int id = GLStateManager.glGenBuffers();
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+            assertNotNull(GLStateManager.glMapBufferRange(target, 0, SIZE, PLAIN_MAP));
+            GLStateManager.glBufferData(target, SIZE, GL15.GL_DYNAMIC_DRAW);
+            assertNotNull(GLStateManager.glMapBufferRange(target, 0, SIZE, PLAIN_MAP));
+            assertTrue(GLStateManager.glUnmapBuffer(target));
+        } finally {
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void bufferDataOnMappedArrayBufferUnmapsIt() {
+        assertBufferDataUnmapsPlainMapping(GL15.GL_ARRAY_BUFFER);
+    }
+
+    @Test
+    void bufferDataOnMappedUniformBufferUnmapsIt() {
+        assertBufferDataUnmapsPlainMapping(GL31.GL_UNIFORM_BUFFER);
+    }
+
+    @Test
+    void outOfRangeFlushOfPersistentMappingIsIgnored() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        ByteBuffer out = null;
+        try {
+            final ByteBuffer mapped = mapPersistent(target, id);
+            assertNotNull(mapped);
+            GLStateManager.glFlushMappedBufferRange(target, SIZE, 64);
+            GLStateManager.glFlushMappedBufferRange(target, SIZE - 16, 64);
+            GLStateManager.glFlushMappedBufferRange(target, -8, 16);
+            fill(mapped, 9);
+            GLStateManager.glFlushMappedBufferRange(target, 0, SIZE);
+            out = readBack(target, SIZE);
+            assertPattern(out, 9);
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void persistentMappingAtNonZeroOffsetRoundTrips() {
+        final int target = GL15.GL_ARRAY_BUFFER;
+        final int id = GLStateManager.glGenBuffers();
+        final ByteBuffer out = MemoryUtil.memAlloc(SIZE);
+        try {
+            GLStateManager.glBindBuffer(target, id);
+            GLStateManager.glBufferStorage(target, SIZE * 2L, PERSISTENT_STORAGE);
+            final ByteBuffer mapped = GLStateManager.glMapBufferRange(target, SIZE, SIZE, PERSISTENT_MAP);
+            assertNotNull(mapped);
+            fill(mapped, 10);
+            GLStateManager.glFlushMappedBufferRange(target, 0, SIZE);
+            GLStateManager.glGetBufferSubData(target, SIZE, out);
+            assertPattern(out, 10);
+        } finally {
+            MemoryUtil.memFree(out);
+            GLStateManager.glDeleteBuffers(id);
+        }
+    }
+
+    @Test
+    void copyFromPersistentMappingShorterThanBufferReadsGpuContents() {
+        final int src = GLStateManager.glGenBuffers();
+        final int dst = GLStateManager.glGenBuffers();
+        final ByteBuffer data = MemoryUtil.memAlloc(SIZE * 2);
+        ByteBuffer out = null;
+        try {
+            fill(data, 11);
+            GLStateManager.glBindBuffer(GL31.GL_COPY_READ_BUFFER, src);
+            GLStateManager.glBufferStorage(GL31.GL_COPY_READ_BUFFER, data, PERSISTENT_STORAGE);
+            assertNotNull(GLStateManager.glMapBufferRange(GL31.GL_COPY_READ_BUFFER, 0, SIZE, PERSISTENT_MAP));
+            GLStateManager.glBindBuffer(GL31.GL_COPY_WRITE_BUFFER, dst);
+            GLStateManager.glBufferData(GL31.GL_COPY_WRITE_BUFFER, SIZE, GL15.GL_STATIC_DRAW);
+            GLStateManager.glCopyBufferSubData(GL31.GL_COPY_READ_BUFFER, GL31.GL_COPY_WRITE_BUFFER, SIZE, 0, 256);
+            out = readBack(GL31.GL_COPY_WRITE_BUFFER, 256);
+            for (int i = 0; i < 256; i++) {
+                assertEquals(data.get(SIZE + i), out.get(i), "byte " + i);
+            }
+        } finally {
+            if (out != null) MemoryUtil.memFree(out);
+            MemoryUtil.memFree(data);
+            GLStateManager.glDeleteBuffers(src);
+            GLStateManager.glDeleteBuffers(dst);
+        }
+    }
+}
@@ -1,7 +1,7 @@
 package com.gtnewhorizons.angelica.sdlgpu.glsm;

 import com.gtnewhorizons.angelica.glsm.GLStateManager;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import com.gtnewhorizons.angelica.glsm.testutil.Reflect;
 import com.gtnewhorizons.angelica.sdlgpu.SDLGPULWJGLService;
 import org.junit.jupiter.api.BeforeAll;
@@ -35,7 +35,7 @@ class GlsmSdlLWJGLServiceRoutingTest {
    }

    private static int glsmUnpackAlignment() {
-        final PixelUnpackState state = Reflect.get(glsmContext(), "pixelUnpackState");
+        final PixelStoreState state = Reflect.get(glsmContext(), "pixelUnpackState");
        return state.alignment();
    }

@@ -0,0 +1,33 @@
+package com.gtnewhorizons.angelica.sdlgpu.glsm;
+
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.testutil.TestThreads;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+@Tag("glsm-sdl")
+@ExtendWith(GlsmSdlFrameExtension.class)
+class GlsmSdlOffContextCreationTest {
+
+    @BeforeAll
+    static void boot() {
+        GlsmSdlHeadlessRig.boot();
+    }
+
+    @Test
+    void creationWithoutContextThrows() throws InterruptedException {
+        TestThreads.run("sdl-no-context", () -> assertThrows(IllegalStateException.class, GLStateManager::glGenTextures));
+    }
+
+    @Test
+    void creationOnRenderThreadPasses() {
+        final int texture = GLStateManager.glGenTextures();
+        assertNotEquals(0, texture);
+        GLStateManager.glDeleteTextures(texture);
+    }
+}
@@ -8,6 +8,8 @@ import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL43;

 import java.nio.ByteBuffer;

@@ -45,6 +47,30 @@ class GlsmSdlReadbackTest {
        GLStateManager.glDeleteTextures(texture);
    }

+    @Test
+    void getBufferSubDataSeesSameFrameStorageBufferWrite() {
+        final int size = 64;
+        final int ssbo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL43.GL_SHADER_STORAGE_BUFFER, ssbo);
+
+        final ByteBuffer initial = BufferUtils.createByteBuffer(size);
+        final ByteBuffer update = BufferUtils.createByteBuffer(size);
+        for (int i = 0; i < size; i++) {
+            initial.put(i, (byte) 0x11);
+            update.put(i, (byte) (i + 1));
+        }
+        GLStateManager.glBufferData(GL43.GL_SHADER_STORAGE_BUFFER, initial, GL15.GL_DYNAMIC_DRAW);
+        GLStateManager.glBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, 0, update);
+
+        final ByteBuffer dst = BufferUtils.createByteBuffer(size);
+        GLStateManager.glGetBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, 0, dst);
+
+        for (int i = 0; i < size; i++) {
+            assertEquals((byte) (i + 1), dst.get(i), "byte " + i + " should hold the same-frame sub-data write");
+        }
+        GLStateManager.glDeleteBuffers(ssbo);
+    }
+
    @Test
    void readPixelsSeesPriorDraw() {
        GlsmSdlHeadlessRig.bindTarget();
@@ -52,7 +52,7 @@ class AbsoluteCopyRegionTest {
        for (int i = 0; i < 32; i++) src.put(i, (byte) i);
        src.position(7).limit(24);
        dst.position(9).limit(28);
-        PersistentBufferSync.mirrorPersistentCopy(src, 4, dst, 16, 8);
+        PersistentBufferSync.mirrorPersistentCopy(new PersistentMapping(src, 0L, 32L, 0), 4, new PersistentMapping(dst, 0L, 32L, 0), 16, 8);
        for (int i = 0; i < 8; i++) assertEquals((byte) (4 + i), dst.get(16 + i));
        assertEquals(7, src.position());
        assertEquals(24, src.limit());
@@ -40,7 +40,7 @@ class PersistentBufferSyncDirtyGateTest {

        final ByteBuffer staging = MemoryUtil.memCalloc(64);
        try {
-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 64, 0);

            assertFalse(rm.hasDirtyPersistentRegions(), "a mapping with no writes is not dirty");
@@ -70,7 +70,7 @@ class PersistentBufferSyncDirtyGateTest {

        final ByteBuffer staging = MemoryUtil.memCalloc(64);
        try {
-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 64, 0);

            sync.onPersistentBufferWrite(1, 0, 16);
@@ -95,7 +95,7 @@ class PersistentBufferSyncDirtyGateTest {
        try {
            final int atStart = rm.getMappingsVersion();

-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            final int afterPut = rm.getMappingsVersion();
            assertNotEquals(atStart, afterPut, "adding a mapping must move the version");

@@ -107,7 +107,8 @@ class PersistentBufferSyncDirtyGateTest {
            sync.enqueueDirtyPersistentRegions();
            assertEquals(afterPut, rm.getMappingsVersion(), "dirtying and draining is not a mapping change");

-            rm.swapPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.removePersistentMapping(1);
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            final int afterSwap = rm.getMappingsVersion();
            assertNotEquals(afterPut, afterSwap, "swapping a mapping must move the version");

@@ -129,7 +130,7 @@ class PersistentBufferSyncDirtyGateTest {

        final ByteBuffer staging = MemoryUtil.memCalloc(256);
        try {
-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 256, 0);

            for (int i = 0; i < 10; i++) {
@@ -156,13 +157,14 @@ class PersistentBufferSyncDirtyGateTest {
        final ByteBuffer first = MemoryUtil.memCalloc(64);
        final ByteBuffer second = MemoryUtil.memCalloc(64);
        try {
-            rm.putPersistentMapping(1, new PersistentMapping(first, 0L, first.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(first, 0L, first.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 64, 0);
            sync.onPersistentBufferWrite(1, 0, 16);
            sync.enqueueDirtyPersistentRegions();
            assertEquals(1, sink.enqueued);

-            rm.swapPersistentMapping(1, new PersistentMapping(second, 0L, second.capacity(), 0));
+            rm.removePersistentMapping(1);
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(second, 0L, second.capacity(), 0));
            sync.onPersistentBufferWrite(1, 0, 16);
            sync.enqueueDirtyPersistentRegions();
            assertEquals(2, sink.enqueued, "the drain must see the replacement, not a stale snapshot");
@@ -184,7 +186,7 @@ class PersistentBufferSyncDirtyGateTest {

        final ByteBuffer staging = MemoryUtil.memCalloc(4096);
        try {
-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 4096, 0);

            final int writers = 6;
@@ -235,7 +237,7 @@ class PersistentBufferSyncDirtyGateTest {
        final ByteBuffer staging = MemoryUtil.memCalloc(64);
        try {
            final PersistentMapping pm = new PersistentMapping(staging, 0L, staging.capacity(), 0);
-            rm.putPersistentMapping(1, pm);
+            rm.putPersistentMappingIfAbsent(1, pm);
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, 64, 0);

            final long[] stampAtEnqueue = {-1L};
@@ -267,7 +269,7 @@ class PersistentBufferSyncDirtyGateTest {
        final int seedCount = 100;
        for (int i = 0; i < seedCount; i++) {
            final ByteBuffer b = MemoryUtil.memAlloc(64);
-            rm.putPersistentMapping(i, new PersistentMapping(b, 0L, b.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(i, new PersistentMapping(b, 0L, b.capacity(), 0));
        }

        final AtomicBoolean stop = new AtomicBoolean(false);
@@ -279,7 +281,7 @@ class PersistentBufferSyncDirtyGateTest {
            int next = seedCount;
            while (!stop.get()) {
                final ByteBuffer b = MemoryUtil.memAlloc(64);
-                rm.putPersistentMapping(next, new PersistentMapping(b, 0L, b.capacity(), 0));
+                rm.putPersistentMappingIfAbsent(next, new PersistentMapping(b, 0L, b.capacity(), 0));
                rm.removePersistentMapping(next - 50);
                next++;
                if (next > seedCount + 10000) next = seedCount;
@@ -37,13 +37,13 @@ class PersistentDrainBoundaryTest {
        final ResourceManager rm;
        final PersistentBufferSync sync;
        final RecordingSink sink = new RecordingSink();
-        final ByteBuffer staging = MemoryUtil.memCalloc(4096);
+        final ByteBuffer staging = MemoryUtil.memCalloc(16384);

        Fixture() {
            final SdlTestRig rig = SdlTestRig.create();
            rm = rig.resourceManager;
            sync = new PersistentBufferSync(rig.frameManager, rm, sink);
-            rm.putPersistentMapping(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
+            rm.putPersistentMappingIfAbsent(1, new PersistentMapping(staging, 0L, staging.capacity(), 0));
            SdlReflect.recordBuffer(rm, 1, 0xCAFEBABEL, staging.capacity(), 0);
        }

@@ -18,14 +18,14 @@ class ReleasePersistentStagingTest {
    @Test
    void nullPmAndNullStagingNoOp() {
        final ResourceManager rm = SdlTestRig.resourceManager();
-        rm.releasePersistentStaging(null);
-        rm.releasePersistentStaging(new PersistentMapping(null, 0L, 0L, 0));
+        rm.releasePersistentStaging(null, 7, "unmap");
+        rm.releasePersistentStaging(new PersistentMapping(null, 0L, 0L, 0), 7, "unmap");
    }

    @Test
    void noTransferThreadFreesInline() {
        final ResourceManager rm = SdlTestRig.resourceManager();
-        rm.releasePersistentStaging(new PersistentMapping(MemoryUtil.memAlloc(24), 0L, 24L, 0));
+        rm.releasePersistentStaging(new PersistentMapping(MemoryUtil.memAlloc(24), 0L, 24L, 0), 7, "unmap");
    }

    @Test
@@ -39,7 +39,7 @@ class ReleasePersistentStagingTest {
        try {
            final PersistentMapping pm = new PersistentMapping(MemoryUtil.memAlloc(24), 0L, 24L, 0);
            pm.lastEnqueuedSeq = 0L;
-            rm.releasePersistentStaging(pm);
+            rm.releasePersistentStaging(pm, 7, "unmap");
            assertEquals(0, SdlReflect.pendingFreeCount(tt));
        } finally { shutdown(tt); }
    }
@@ -55,7 +55,7 @@ class ReleasePersistentStagingTest {
        try {
            final PersistentMapping pm = new PersistentMapping(MemoryUtil.memAlloc(24), 0L, 24L, 0);
            pm.lastEnqueuedSeq = 50L;
-            rm.releasePersistentStaging(pm);
+            rm.releasePersistentStaging(pm, 7, "unmap");
            assertEquals(1, SdlReflect.pendingFreeCount(tt));
        } finally { shutdown(tt); }
    }
@@ -64,7 +64,7 @@ class ReleasePersistentStagingTest {
    void deleteBufferReleasesPersistentStaging() {
        final ResourceManager rm = SdlTestRig.resourceManager();
        SdlReflect.recordBuffer(rm, 7, 0xDEADBEEFL, 64, 0);
-        rm.putPersistentMapping(7, new PersistentMapping(MemoryUtil.memCalloc(64), 0L, 64L, 0));
+        rm.putPersistentMappingIfAbsent(7, new PersistentMapping(MemoryUtil.memCalloc(64), 0L, 64L, 0));

        rm.deleteBuffer(7);

@@ -84,7 +84,7 @@ class ReleasePersistentStagingTest {
            final PersistentMapping pm = new PersistentMapping(staging, 0L, staging.capacity(), 0);
            pm.lastEnqueuedSeq = 99L;
            SdlReflect.recordBuffer(rm, 7, 0xDEADBEEFL, 64, 0);
-            rm.putPersistentMapping(7, pm);
+            rm.putPersistentMappingIfAbsent(7, pm);

            rm.deleteBuffer(7);

@@ -3,7 +3,9 @@ package com.gtnewhorizons.angelica.sdlgpu.resource;
 import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
 import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
 import org.junit.jupiter.api.Test;
+import org.lwjgl.system.MemoryUtil;

+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
@@ -159,4 +161,99 @@ class ResourceManagerConcurrencyTest {

        assertTrue(created.get() >= threads, "each thread should have created at least one FBO");
    }
+
+    @Test
+    void putPlainMappingIfAbsent_oneWinnerAcrossThreads() throws Exception {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        final int glId = 9001;
+        final int n = 8;
+        final AtomicInteger winners = new AtomicInteger();
+
+        race(n, slot -> {
+            final ByteBuffer staging = MemoryUtil.memAlloc(16);
+            if (rm.putPlainMappingIfAbsent(glId, staging, 0L, 16L, false, slot)) winners.incrementAndGet();
+            else MemoryUtil.memFree(staging);
+        });
+
+        assertEquals(1, winners.get(), "exactly one thread may map the buffer");
+        final ByteBuffer staging = rm.takePlainStaging(glId);
+        assertTrue(staging != null, "the winning mapping must still be registered");
+        MemoryUtil.memFree(staging);
+        assertNull(rm.takePlainStaging(glId));
+    }
+
+    @Test
+    void plainMappingTakenFromAnotherThread() throws Exception {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        final int glId = 9002;
+        final ByteBuffer staging = MemoryUtil.memAlloc(32);
+        try {
+            assertTrue(rm.putPlainMappingIfAbsent(glId, staging, 8L, 32L, true, 0x2A));
+            final MappedRange peeked = new MappedRange();
+            final MappedRange taken = new MappedRange();
+            final AtomicBoolean peekedOk = new AtomicBoolean();
+            final AtomicBoolean takenOk = new AtomicBoolean();
+            final AtomicBoolean secondTake = new AtomicBoolean(true);
+
+            race(1, slot -> {
+                peekedOk.set(rm.peekPlainMapping(glId, peeked));
+                takenOk.set(rm.takePlainMapping(glId, taken));
+                secondTake.set(rm.takePlainMapping(glId, new MappedRange()));
+            });
+
+            assertTrue(peekedOk.get(), "peek from another thread must see the mapping");
+            assertSame(staging, peeked.staging);
+            assertTrue(takenOk.get(), "take from another thread must succeed");
+            assertSame(staging, taken.staging);
+            assertEquals(glId, taken.glId);
+            assertEquals(8L, taken.offset);
+            assertEquals(32L, taken.length);
+            assertTrue(taken.invalidate);
+            assertEquals(0x2A, taken.accessFlags);
+            assertFalse(secondTake.get(), "a taken mapping must be gone");
+            assertFalse(rm.peekPlainMapping(glId, new MappedRange()));
+        } finally {
+            MemoryUtil.memFree(staging);
+        }
+    }
+
+    @Test
+    void deleteBufferFromAnotherThreadDropsPlainMapping() throws Exception {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        final int glId = 9003;
+        assertTrue(rm.putPlainMappingIfAbsent(glId, MemoryUtil.memAlloc(16), 0L, 16L, false, 0));
+
+        race(1, slot -> rm.deleteBuffer(glId));
+
+        assertFalse(rm.peekPlainMapping(glId, new MappedRange()));
+        assertFalse(rm.takePlainMapping(glId, new MappedRange()));
+        final ByteBuffer again = MemoryUtil.memAlloc(16);
+        assertTrue(rm.putPlainMappingIfAbsent(glId, again, 0L, 16L, false, 0), "a deleted buffer's id must be mappable again");
+        MemoryUtil.memFree(rm.takePlainStaging(glId));
+    }
+
+    @Test
+    void persistentAndPlainMappingsExcludeEachOther() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        final int plainFirst = 9004;
+        final int persistentFirst = 9005;
+        final ByteBuffer plainStaging = MemoryUtil.memAlloc(16);
+        final ByteBuffer persistentStaging = MemoryUtil.memAlloc(16);
+        final ByteBuffer refused = MemoryUtil.memAlloc(16);
+        try {
+            assertTrue(rm.putPlainMappingIfAbsent(plainFirst, plainStaging, 0L, 16L, false, 0));
+            assertFalse(rm.putPersistentMappingIfAbsent(plainFirst, new PersistentMapping(refused, 0L, 16L, 0)), "persistent map of a plain-mapped buffer must be refused");
+            assertNull(rm.getPersistentMapping(plainFirst));
+
+            assertTrue(rm.putPersistentMappingIfAbsent(persistentFirst, new PersistentMapping(persistentStaging, 0L, 16L, 0)));
+            assertFalse(rm.putPlainMappingIfAbsent(persistentFirst, refused, 0L, 16L, false, 0), "plain map of a persistently mapped buffer must be refused");
+            assertFalse(rm.peekPlainMapping(persistentFirst, new MappedRange()));
+        } finally {
+            rm.takePlainStaging(plainFirst);
+            rm.removePersistentMapping(persistentFirst);
+            MemoryUtil.memFree(plainStaging);
+            MemoryUtil.memFree(persistentStaging);
+            MemoryUtil.memFree(refused);
+        }
+    }
 }
Author	SHA1	Message	Date
Eclipse-Sol	3389b952d0	Fix SDL compile failure when an image atomic's result is used (#2218 )	2026-10-04 18:56:12 -07:00
Jason Mitchell	b49d37d827	Ignore additional tags when deriving the mod version (#2219 )	2026-10-04 18:33:06 -07:00
Jason Mitchell	12857006c6	Harden SDL-GPU buffer mapping lifetime (#2217 )	2026-10-04 16:31:48 -07:00
Eclipse-Sol	38af64f10c	Initial commit for shader-loading-optimizations (#2213 )	2026-10-04 15:36:50 -07:00
Jason Mitchell	10922edca3	Include missed scripts (#2216 )	2026-10-04 15:22:09 -07:00
Jason Mitchell	2a8c8756d3	Add renderer selection to video settings - (#2215 )	2026-10-04 15:16:51 -07:00
Jason Mitchell	23e36f2b76	Narrow overly broad transformer exclusions for PowerConverters (#2214 )	2026-10-04 14:27:43 -07:00
Jason Mitchell	fcf8ad064a	Fix terrain disappearing at screen edges with compute culling (#2212 )	2026-10-04 13:05:14 -07:00
Jason Mitchell	6dfb0312b1	Answer legacy stack and client state queries from GLSM (#2211 )	2026-10-04 11:43:56 -07:00
Eclipse-Sol	0a4d48964e	Cache Iris Shaders (#2206 )	2026-10-03 20:06:39 -07:00
Ranzu	231a2ab216	Add Darkmode Transformer target (#2205 )	2026-10-03 15:28:37 -07:00
Jason Mitchell	61bb779dea	Fix crash when mods measure text off-thread with a custom font (#2204 )	2026-10-03 15:28:15 -07:00
Jason Mitchell	7cd97d1216	Fix HUD caching flicker and match non-cached GL state (#2201 )	2026-10-03 13:19:29 -07:00
Eclipse-Sol	fe82cd320a	Plenty of fixes for GTNH (#2202 )	2026-10-03 13:19:15 -07:00
Li Xiangrong	c7a0f3a208	Default raw custom textures to bilinear filtering and clamping (#2198 )	2026-10-03 11:57:30 -07:00
Matt Van Horn	338d94197c	Settle frame pacing after an inconsistent vsync gate (#2197 )	2026-10-03 11:51:30 -07:00
Death Fuel	75a0278138	Fix splash issues (#2200 )	2026-10-03 11:42:57 -07:00