perf(vk): the load at create lets a program's shader modules go once its noted pipelines are built (RX_VK_DROP_LOADED_MODULES) #1844

Merged
HumanBean merged 1 commit from GummiNaomi/Longshot:perf/drop-loaded-modules into main 2026-11-20 06:46:42 +00:00
Member

Summary

With programs loaded at their create calls (RX_VK_LOAD=create, the default), every program the load reads keeps its vertex and fragment shader modules for the session, and NVIDIA's Windows driver keeps each module's SPIR-V in the game's private memory while the module lives: in a Market stand on my PC, 915 MB of the game's private memory were modules made by the load at create, nearly all for programs whose pipelines the load had already built. This lets a loaded program's modules go once every noted pipeline of its variant is built, and makes them again from longshot_programs.bin if play ever builds a new pipeline state of it (RX_VK_DROP_LOADED_MODULES). In two Market stands a side: working set 13.5 -> 12.2-12.3 GB, private memory 22.2 / 21.9 -> 20.8 / 20.6 GB, steady frames and loads the same; a 7-area tour peaked at 13.1 GB instead of 15.3 GB, with 15,393 modules let go and none made again. On by default; =0 keeps them, as before.

Why: the 915 MB is what a temporary census of the process's allocations by call stack (not in this PR) put under vkCreateShaderModule <- make_module <- program_cache_read <- load_work. The pipelines built from a module don't need it once they are made. Linux already lets modules go after the start-up precompile (program_cache_drop_modules, for RX_VK_LOAD=start on 20 GB or less), and #1488 (open) proposes that release on Windows on request; neither reaches the load at create, which is where a default start's modules come from. Also in that census, not changed here: the recordings' descriptor pools held 339 MB of the game's private memory on NVIDIA's Windows driver (48 pools, about 7 MB each), which bears on #1158's note that NVIDIA is unaffected.

What changes: load_work (gpu/vk/vk_programs.cpp) counts, for each graphics program, the noted pipelines of its variant it built and those it left (deferred to their draw, cold, or a note that did not read). When every one was built and the switch is on, program_cache_drop_loaded (gpu/vk/vk_progcache.cpp) destroys the program's modules while it is still in the load job's own list, so no other thread holds it, and records it in the table Linux's release uses. A build of a new state for it goes through program_cache_complete_graphics first, which reads the stages back from longshot_programs.bin and makes the modules on that worker, as after Linux's release; build_graphics and the quick pipeline already refuse a program whose modules are gone. Kept: compute and mesh-fallback programs, a program with a stage that cannot be read back from the file, and a second program of the same key and variant. The census line vk: program loads at create (...) counts the modules let go and the programs that had them made again. Unchanged: the load itself, the pipelines, the program cache's file, Linux's release after the precompile.

Read first: program_cache_drop_loaded in gpu/vk/vk_progcache.cpp, the notes loop in load_work (gpu/vk/vk_programs.cpp), then tests/test_loaded_modules_drop.py.

Testing

Tested: Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB: two Market stands of 150 s a side and one 7-area teleport tour a side from the kokiri-start save, RX_VK_DROP_LOADED_MODULES=0 against unset, on a build of main @ f505340b with #1810-#1813's changes and this one; with it on, the census line counted the modules let go (5,582 in a stand, 15,393 in the tour) and 0 programs' modules made again; the tour's pictures alike in all 7 areas both ways.
Checks: tests/test_loaded_modules_drop.py (the notes loop's counting as it is in the source; the drop and the remake run on a real program cache file: a graphics program's two modules go and come back with the same SPIR-V, counted; a mesh fallback program, a compute program, a stage not in the file and a second program of the same key keep theirs; the switch on unset, off for 0/off/false/no) passes on this head on Windows (clang) and Linux (g++ 13.3, WSL Ubuntu 24.04); tests/test_program_load_wait.py passes with its fixture's two new counters, and tests/test_module_ids.py and tests/test_switch_table.py pass.
Suite: tests/run_all.py with every check on main @ 068fb8eb in WSL Ubuntu 24.04 (740 pass, 61 fail, 69 skipped: no clang or spirv-val there), then this head's --changed checks in WSL (51 pass, 6 fail, 3 skipped) and on Windows (55 run, 9 fail). Every failure also fails on main @ 068fb8eb on the same OS: in WSL and on Windows test_crash_dialog, test_dev_ab, test_frame_overlap, test_linux_pressure, test_present_queue_default, test_vk_occlusion_queries; on Windows only test_driver_env_choose, test_mesh_fallback_layout, test_native_float_atomic_add. (On Windows the changed checks ran on the head before its last test fixes; test_loaded_modules_drop were run again on this head and passed, as in WSL.) (On Windows most of them are compile errors with this PC's compiler wrapper, on main as here.) These ran on the head as it was on main @ 068fb8eb; it was then rebased onto main @ 3f2c9b3c, whose two new commits change only the NFC menu (gpu/vk/menu/nfc.cpp and its test), none of this PR's files.

