fix(vk): a load-at-create start whose mesh fallback builds stall in the driver goes on to the title, with progress on the way #1450

Merged
HumanBean merged 2 commits from HumanBean/Longshot:fix/load-at-create-stall into main 2026-11-17 20:19:32 +00:00
Owner

Type: fix · Risk: medium · Tested on: Linux, RTX 3090 (the start through the changed function; game-free checks left to CI) · Needs: Windows, AMD without mesh shaders (RX 5600 XT / 5700 XT, RDNA1; Vega)

Why

On RX 5600 XT and RX 5700 XT cards (AMD's Windows driver 26.5.2 and 26.10.1), rc.7 never gets past "Loading pipelines". After the update the first start reaches 100% and then freezes. Every start after that stays at 0% on "Loading the shader cache" until the window is closed. Setting RX_VK_LOAD=start reaches the title on the same install (zimoroque's tests on #1373). An rc.5 report on a Vega iGPU (7730U, #1262) ends at the same point.

The cause is precompile_at_create in gpu/vk/vk_draw.cpp. Under RX_VK_LOAD=create, the default since #975 on the compute fallback too, the start calls it before the title. On a GPU without mesh shaders it builds every mesh fallback program's compute pipelines in the driver there. It also asks the caches for those programs' noted pipelines. It never tells the start-up screen anything, so the screen shows !total, which reads "Loading the shader cache" at 0% (vk_progress.h). It then joins its threads with no bound.

precompile_run, the path RX_VK_LOAD=start takes, does the same builds. Since 2026-11-08 ("stuck at 99%" on an RX 5700 XT) it goes on to the game after RX_VK_PRECOMPILE_STALL_S (30 s) with nothing finished. rc.7 made it much more likely that this pass runs long: its translator changed (#906's soa fallback layout, #1086), so every fallback pipeline is compiled again. A close in this pass did not end within the close's 10 s ("the preparation did not stop within 10 s: closing anyway" in both logs). So the close's save of the pipeline cache never ran, and the next start began again from nothing.

The logs agree. The last line before the close is pcache_init's vk: pipeline cache ... (1405978 KB). precompile_at_create's own vk: precompile: load at create ... line never comes, and the close census shows zero programs created.

Fixes #1373, #1405. See #1404 (the same PC, its close recorded as a crash), #1430 (its launcher half, "Prepare shaders" at 0%, is the builder's, not this) and #1262.

How to reproduce

Seen on: Windows 10/11, RX 5600 XT (26.5.2, 26.10.1) and RX 5700 XT (26.10.1), v3.0.0-rc.7
Settings and switches: defaults (Auto: the task + mesh compute fallback, RX_VK_LOAD=create)
Steps: update to rc.7 and start the game
Expected: the screen counts the work and reaches the title
Actual: 100% then a freeze at the first start, then 0% "Loading the shader cache" at every start, ending with the preparation did not stop within 10 s: closing anyway on close

What changed

precompile_at_create now works like precompile_run. It reports progress, waits with a bound, and keeps what it built.

  • vk: gpu/vk/bounded_wait.h (new, standard library only). bounded_wait::wait ticks the progress and ends in one of three ways: every item is done, the window is closed, or no item has finished for the stall's seconds.
  • vk: precompile_at_create(progress) in gpu/vk/vk_draw.cpp, given its progress by precompile_run:
    • Each fallback program's compute pipelines and each kept program's noted pipelines count as one step on the start-up screen and in a 10 s log line.
    • Its workers' state is on the heap: NoteRef copies, not pointers into refs.
    • The wait is bounded by RX_VK_PRECOMPILE_STALL_S, the same switch and default (30 s) as precompile_run. When it stalls or the window closes, no new item is taken, the builds still in the driver are detached and noted (prepare_left_workers_note), and their state is never freed. A close therefore returns at once, and the close's own pipeline cache save runs.
    • A pass of RX_VK_PRECOMPILE_SAVE_S (30 s) or more writes the pipeline cache before the title, as precompile_run's does (precompile_save::due).
  • vk: gpu/vk/switches.def: RX_VK_PRECOMPILE_STALL_S's row names this pass.
  • tests: tests/test_bounded_wait.py with tests/bounded_wait_test.cpp (the wait against a fake clock, and the wiring). tests/test_fallback_loaded.py follows the new signature.

A program whose fallback build is still in the driver after the start has gone on keeps compute_state 1. Its draws are left out until that build ends, which is how precompile_run's stall already behaves.

Measurements

Verdict: a hang fix, so there are no numbers to compare. This PC can't show the stall (an RTX 3090 has mesh shaders, so the pass has nothing to build). The game-free test shows the bound, and the in-game run here shows the default start still reaching the title through the changed function. The hardware run is asked of the Test Farm below.

Flags and settings

No new switch. RX_VK_PRECOMPILE_STALL_S and RX_VK_PRECOMPILE_SAVE_S now also apply to the load-at-create start.

Flag What it is Before this PR After this PR Effect Helps / doesn't help / untested Recommendation
RX_VK_PRECOMPILE_STALL_S seconds with nothing finished before the start goes on 30, RX_VK_LOAD=start only 30, both loads a stuck or very slow fallback build no longer holds the start untested on RDNA1 (Test Farm asked) keep 30; 0 waits for all
RX_VK_PRECOMPILE_SAVE_S a pass this long writes the pipeline cache before the title 30, the precompile and the warm pass 30, the load-at-create pass too the compiled fallback pipelines survive to the next start untested on RDNA1 keep 30

Testing

Tested:

  • Linux, RTX 3090: the renderer built with this change (clang, the dev build's renderer-only pack on base 8e9cfc3a), and the game started through it. See the --tested-in-game comment for what the log showed.
  • No checks were run on this PC: this PC runs no test suites. Forgejo CI runs tests/run_all.py, including the new tests/test_bounded_wait.py and the changed tests/test_fallback_loaded.py.
  • A second agent did a cold code review. Its findings: nothing serious. It flagged one gap, that a close did not note the left workers, and this PR now fixes that.

Not tested: a real stall, or a long fallback pass on AMD's Windows driver. I don't have that hardware.

Must be tested:

  • Windows, AMD RX 5600 XT / 5700 XT (RDNA1) or Vega, AMD's proprietary driver: start the game twice with defaults from a cache rc.7 made, expecting the screen to count N / M and reach the title both times, the log showing vk: precompile: load at create: ... steps and then the load at create (RX_VK_LOAD=create) summary or nothing finished for 30 s: the game starts (Test Farm: @Beanstalk, asked in the comments)

Risks

What could break: on a fallback GPU a start whose builds stall now plays with those programs' draws left out until the driver finishes them, rather than never starting. Every load-at-create start with something to build waits at least one 100 ms round.

Turning it off: RX_VK_PRECOMPILE_STALL_S=0 waits for every build as before (progress and the save stay); revert for the rest.

Compatibility: Nothing changes for caches, options or MKWVK_API_VERSION.

Issues

Fixes #1373
Fixes #1405
See #1404, #1430, #1262

Checklist

Everyone

  • One topic.
  • The title is a Conventional Commit (type(scope): description) of the status line's type.
  • Why gives the reason plainly and links the issues that fit (the tracker searched).
  • Measurements has a verdict, or one line saying why there is nothing to measure.
  • Testing names what was tested, what wasn't, and what must still be tested, where and how.
  • Rebased on current main.
  • python -I -B tests/run_all.py passes (any failure that also fails on main is named). Not run on this PC; Forgejo CI runs it.
  • No game files, dumps, build output or generated files.
  • third_party/ untouched (a new folder with a PROVENANCE.md instead).
  • The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled.

When it applies

  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.
  • A game-free test added for the fix, failing on main and passing here. Written as the first commit; not run here, CI runs it.
  • A check under tests/ that reads changed source updated in this PR, not weakened.
  • Docs updated (the switch table's row).

🤖 Generated with Claude Code

**Type:** fix · **Risk:** medium · **Tested on:** Linux, RTX 3090 (the start through the changed function; game-free checks left to CI) · **Needs:** Windows, AMD without mesh shaders (RX 5600 XT / 5700 XT, RDNA1; Vega) ## Why On RX 5600 XT and RX 5700 XT cards (AMD's Windows driver 26.5.2 and 26.10.1), rc.7 never gets past "Loading pipelines". After the update the first start reaches 100% and then freezes. Every start after that stays at 0% on "Loading the shader cache" until the window is closed. Setting `RX_VK_LOAD=start` reaches the title on the same install ([zimoroque's tests on #1373](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1373)). An rc.5 report on a Vega iGPU (7730U, [#1262](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1262)) ends at the same point. The cause is `precompile_at_create` in `gpu/vk/vk_draw.cpp`. Under `RX_VK_LOAD=create`, the default since [#975](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/975) on the compute fallback too, the start calls it before the title. On a GPU without mesh shaders it builds every mesh fallback program's compute pipelines in the driver there. It also asks the caches for those programs' noted pipelines. It never tells the start-up screen anything, so the screen shows `!total`, which reads "Loading the shader cache" at 0% (`vk_progress.h`). It then joins its threads with no bound. `precompile_run`, the path `RX_VK_LOAD=start` takes, does the same builds. Since 2026-11-08 ("stuck at 99%" on an RX 5700 XT) it goes on to the game after `RX_VK_PRECOMPILE_STALL_S` (30 s) with nothing finished. rc.7 made it much more likely that this pass runs long: its translator changed ([#906](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/906)'s soa fallback layout, [#1086](https://git.magicbean.dev/MagicBeanDev/Longshot/pulls/1086)), so every fallback pipeline is compiled again. A close in this pass did not end within the close's 10 s ("the preparation did not stop within 10 s: closing anyway" in both logs). So the close's save of the pipeline cache never ran, and the next start began again from nothing. The logs agree. The last line before the close is `pcache_init`'s `vk: pipeline cache ... (1405978 KB)`. `precompile_at_create`'s own `vk: precompile: load at create ...` line never comes, and the close census shows zero programs created. Fixes [#1373](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1373), [#1405](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1405). See [#1404](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1404) (the same PC, its close recorded as a crash), [#1430](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1430) (its launcher half, "Prepare shaders" at 0%, is the builder's, not this) and [#1262](https://git.magicbean.dev/MagicBeanDev/Longshot/issues/1262). ## How to reproduce **Seen on:** Windows 10/11, RX 5600 XT (26.5.2, 26.10.1) and RX 5700 XT (26.10.1), v3.0.0-rc.7 **Settings and switches:** defaults (Auto: the task + mesh compute fallback, `RX_VK_LOAD=create`) **Steps:** update to rc.7 and start the game **Expected:** the screen counts the work and reaches the title **Actual:** 100% then a freeze at the first start, then 0% "Loading the shader cache" at every start, ending with `the preparation did not stop within 10 s: closing anyway` on close ## What changed `precompile_at_create` now works like `precompile_run`. It reports progress, waits with a bound, and keeps what it built. - vk: `gpu/vk/bounded_wait.h` (new, standard library only). `bounded_wait::wait` ticks the progress and ends in one of three ways: every item is done, the window is closed, or no item has finished for the stall's seconds. - vk: `precompile_at_create(progress)` in `gpu/vk/vk_draw.cpp`, given its progress by `precompile_run`: - Each fallback program's compute pipelines and each kept program's noted pipelines count as one step on the start-up screen and in a 10 s log line. - Its workers' state is on the heap: `NoteRef` copies, not pointers into `refs`. - The wait is bounded by `RX_VK_PRECOMPILE_STALL_S`, the same switch and default (30 s) as `precompile_run`. When it stalls or the window closes, no new item is taken, the builds still in the driver are detached and noted (`prepare_left_workers_note`), and their state is never freed. A close therefore returns at once, and the close's own pipeline cache save runs. - A pass of `RX_VK_PRECOMPILE_SAVE_S` (30 s) or more writes the pipeline cache before the title, as `precompile_run`'s does (`precompile_save::due`). - vk: `gpu/vk/switches.def`: `RX_VK_PRECOMPILE_STALL_S`'s row names this pass. - tests: `tests/test_bounded_wait.py` with `tests/bounded_wait_test.cpp` (the wait against a fake clock, and the wiring). `tests/test_fallback_loaded.py` follows the new signature. A program whose fallback build is still in the driver after the start has gone on keeps `compute_state` 1. Its draws are left out until that build ends, which is how `precompile_run`'s stall already behaves. ## Measurements **Verdict:** a hang fix, so there are no numbers to compare. This PC can't show the stall (an RTX 3090 has mesh shaders, so the pass has nothing to build). The game-free test shows the bound, and the in-game run here shows the default start still reaching the title through the changed function. The hardware run is asked of the Test Farm below. ### Flags and settings No new switch. `RX_VK_PRECOMPILE_STALL_S` and `RX_VK_PRECOMPILE_SAVE_S` now also apply to the load-at-create start. | Flag | What it is | Before this PR | After this PR | Effect | Helps / doesn't help / untested | Recommendation | |---|---|---|---|---|---|---| | `RX_VK_PRECOMPILE_STALL_S` | seconds with nothing finished before the start goes on | 30, `RX_VK_LOAD=start` only | 30, both loads | a stuck or very slow fallback build no longer holds the start | untested on RDNA1 (Test Farm asked) | keep 30; 0 waits for all | | `RX_VK_PRECOMPILE_SAVE_S` | a pass this long writes the pipeline cache before the title | 30, the precompile and the warm pass | 30, the load-at-create pass too | the compiled fallback pipelines survive to the next start | untested on RDNA1 | keep 30 | ## Testing **Tested:** - Linux, RTX 3090: the renderer built with this change (clang, the dev build's renderer-only pack on base 8e9cfc3a), and the game started through it. See the `--tested-in-game` comment for what the log showed. - No checks were run on this PC: this PC runs no test suites. Forgejo CI runs `tests/run_all.py`, including the new `tests/test_bounded_wait.py` and the changed `tests/test_fallback_loaded.py`. - A second agent did a cold code review. Its findings: nothing serious. It flagged one gap, that a close did not note the left workers, and this PR now fixes that. **Not tested:** a real stall, or a long fallback pass on AMD's Windows driver. I don't have that hardware. **Must be tested:** - Windows, AMD RX 5600 XT / 5700 XT (RDNA1) or Vega, AMD's proprietary driver: start the game twice with defaults from a cache rc.7 made, expecting the screen to count `N / M` and reach the title both times, the log showing `vk: precompile: load at create: ... steps` and then the `load at create (RX_VK_LOAD=create)` summary or `nothing finished for 30 s: the game starts` (Test Farm: @Beanstalk, asked in the comments) ## Risks **What could break:** on a fallback GPU a start whose builds stall now plays with those programs' draws left out until the driver finishes them, rather than never starting. Every load-at-create start with something to build waits at least one 100 ms round. **Turning it off:** `RX_VK_PRECOMPILE_STALL_S=0` waits for every build as before (progress and the save stay); revert for the rest. **Compatibility:** Nothing changes for caches, options or `MKWVK_API_VERSION`. ## Issues Fixes #1373 Fixes #1405 See #1404, #1430, #1262 ## Checklist ### Everyone - [x] One topic. - [x] The title is a Conventional Commit (`type(scope): description`) of the status line's type. - [x] Why gives the reason plainly and links the issues that fit (the tracker searched). - [x] Measurements has a verdict, or one line saying why there is nothing to measure. - [x] Testing names what was tested, what wasn't, and what must still be tested, where and how. - [x] Rebased on current `main`. - [ ] `python -I -B tests/run_all.py` passes (any failure that also fails on `main` is named). Not run on this PC; Forgejo CI runs it. - [x] No game files, dumps, build output or generated files. - [x] `third_party/` untouched (a new folder with a `PROVENANCE.md` instead). - [x] The license is OK: GPL-3.0-or-later, nothing incompatible and nothing decompiled. ### When it applies - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. - [ ] A game-free test added for the fix, failing on `main` and passing here. Written as the first commit; not run here, CI runs it. - [x] A check under `tests/` that reads changed source updated in this PR, not weakened. - [x] Docs updated (the switch table's row). 🤖 Generated with [Claude Code](https://claude.com/claude-code)
tests/test_bounded_wait.py with tests/bounded_wait_test.cpp: gpu/vk/bounded_wait.h's wait
(done, the window closed, slow builds, builds that never finish, the switch at 0) and its
wiring into precompile_at_create. Fails on main: precompile_at_create takes no progress and
joins its workers with no bound (Longshot #1373, #1405).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
fix(vk): a load-at-create start whose mesh fallback builds stall in the driver goes on to the title, with progress on the way
Some checks failed
CI / Python source checks (ubuntu-24.04, part 1/2) (pull_request) Has been skipped
CI / Python source checks (ubuntu-24.04, part 2/2) (pull_request) Has been skipped
CI / SPIR-V fixtures (global narrow load/store, direct surface atomics, F2I immediate) (pull_request) Has been skipped
Third-party parts / The same as upstream (pull_request) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 12s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 18s
CI / Workflow lint (actionlint) (pull_request) Successful in 22s
Website / Website on Cloudflare (pull_request_target) Has been skipped
Third-party parts / As their notes say (pull_request) Successful in 31s
PR description / Description follows the template (pull_request_target) Failing after 6s
beanstalk/approval approved by HumanBean (reviewed)
beanstalk/windows+amd+amd-proprietary+gpu-rx-5xxx_vega-* 0/1 pass, 0 running, 0 queued
732aa8ab3a
On an RX 5600 XT and an RX 5700 XT (AMD's Windows driver, mesh programs through the compute
fallback) every start of rc.7 sat at 0%, "Loading the shader cache", until the window was
closed (Longshot #1373, #1405). Under RX_VK_LOAD=create, the default, precompile_at_create
built every mesh fallback program's compute pipelines in the driver before the title,
told the start-up screen nothing, and joined its threads with no bound; RX_VK_LOAD=start's
precompile_run, which goes on after RX_VK_PRECOMPILE_STALL_S without progress, reached the
title on the same install.

- gpu/vk/bounded_wait.h (new, standard library only): the wait, ended by done, the window
  closed, or no item finished for the stall's seconds.
- gpu/vk/vk_draw.cpp precompile_at_create: takes the screen's progress (precompile_run hands
  it on), its workers' state on the heap, the wait bounded by RX_VK_PRECOMPILE_STALL_S;
  gone on (stalled or closed), no new item is taken and the builds still in the driver are
  left running; a pass of RX_VK_PRECOMPILE_SAVE_S or more writes the pipeline cache before
  the title, as precompile_run's does. A close now returns at once, so the close's own save
  of the pipeline cache runs.
- gpu/vk/switches.def: RX_VK_PRECOMPILE_STALL_S's row names this pass too.
- tests/test_fallback_loaded.py: precompile_at_create's new signature.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Author
Owner

Tested in game: Linux, RTX 3090 (NVIDIA, native mesh shaders), headless start on a dev runtime over base 8e9cfc3a with this change's renderer: the start ran through the new precompile_at_create (after the warm pass: 32655 noted + 9927 compute pipelines into the cache in 37.7 s), logged 'vk: precompile: load at create (RX_VK_LOAD=create): 32390 noted pipelines found ... 0 mesh fallback programs kept ready ... in 920 ms' and went on to play frames (167 fps, 0 draws left out). This GPU has nothing for the pass to build, so the stall bound and the progress were NOT exercised here: they need an AMD card without mesh shaders on Windows (Test Farm asked). The pack predates the last small edit (prepare_left_workers_note on a close too).

Tested in game: Linux, RTX 3090 (NVIDIA, native mesh shaders), headless start on a dev runtime over base 8e9cfc3a with this change's renderer: the start ran through the new precompile_at_create (after the warm pass: 32655 noted + 9927 compute pipelines into the cache in 37.7 s), logged 'vk: precompile: load at create (RX_VK_LOAD=create): 32390 noted pipelines found ... 0 mesh fallback programs kept ready ... in 920 ms' and went on to play frames (167 fps, 0 draws left out). This GPU has nothing for the pass to build, so the stall bound and the progress were NOT exercised here: they need an AMD card without mesh shaders on Windows (Test Farm asked). The pack predates the last small edit (prepare_left_workers_note on a close too).
Author
Owner

@Beanstalk On Windows with an AMD GPU that has no mesh shaders (an RX 5600 XT or 5700 XT, RDNA1, or a Vega), with the AMD proprietary driver and default settings: build this branch, start the game once to the title, quit, then start it again. Expected: the loading screen counts 'N / M pipelines' instead of sitting at 0% on 'Loading the shader cache', and both starts reach the title. The log should have 'vk: precompile: load at create' lines, ending with either the 'load at create (RX_VK_LOAD=create)' summary or 'nothing finished for 30 s: the game starts'. Please compare against main, which on these cards stays at 0% until the window is closed (issues 1373 and 1405).

@Beanstalk On Windows with an AMD GPU that has no mesh shaders (an RX 5600 XT or 5700 XT, RDNA1, or a Vega), with the AMD proprietary driver and default settings: build this branch, start the game once to the title, quit, then start it again. Expected: the loading screen counts 'N / M pipelines' instead of sitting at 0% on 'Loading the shader cache', and both starts reach the title. The log should have 'vk: precompile: load at create' lines, ending with either the 'load at create (RX_VK_LOAD=create)' summary or 'nothing finished for 30 s: the game starts'. Please compare against main, which on these cards stays at 0% until the window is closed (issues 1373 and 1405).
Member

Beanstalk test farm

Commit 732aa8a · tier reviewed · approved by HumanBean · dashboard

What will be tested · AI plan (gpt-6.1-terra)

On Windows with the AMD proprietary driver, this plan targets RDNA1 or Vega GPUs and compares two default-settings title starts per build against main, measuring startup time and requiring each start to reach the menu without a crash. No matching GPU is listed online, so the test will wait for one. The farm cannot guarantee that the second start reuses the first start’s cache or check the loading-screen pipeline counter; the requested progress and cache-reuse behavior therefore remain unverified. No tester online now matches windows+amd+amd-proprietary+gpu-rx-5xxx_vega-*: that target waits for one.

  • Where: windows+amd+amd-proprietary+gpu-rx-5xxx_vega-* (GPU "rx 5xxx" or "vega *", 1-2 reports).
  • title-starts: from the title screen; 2 runs on each side.
  • Measured: crashes, boot time.
  • The PR fails if: it crashes.
  • Time: about 20 min of game runs per tester (4 game starts), plus the two builds.

Done. Comment @Beanstalk to run it again.

Target Reports Crash Frame p99 (ms) vs main VRAM peak (MB) vs main Result
windows+amd+amd-proprietary+gpu-rx-5xxx_vega-* 0/1 — — — queued
<!-- beanstalk:sticky --> ### Beanstalk test farm Commit `732aa8a` · tier **reviewed** · approved by HumanBean · [dashboard](https://beanstalk.magicbean.dev/prs/1450) **What will be tested** · AI plan (`gpt-6.1-terra`) On Windows with the AMD proprietary driver, this plan targets RDNA1 or Vega GPUs and compares two default-settings title starts per build against main, measuring startup time and requiring each start to reach the menu without a crash. No matching GPU is listed online, so the test will wait for one. The farm cannot guarantee that the second start reuses the first start’s cache or check the loading-screen pipeline counter; the requested progress and cache-reuse behavior therefore remain unverified. No tester online now matches windows+amd+amd-proprietary+gpu-rx-5xxx_vega-*: that target waits for one. - **Where:** windows+amd+amd-proprietary+gpu-rx-5xxx_vega-* (GPU "rx 5xxx" or "vega *", 1-2 reports). - **title-starts:** from the title screen; 2 runs on each side. - **Measured:** crashes, boot time. - **The PR fails if:** it crashes. - **Time:** about 20 min of game runs per tester (4 game starts), plus the two builds. Done. Comment `@Beanstalk` to run it again. | Target | Reports | Crash | Frame p99 (ms) vs main | VRAM peak (MB) vs main | Result | | --- | --- | --- | --- | --- | --- | | windows+amd+amd-proprietary+gpu-rx-5xxx_vega-* | 0/1 | — | — | — | queued |
HumanBean changed title from WIP: fix(vk): a load-at-create start whose mesh fallback builds stall in the driver goes on to the title, with progress on the way to fix(vk): a load-at-create start whose mesh fallback builds stall in the driver goes on to the title, with progress on the way 2026-11-17 20:19:23 +00:00
HumanBean deleted branch fix/load-at-create-stall 2026-11-17 20:19:33 +00:00
Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
2 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
MagicBeanDev/Longshot!1450
No description provided.