Still to test:

  • A Windows PC with 16 GB of RAM and an NVIDIA card: a Market stand twice a side, RX_VK_DROP_LOADED_MODULES=0 against unset, expecting about 1 GB less private memory unset, and the loads at create and the frames the same (by hand)
  • This PC, Windows: a play session that builds new pipeline states for loaded programs (another area, an upscaler or resolution row changed in play), expecting the census line's "programs' modules made again" above 0 and no draw left out: the remake path did not run in the stands or the tour (by hand)
  • Windows, AMD and Intel: a Market stand a side, expecting less private memory unset and no draw left out (by hand)

Measurements

Verdict: about 1.3 GB less working set and private memory in the Market on this PC, with the steady frames, the loads at create and the tour's pictures the same; the tour, one a side, peaked 2.1 GB lower. The remake path was not needed in any run.

Setup: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB; from kokiri-start, a teleport to the Market and 150 s there (the working set's median over the last third of the log's memory lines, frames over the last 100 s), and a teleport tour of 7 areas, 20 s each; 2560x1440, no window (HOS_HEADLESS=1), uncapped, 16 cores; in both arms RX_VK_LOAD=create RX_VK_ASTC_BC_ALL=1 RX_VK_IMAGE_BLOCK_MB=32 RX_VK_BC_LAYERS=8 RX_VK_LATE_FIX=1 RX_VK_TEX_MOVE=1 RX_VK_TEX_AHEAD=2 HOS_NVN_FRAME_OVERLAP=1 RX_VK_FRAME_TRACE=1.

Baseline: builds of main @ f505340b (before the tooling revamp 068fb8eb, which changes none of this code) with #1810-#1813's changes, this change and the pipeline cache's Windows rule (its own PR, #1845). Before: RX_VK_DROP_LOADED_MODULES=0 RX_VK_PCACHE_LOAD=1, main's behaviour on this PC, on a build that also held the temporary census (off) and that rule without its RAM limit (overridden by =1). After: the final build at its defaults, which on this 32 GB PC reads the pipeline cache file as main does. The two sides' stands were not interleaved.

Before: RX_VK_DROP_LOADED_MODULES=0 (as main) @ f505340b After: on (this PR) @ f505340b
Market stands: working set, median (MB) 13,524 / 13,465 12,190 / 12,315
Market stands: working set, peak (MB) 13,551 / 13,488 12,285 / 12,353
Market stands: private memory (MB) 22,193 / 21,934 20,757 / 20,607
Market stands: mean frame / p99 (ms) 10.91 / 14.52, 10.87 / 14.54 10.94 / 14.66, 10.84 / 14.44
Market stands: late frames, frames of 33 ms or more 0.11 %, 0; 0.15 %, 0 0.12 %, 0; 0.10 %, 0
Market stands: a load at create, median; draws that ran a load themselves 0.98 ms, 11; 1.04 ms, 18 0.69 ms, 6; 0.84 ms, 8
tour (7 areas): working set, peak / last (MB) 15,280 / 14,849 13,147 / 12,915
tour: private memory, last (MB) 23,551 21,758
tour: frames of 33 ms or more / 100 ms or more; p99 78 / 14; 18.53 ms 62 / 10; 17.23 ms
modules let go / programs' modules made again none 15,393 / 0 (tour)

The stands' mean frame, after against before: -0.004 ms (95 % interval -0.033 to +0.027). The tour is one run a side: its frame rows are within run to run, not a claim.

RX_VK_DROP_LOADED_MODULES (new, a kill switch) ships on, chosen by the stands above: less memory, nothing slower; =0 keeps the modules for the session, as on main.

Risks

What could break: a draw that needs a new pipeline state of a program whose modules went waits for its worker to read the stages back and make them (a file read and two module creates), and gets no quick pipeline meanwhile, so it is left out or waits as for any full build; this path is the one Linux's release has used since #223, but it did not run in these Windows runs (0 made again). #1809 (open) moves the SPIR-V to a shared store; the remake reads it through the program cache's own reader, so whichever lands second adapts that one call. Turning it off: RX_VK_DROP_LOADED_MODULES=0. After updating, a player on Windows with NVIDIA has about 1 GB less of the game in RAM; nothing changes for saves, longshot_options.ini or the caches.

Checklist

Ready for review

  • One topic, on current main; the title is a Conventional Commit.
  • Tested on my own PC, in the game for a change the game runs, as Testing says.
  • mise run test passes (any failure that also fails on main is named).
  • Measured against main, or Measurements says why there is nothing to measure. (Two stands and one tour a side, not interleaved, on a build of main @ f505340b with four open PRs' changes, as Baseline says.)
  • No game files, build output or hand-edited generated files; third_party/ untouched; nothing GPL-incompatible.

When it applies

  • A switch added or changed: it ships at the default the measurements chose, with its row in gpu/vk/switches.def.
  • A check under tests/ that reads changed source is updated, not weakened.
  • Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (The changed renderer files were built on Windows for the measured build, not yet on this head or on Linux; the test compiles the new functions with clang on Windows and g++ 13.3 on WSL Ubuntu 24.04. On this head the changed files pass a syntax-only compile with the builder's own Windows flags.)
  • AI assistance recorded with Assisted-by: / Co-Authored-By: trailers.

Ready to merge

  • Everything in Still to test has run, its results in Tested.
  • Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers").
  • Approved in review, every comment answered.
  • CI passes on the head; on current main, measured again or a comment says why the numbers still hold.

🤖 Generated with Claude Code

## Summary With programs loaded at their create calls (`RX_VK_LOAD=create`, the default), every program the load reads keeps its vertex and fragment shader modules for the session, and NVIDIA's Windows driver keeps each module's SPIR-V in the game's private memory while the module lives: in a Market stand on my PC, 915 MB of the game's private memory were modules made by the load at create, nearly all for programs whose pipelines the load had already built. This lets a loaded program's modules go once every noted pipeline of its variant is built, and makes them again from `longshot_programs.bin` if play ever builds a new pipeline state of it (`RX_VK_DROP_LOADED_MODULES`). In two Market stands a side: working set 13.5 -> 12.2-12.3 GB, private memory 22.2 / 21.9 -> 20.8 / 20.6 GB, steady frames and loads the same; a 7-area tour peaked at 13.1 GB instead of 15.3 GB, with 15,393 modules let go and none made again. On by default; `=0` keeps them, as before. Why: the 915 MB is what a temporary census of the process's allocations by call stack (not in this PR) put under `vkCreateShaderModule` <- `make_module` <- `program_cache_read` <- `load_work`. The pipelines built from a module don't need it once they are made. Linux already lets modules go after the start-up precompile (`program_cache_drop_modules`, for `RX_VK_LOAD=start` on 20 GB or less), and #1488 (open) proposes that release on Windows on request; neither reaches the load at create, which is where a default start's modules come from. Also in that census, not changed here: the recordings' descriptor pools held 339 MB of the game's private memory on NVIDIA's Windows driver (48 pools, about 7 MB each), which bears on #1158's note that NVIDIA is unaffected. What changes: `load_work` (`gpu/vk/vk_programs.cpp`) counts, for each graphics program, the noted pipelines of its variant it built and those it left (deferred to their draw, cold, or a note that did not read). When every one was built and the switch is on, `program_cache_drop_loaded` (`gpu/vk/vk_progcache.cpp`) destroys the program's modules while it is still in the load job's own list, so no other thread holds it, and records it in the table Linux's release uses. A build of a new state for it goes through `program_cache_complete_graphics` first, which reads the stages back from `longshot_programs.bin` and makes the modules on that worker, as after Linux's release; `build_graphics` and the quick pipeline already refuse a program whose modules are gone. Kept: compute and mesh-fallback programs, a program with a stage that cannot be read back from the file, and a second program of the same key and variant. The census line `vk: program loads at create (...)` counts the modules let go and the programs that had them made again. Unchanged: the load itself, the pipelines, the program cache's file, Linux's release after the precompile. Read first: `program_cache_drop_loaded` in `gpu/vk/vk_progcache.cpp`, the notes loop in `load_work` (`gpu/vk/vk_programs.cpp`), then `tests/test_loaded_modules_drop.py`. ## Testing **Tested:** Windows 11, RTX 4070 SUPER (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB: two Market stands of 150 s a side and one 7-area teleport tour a side from the `kokiri-start` save, `RX_VK_DROP_LOADED_MODULES=0` against unset, on a build of main @ f505340b with #1810-#1813's changes and this one; with it on, the census line counted the modules let go (5,582 in a stand, 15,393 in the tour) and 0 programs' modules made again; the tour's pictures alike in all 7 areas both ways. Checks: `tests/test_loaded_modules_drop.py` (the notes loop's counting as it is in the source; the drop and the remake run on a real program cache file: a graphics program's two modules go and come back with the same SPIR-V, counted; a mesh fallback program, a compute program, a stage not in the file and a second program of the same key keep theirs; the switch on unset, off for 0/off/false/no) passes on this head on Windows (clang) and Linux (g++ 13.3, WSL Ubuntu 24.04); `tests/test_program_load_wait.py` passes with its fixture's two new counters, and `tests/test_module_ids.py` and `tests/test_switch_table.py` pass. Suite: `tests/run_all.py` with every check on main @ 068fb8eb in WSL Ubuntu 24.04 (740 pass, 61 fail, 69 skipped: no clang or spirv-val there), then this head's `--changed` checks in WSL (51 pass, 6 fail, 3 skipped) and on Windows (55 run, 9 fail). Every failure also fails on main @ 068fb8eb on the same OS: in WSL and on Windows `test_crash_dialog`, `test_dev_ab`, `test_frame_overlap`, `test_linux_pressure`, `test_present_queue_default`, `test_vk_occlusion_queries`; on Windows only `test_driver_env_choose`, `test_mesh_fallback_layout`, `test_native_float_atomic_add`. (On Windows the changed checks ran on the head before its last test fixes; `test_loaded_modules_drop` were run again on this head and passed, as in WSL.) (On Windows most of them are compile errors with this PC's compiler wrapper, on main as here.) These ran on the head as it was on main @ 068fb8eb; it was then rebased onto main @ 3f2c9b3c, whose two new commits change only the NFC menu (`gpu/vk/menu/nfc.cpp` and its test), none of this PR's files. **Still to test:** - A Windows PC with 16 GB of RAM and an NVIDIA card: a Market stand twice a side, `RX_VK_DROP_LOADED_MODULES=0` against unset, expecting about 1 GB less private memory unset, and the loads at create and the frames the same (by hand) - This PC, Windows: a play session that builds new pipeline states for loaded programs (another area, an upscaler or resolution row changed in play), expecting the census line's "programs' modules made again" above 0 and no draw left out: the remake path did not run in the stands or the tour (by hand) - Windows, AMD and Intel: a Market stand a side, expecting less private memory unset and no draw left out (by hand) ## Measurements **Verdict:** about 1.3 GB less working set and private memory in the Market on this PC, with the steady frames, the loads at create and the tour's pictures the same; the tour, one a side, peaked 2.1 GB lower. The remake path was not needed in any run. Setup: Windows 11 Pro 26200, RTX 4070 SUPER 12 GB (NVIDIA 617.42), Ryzen 9 9950X3D with SMT off, 32 GB; from `kokiri-start`, a teleport to the Market and 150 s there (the working set's median over the last third of the log's memory lines, frames over the last 100 s), and a teleport tour of 7 areas, 20 s each; 2560x1440, no window (`HOS_HEADLESS=1`), uncapped, 16 cores; in both arms `RX_VK_LOAD=create RX_VK_ASTC_BC_ALL=1 RX_VK_IMAGE_BLOCK_MB=32 RX_VK_BC_LAYERS=8 RX_VK_LATE_FIX=1 RX_VK_TEX_MOVE=1 RX_VK_TEX_AHEAD=2 HOS_NVN_FRAME_OVERLAP=1 RX_VK_FRAME_TRACE=1`. Baseline: builds of main @ f505340b (before the tooling revamp 068fb8eb, which changes none of this code) with #1810-#1813's changes, this change and the pipeline cache's Windows rule (its own PR, #1845). Before: `RX_VK_DROP_LOADED_MODULES=0 RX_VK_PCACHE_LOAD=1`, main's behaviour on this PC, on a build that also held the temporary census (off) and that rule without its RAM limit (overridden by `=1`). After: the final build at its defaults, which on this 32 GB PC reads the pipeline cache file as main does. The two sides' stands were not interleaved. | | Before: `RX_VK_DROP_LOADED_MODULES=0` (as main) @ f505340b | After: on (this PR) @ f505340b | |---|---|---| | Market stands: working set, median (MB) | 13,524 / 13,465 | 12,190 / 12,315 | | Market stands: working set, peak (MB) | 13,551 / 13,488 | 12,285 / 12,353 | | Market stands: private memory (MB) | 22,193 / 21,934 | 20,757 / 20,607 | | Market stands: mean frame / p99 (ms) | 10.91 / 14.52, 10.87 / 14.54 | 10.94 / 14.66, 10.84 / 14.44 | | Market stands: late frames, frames of 33 ms or more | 0.11 %, 0; 0.15 %, 0 | 0.12 %, 0; 0.10 %, 0 | | Market stands: a load at create, median; draws that ran a load themselves | 0.98 ms, 11; 1.04 ms, 18 | 0.69 ms, 6; 0.84 ms, 8 | | tour (7 areas): working set, peak / last (MB) | 15,280 / 14,849 | 13,147 / 12,915 | | tour: private memory, last (MB) | 23,551 | 21,758 | | tour: frames of 33 ms or more / 100 ms or more; p99 | 78 / 14; 18.53 ms | 62 / 10; 17.23 ms | | modules let go / programs' modules made again | none | 15,393 / 0 (tour) | The stands' mean frame, after against before: -0.004 ms (95 % interval -0.033 to +0.027). The tour is one run a side: its frame rows are within run to run, not a claim. `RX_VK_DROP_LOADED_MODULES` (new, a kill switch) ships on, chosen by the stands above: less memory, nothing slower; `=0` keeps the modules for the session, as on main. ## Risks What could break: a draw that needs a new pipeline state of a program whose modules went waits for its worker to read the stages back and make them (a file read and two module creates), and gets no quick pipeline meanwhile, so it is left out or waits as for any full build; this path is the one Linux's release has used since #223, but it did not run in these Windows runs (0 made again). #1809 (open) moves the SPIR-V to a shared store; the remake reads it through the program cache's own reader, so whichever lands second adapts that one call. Turning it off: `RX_VK_DROP_LOADED_MODULES=0`. After updating, a player on Windows with NVIDIA has about 1 GB less of the game in RAM; nothing changes for saves, `longshot_options.ini` or the caches. ## Checklist ### Ready for review - [x] One topic, on current `main`; the title is a Conventional Commit. - [x] Tested on my own PC, in the game for a change the game runs, as Testing says. - [x] `mise run test` passes (any failure that also fails on `main` is named). - [ ] Measured against `main`, or Measurements says why there is nothing to measure. (Two stands and one tour a side, not interleaved, on a build of main @ f505340b with four open PRs' changes, as Baseline says.) - [x] No game files, build output or hand-edited generated files; `third_party/` untouched; nothing GPL-incompatible. ### When it applies - [x] A switch added or changed: it ships at the default the measurements chose, with its row in `gpu/vk/switches.def`. - [x] A check under `tests/` that reads changed source is updated, not weakened. - [ ] Host code builds on Windows (llvm-mingw) and Linux, with UTF-8 paths. (The changed renderer files were built on Windows for the measured build, not yet on this head or on Linux; the test compiles the new functions with clang on Windows and g++ 13.3 on WSL Ubuntu 24.04. On this head the changed files pass a syntax-only compile with the builder's own Windows flags.) - [x] AI assistance recorded with `Assisted-by:` / `Co-Authored-By:` trailers. ### Ready to merge - [ ] Everything in Still to test has run, its results in Tested. - [ ] Tier 1 hardware it can affect is tested (docs/dev/standards.md, "Hardware tiers"). - [ ] Approved in review, every comment answered. - [ ] CI passes on the head; on current `main`, measured again or a comment says why the numbers still hold. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
perf(vk): the load at create lets a program's shader modules go once its noted pipelines are built (RX_VK_DROP_LOADED_MODULES)
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
Website / Website on Cloudflare (pull_request_target) Has been skipped
CI / Conventional Commit title (pull_request) Successful in 25s
Guide screenshots / Guide images and local UI source review (pull_request) Failing after 36s
CI / Workflow lint (actionlint) (pull_request) Successful in 38s
Third-party parts / As their notes say (pull_request) Successful in 40s
PR description / Description follows the template (pull_request_target) Failing after 3s
CI / Website build and checks (pull_request) Failing after 2m1s
c42b242f30
With programs loaded at their create calls (RX_VK_LOAD=create, the default), every loaded program kept its vertex and
fragment shader modules for the session, and NVIDIA's Windows driver keeps each module's SPIR-V in the game's private
memory while it lives: 915 MB of a Market stand, nearly all for programs whose noted pipelines were already built.

load_work now counts, per graphics program, the noted pipelines of its variant it built and those it left (deferred to
their draw, cold, or a note that did not read). When all were built, program_cache_drop_loaded lets the program's modules
go before the program is handed on, where every stage can be read again from longshot_programs.bin; a new pipeline state
in play has them made again on the worker that builds it (program_cache_complete_graphics, the path Linux's release after
the precompile already uses). Compute and fallback programs, a stage that cannot be remade, and a second program of the
same key and variant keep theirs. The census line says how many went and how many programs had them made again.

On by default, a kill switch: RX_VK_DROP_LOADED_MODULES=0 keeps them, as before. Two Market stands a side on 16 cores:
working set 13.5 -> 12.2-12.3 GB, private 22.2/21.9 -> 20.8/20.6 GB, loads and steady frames the same; a 7-area tour
let 15,393 modules go and made none again. tests/test_loaded_modules_drop.py runs the new code as it is in the source;
tests/program_load_wait_test.cpp's cut of the notes loop gets the two counters.

Assisted-by: Claude Code
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Member

Possibly related, for context:

  • issue #1509 Shader programs, modules and pipelines are never released while the game runs, and the rule that would release a program has no caller — Open renderer-memory issue; this releases loaded modules, though not whole programs or pipelines
  • issue #1474 Idea: on Windows, hold less memory for pipelines after the start: the cache file rule (#416) and the module release (#223) Linux has, once measured — Open Windows memory proposal; this adds load-at-create module release beyond its cited post-start work
Possibly related, for context: - issue #1509 Shader programs, modules and pipelines are never released while the game runs, and the rule that would release a program has no caller — Open renderer-memory issue; this releases loaded modules, though not whole programs or pipelines - issue #1474 Idea: on Windows, hold less memory for pipelines after the start: the cache file rule (#416) and the module release (#223) Linux has, once measured — Open Windows memory proposal; this adds load-at-create module release beyond its cited post-start work
HumanBean changed title from WIP: perf(vk): the load at create lets a program's shader modules go once its noted pipelines are built (RX_VK_DROP_LOADED_MODULES) to perf(vk): the load at create lets a program's shader modules go once its noted pipelines are built (RX_VK_DROP_LOADED_MODULES) 2026-11-20 06:46:32 +00:00
HumanBean deleted branch perf/drop-loaded-modules 2026-11-20 06:46:42 +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!1844
No description provided.