Skip to content

Releases

Veshiru 2.4.1

Choose a tag to compare

@github-actions github-actions released this 21 Nov 12:10
2fc3c41

Ports six self-contained stability and hot-path fixes from Lichii nx2 3165970a, with the
upstream commit named in each file. No frame-generation behaviour changed.

Fixed

  • UniqueFunction owns a callable given as an lvalue. It previously stored Functor with a
    forwarding reference, so a callable passed by name as const was kept as a reference;
    QueueVulkanPipelineCacheSave queues const auto save = ..., and the serialization worker ran
    that lambda after its stack frame returned. It now stores std::decay_t<Functor>, constrains
    construction and calls through std::invoke. Ported from Lichii 249d889b.
    [verified: host g++ harness covers const/non-const lvalues, std::ref, member pointers and the construction constraints; unverified: the original crash on hardware]
  • Shader TrackAddend no longer recurses without a depth limit. A long IAdd32 chain could
    overflow the host stack while translating a shader; it now uses an explicit stack with the same
    visit order. Ported from Lichii 19dcffea.
    [verified: same visit order and ambiguity rule by inspection; unverified: a title with the long chain]
  • A failed ScratchBuffer::resize_destructive leaves a consistent buffer. The old order
    raised the capacity before allocating, so a failed growth left a capacity with no storage. It
    now releases first; a failure leaves an empty, reusable buffer. Ported from Lichii 64ea088a
    (the ScratchBuffer part only). [verified: host g++ failure-injection harness and a new ctest case; unverified: memory pressure in a game]
  • Sparse texture segments with no device translation are skipped, not asserted. A segment can
    lose its translation between the submapped-range query and the lookup. The first eight are
    logged, the rest are skipped, and iteration continues. Ported from Lichii 4a558454 (originally
    Eglantine 19dfa543). [unverified: a title that hits the race]
  • Unmapped guest writes no longer flood the log. Write, WriteExclusive and
    WriteExclusive128 now log the first 1000 and then one per 100000, as unmapped reads already
    did. A guest spinning on a bad pointer could otherwise write a ~100 MB log and slow the run.
    Ported from Lichii 528dae4b. [verified: code path by inspection; unverified: the pathological guest]

Changed

  • The GPU snapshot copier parks its waiter. After 4096 spins, WaitFor now waits on the
    completion atomic and the copier notifies after each job, instead of yielding in a loop. Ported
    from Lichii 4a3dbf64. [unverified: frame-time effect on the GTX 1650]

Verified

  • Windows clang-cl production build and ctest: CI run
    44892557878 passed configure,
    cmake --build build with ENABLE_WERROR=ON, both executable checks and
    ctest --test-dir build --output-on-failure --no-tests=error on commit 5838714.
  • Host g++ -std=c++20 harnesses for UniqueFunction (const/non-const lvalues, std::ref,
    member pointers, construction constraints) and ScratchBuffer (failure injection and reuse).

Not ported

  • Lichii's 4 MiB device-buffer blocks: Veshiru already uses 8 MiB; the extra step is unmeasured.
  • Spill-collect GC change: Veshiru has no host-spill collect path.
  • Texel-buffer clamp, GPU-split parking and GPFIFO inline headers: deferred; reasons and exact
    commits are in the comparison.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v2.3.0

Choose a tag to compare

@github-actions github-actions released this 21 Nov 06:50
0c8f66e

Every entry carries a tag. [verified: <how>] means it was run, or a CI job proved it; a green
CI means the code builds and the tests pass, not that a game or Discord behaves. [unverified]
means nobody has observed it. The Verified and Unverified sections below summarize.

Fixed

  • The Windows production build, broken on main since the 2.3 library merge. game_list.cpp
    called isRowHidden (removed with the view change) and used Veshiru without its include;
    both compile errors are repaired, and CI compiles the Discord RPC TU (USE_DISCORD_PRESENCE=ON)
    so a broken include cannot ship silently again. [verified: Windows clang-cl build in CI]

Added

  • Discord Rich Presence over a local IPC client (Windows). Presence is opt-in, uses a
    user-supplied Discord Application ID (none is bundled), and only sends the game title, version
    and elapsed-time timestamp plus the required local IPC metadata. The worker owns one persistent
    pipe connection with overlapped I/O, a 15-second send rate limit, and reconnect backoff of 1 to
    60 seconds with a bounded shutdown. Artwork lookups and the third-party RPC library were
    removed. The activity name is derived from the build version, and the payload escaping is
    covered by unit tests. [verified: payload/version unit tests; unverified: live Discord behavior on a real desktop]
  • Versioned List game-library mode. A new compact, keyboard/controller-friendly card list shows
    cover art, title, content type, play time and the installed game version at a glance. The
    version comes from one shared resolver (GameListVersion::Resolve: enabled update > control
    metadata > display version > "1.0.0" only when a base NACP exists); an unknown version hides
    the badge, and Discord reports the same version. [verified: resolver unit tests; unverified: badge rendering in a running GUI]

Changed

  • Vulkan storage-binding cache reads only stable GPU mapping generations. Cache hits are
    bypassed while a page-table update is in progress, so a service thread cannot reuse a binding
    against a partially updated map, and a lockstep test pins that every completed page-table
    operation (map, sparse map, unmap, remap) advances the generation. Adapted from Orchid's
    buffer_cache: reuse storage bindings while GPU mappings are stable change. [verified: mapping-generation and lockstep unit tests; unverified: gameplay effect on target hardware]
  • Game-directory updates are debounced by 30 ms. Watcher bursts of both kinds (game
    directories and external content) are tracked independently and coalesce into one asynchronous
    rescan instead of repeatedly clearing and rebuilding the library. Manual and settings-driven
    refreshes remain immediate. [verified: coalescer unit tests; unverified: under an OS filesystem watcher]
  • The library refresh is incremental. Rows are cached in memory for the session keyed by
    canonical path, file size and modification time, so a refresh re-parses only new or modified
    files. Play time is re-read when a row is rebuilt, boot support never depends on the cache, and
    the cache is cleared when keys or firmware are installed. Every refresh logs
    library refresh: N entries, X reused, Y parsed, Z ms (reason: ...). [verified: cache unit tests; unverified: large-library timing on target hardware]
  • Diagnostic logs redact private identifiers, including emulated console serials, device and
    account names, network-interface labels, configured endpoints, controller/audio identifiers, IP
    addresses, and MAC addresses. Address redaction is a single-pass scanner that no longer
    mistakes Vulkan/driver version numbers for IPv4 addresses (the old regexes redacted
    Vulkan 1.3.280 and 551.86.0.0). [verified: 18-case unit test and a 100k-line benchmark printed in the CI log (locally 1578 ms regexes vs 46 ms scanner)]
  • A built-in performance summary for honest FPS measurement: Debug > Performance Summary
    (off / 10 s / 30 s), Ctrl+F10 for an on-demand window, or VESHIRU_PERF_SUMMARY=<seconds>.
    One fixed-format Info line per window with native FPS, nearest-rank frame-time percentiles,
    1%/0.1% lows, slow-frame counts, synchronous-readback waits, pipeline builds and generated
    presents. Off by default; a single branch when off. [verified: format definitions and flag plumbing compile in CI; unverified: measured on target hardware]

Known issues

  • Discord Rich Presence requires a user-supplied Application ID in Settings and is Windows-only in
    this build; it is off by default.
  • The Windows production build of PR #22 was broken (isRowHidden, missing include); this release
    restores it. Main carried the broken commit, so 2.3.0 is the first release whose artifacts are
    expected to build since 2.2.0.

Verified

  • Unit tests run by the CI test job on the release head: Discord payload construction, escaping
    and version derivation (src/tests/common/discord_payload.cpp, 8 cases); watcher refresh
    coalescing (src/tests/qt_common/refresh_coalescer.cpp, 2 cases); the game-list version
    resolver (src/tests/qt_common/game_version.cpp, 5 cases); address redaction
    (src/tests/common/address_redaction.cpp, 18 cases plus a printed benchmark); the
    mapping-generation lockstep (src/tests/video_core/memory_manager_runs.cpp); the parse cache
    (src/tests/qt_common/game_list_parse_cache.cpp, 3 cases).
  • The Windows clang-cl production build and the full test suite on the exact release commit.

Unverified

  • Live Discord behavior on a real desktop (no Application ID was supplied; none is bundled).
  • GUI behavior of the Versioned List badge, the Debug > Performance Summary menu and Ctrl+F10.
  • Watcher-driven refreshes under a real OS filesystem watcher, and large-library refresh timing.
  • Any gameplay or FPS effect: no target-hardware measurement exists for this release.

Off by default

  • Discord Rich Presence (opt-in; requires a user-supplied Application ID in Settings).
  • The periodic performance summary (off / 10 s / 30 s; Ctrl+F10 and VESHIRU_PERF_SUMMARY also
    available). When off it costs one atomic load per present.
  • No experimental performance change from the 2.3 review is enabled in this release.

Performance status

  • The supplied 2.2.0 log shows the native game rate varying well below 30 FPS in gameplay even while
    frame generation queues extra presents. Its frame and GPU-readback diagnostics point to runtime
    workload bottlenecks, not a proven single fix. No general emulator-core optimization is claimed
    or a 30 FPS result promised without a repeatable scene benchmark. See
    the 2.3 performance review.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v2.2.0

Choose a tag to compare

@github-actions github-actions released this 21 Nov 01:26
479fd2a

Every entry carries a tag. [verified: <how>] means it was run, or a CI job proved it; a green
CI means the code builds and the tests pass, not that a game or a controller behaves. [unverified]
means nobody has observed it.

Added

  • HD rumble (off by default), for Xbox-style pads, Pro Controller / Joy-Con and DualSense.
    The HD Rumble... button in the vibration settings opens it. Ported from Octelly's Eglantine
    hdrumble-mvp branch (samaBR85, hermes) and played by Three-Dola's RenHDrum v0.5.0, whose
    prebuilt renhdrum.dll now ships in the Windows packages (third-party binary, SHA-256 pinned
    in the release workflow, notices in third_party_notices/RenHDrum.txt). With the switch off,
    or without the DLL, rumble is played by the same code as in 2.1.0. Details and limits:
    HD rumble on Xbox-style pads.
    • Xbox-style pads get a "Direct" mode mapped by Veshiru itself (low band to the heavy motor,
      high band to the light one) and RenHDrum's own mix as the alternative.
      [verified: 14 unit test cases for the Direct mapping and the write scheduler, run by CI]
      [unverified on hardware]: nobody has felt it on a controller, the PowerA wired Xbox One pad
      included. Eccentric-mass motors cannot reproduce HD rumble frequencies or very short ticks.
    • Motors are zeroed on pause, stop, exit, disconnect and when the feature is switched off, and
      every write expires after one second. [verified: scheduler unit tests] for the stop and the
      expiry logic; [unverified] on a real pad.
    • One Info log line per Xbox-style pad names the SDL input path and whether trigger motors are
      available; refused rumble writes are logged at most once every 10 seconds. [unverified]
    • RenHDrum mix, Pro Controller / Joy-Con and DualSense paths. [unverified]: the mapping is
      inside the DLL and none of these controllers was available.

Changed

  • Mario Kart World, sparse texture tiles outside video memory are now reported. When
    device-local memory runs out and tiles go to a non-device-local heap (the 2.1.0 behaviour,
    unchanged), the log gets a warning at most once every 10 seconds with the tiles and MiB placed
    there since the last report, the tiles no heap had room for, and the session totals; the totals
    are logged once more at shutdown. Counters only: no claim about frame rate is made, because
    none was measured. [verified: 4 unit test cases for the counting and the rate limit, run by CI] [unverified] in a game: nobody has seen the line in a Mario Kart World log yet.

  • aoc:u PrepareAddOnContent says whether the add-on exists. It still always reports
    success, exactly as the stub did, so no title behaves differently. The log now has an Info line
    when the index names an add-on that ListAddOnContent lists for the calling title, and a warning
    with the number of listed add-ons when it does not (or when add-ons are disabled for the
    title). [verified: 3 unit test cases for the index check, run by CI] [unverified] in a
    game: no title that calls it was run.

  • Shader builds that a draw is waiting for run at normal thread priority (Windows). Shader
    workers run below normal priority so that background builds give way to the game. A build was
    already moved to the front of the queue once a draw waited for it, but one that had started
    kept the low priority while the GPU thread was blocked on it. The worker running such a build
    is now raised until that stage ends; builds nothing has waited for are untouched. Taken from
    an owner's Donkey Kong Bananza log on a GTX 1650 laptop, where draws were held 48.5 s out of
    833 s for pipelines still building on a first run with an empty shader cache.
    [verified: 6 unit test cases for when a worker is raised and when that ends, run by CI; the scheduler's 31 cases also pass under ThreadSanitizer in a Linux build] [unverified] in a
    game: no frame time was measured before or after, and the log cannot say how much of the
    waiting was priority.
    It does not change the frame rate once shaders are built: that log's 14 FPS in gameplay is
    time on the GPU command threads, which this release does not address.
    What the log shows.

Build and packaging

  • The Windows packages bundle a third-party binary, renhdrum.dll (RenHDrum v0.5.0). The
    release workflow that builds the packages fails unless the downloaded file has the SHA-256
    pinned in the workflow, is an x86-64 PE, exports the 18 functions Veshiru resolves by name, and
    is byte-for-byte the copy that ends up next to veshiru.exe. [verified: those checks are steps of the workflow run that produced the packages of this release] [unverified]: the
    library was never loaded or called by anyone working on this release.
  • Every GitHub Action in the three workflows is pinned to a commit. [verified: grep; the workflows ran]

Documentation

  • The "main.npdm is parsed rather than assumed" entry was listed under 1.5.0, 1.6.0 and 1.8.0
    as well as 2.0.0. The fix first shipped in 2.0.0; the other three entries are removed.
    [verified: commit range]
  • docs/CI.md said build-check runs the tools/nx2 scripts. It does not, and the page now
    says so. [verified: the workflow file]

Known gaps in this release

  • The written brief for 2.2.0 was lost while the work was in progress and could not be recovered
    from the repository. Its sections 3 and 7, part of 6 and 8, and its release gates G1 to G6 are
    unknown, so nothing was implemented for them and nothing here claims they were met. The owner
    chose to release without them, against a substitute list of six checks.
    The 2.2.0 report
    lists what is known, what is not, and those checks.
  • Nothing in this release was tried on a controller or in a game, and no performance figure
    was measured for it.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

v2.1.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 08:58
451f273

Fixed (source-level verification)

  • Zero or absent DLC metadata no longer produces a zero AOC base. Use a matching carried
    add-on's namespace or the conventional application DLC base; preserve non-zero metadata.
    Populate the base in synthesized NUP control data too. Pin its NACP offset at 0x3070.

Changed (UNVERIFIED - needs runtime test)

  • Donkey Kong Bananza: log the returned base and the actual carried/requested IDs, and return
    FS TargetNotFound for missing data storage. Reaching the menu is unverified.
  • Mario Kart World: MemoryAllocator::AllocateSparseMemory tries a compatible non-local type
    within budget after device-local exhaustion, before rolling back a sparse tile upload. The
    GTX 1650 log recorded 213 failed tile allocations. No same-scene FPS measurement yet.

Known issues

  • Donkey Kong Bananza reaching the menu is unverified at runtime.
  • Mario Kart World same-scene frametime and 1% low are unverified. No FPS gain is claimed.
  • The sparse allocation fallback may use slower non-local memory.
  • Mario Kart 8 and other previously working titles were not re-tested.

Compatibility notes and credits

  • Guest software can still abort on a missing required add-on. GPU paging and readback stalls
    are still possible; no changes to frame generation, shader cache, JIT, or PGO profiles.
  • Thanks to Orchid, Lichii (both forks) and Eglantine PR #877 for DLC metadata precedents.
    See the investigation and retest plan for evidence and limitations.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru 2.0

Choose a tag to compare

@github-actions github-actions released this 20 Nov 06:57
dfea788

Memory: one VRAM policy instead of three fighting margins

  • Removed the 2,048 MiB "keep free" behaviour: Veshiru 1.x stacked three margins under the
    driver budget (a base share, a reaction to every allocation that missed the budget, and a reserve
    for the allocator's block space). They reacted to each other: a miss raised the margin by
    256–512 MiB, the raised margin made the next allocations miss, and on a 4 GB card the margin
    reached its 2 GiB cap, so the cache held half the card free and re-decoded textures every frame
    (Out of device memory: keeping 2048 MiB more free once per few hundred milliseconds in the
    supplied log). A single Common::VramPolicy now sizes the reserve from the driver budget alone:
    an eighth of it, at most 1 GiB — about 387 MiB on the GTX 1650's ~3 GiB budget, so the texture
    cache may fill ~2,709 MiB instead of ~1,734 MiB. The reserve settles instead of ratcheting up.
  • Removed the dead allocator-pressure feedback: runtime.MemoryPressureEvents(), the
    pressure_events counter behind it and the unused pressure_margin, pressure_quiet_frames,
    slack_margin and seen_pressure_events state are gone. An allocation that still misses the
    budget is served by the allocator's existing relax/try-fallback path, which did not need the
    margin loop.
  • Small images no longer count as VRAM pressure: every is over the memory budget; allocating it anyway line in the supplied Mario Kart log was the same 64x64, 7-level depth image — 21 KiB.
    The Vulkan allocator's own budget estimate refused it, which counted as pressure and made the
    texture cache evict recently used images. Images that cannot exceed 4 MiB now skip the budget
    check and fail only if the allocation really fails.
  • Removed the second hidden cap: a discrete GPU's budget was capped again at 6 GiB plus 1 GiB
    per resolution scale step unless VRAM Usage Mode was Aggressive. On a 12 GB card that left
    over 4 GiB unused while the cache evicted to stay under the cap. The driver budget less the
    reserve is now the whole answer.

Frame delivery: fewer hitches while playing

  • NVIDIA pipeline-compile workers: the driver stage of the pipeline build
    (vkCreateGraphicsPipelines/vkCreateComputePipelines) took 201 ms at the median in the supplied
    log with six workers on a 12-thread laptop. NVIDIA's driver serialises that work behind an
    internal lock, so the extra workers only queued while holding their shaders' memory. NVIDIA now
    runs two driver workers; other vendors keep the previous scaling. The previously dead
    has_broken_parallel_compiling flag is now set for Intel's Windows driver, which shares the lock
    too and keeps one worker.
  • NUP decompression batching: DecodeTo released and re-acquired the member's lock once per
    512 KiB chunk, so one sequential read of a big asset made dozens of turns: the log shows
    Archive.min.bntx.zs (38.6 MiB) taking 514 ms, CmnTex_Tera_Product_Proc_Nrm.bntx.zs 228 ms and
    main 193 ms on the thread that asked for the bytes. A read now decodes up to 16 chunks per turn,
    which is five turns for that 38.6 MiB file instead of 77, while still yielding to another reader.

Profile applet: no more stale black frame

  • Compositor presents when the visible layer set changes: HardwareComposer::ComposeLocked only
    presented when a producer handed over a new buffer. A layer that just became visible (the profile
    applet over Mario Kart World) or went away left the previous composite on screen until the next
    buffer arrived — the reported two-second black frame. The composer now also presents when the set
    of layers that should be on screen differs from what the frame can show, without consuming extra
    producer buffers.

Game list: a file that goes missing says so

  • Moved or deleted game files are reported: a title whose file moved or was deleted simply
    stopped appearing, with nothing to distinguish it from never having been added — the reported
    "I deleted my MKW .nup and the game vanished". The worker keeps the paths the last scan listed
    and, on the next scan, lists a Missing row for each one now absent from a directory still
    being scanned, with its old location and a note that saves live in the NAND save data, not in the
    game file. Removing a folder from the game list stays silent, since that is not a game going
    missing.

Settings

  • Memory knobs behind "Show memory expert options": VRAM Usage Mode, VRAM Reserve and
    Texture Cache Memory Limit leave the normal Advanced tab and appear only when that box is
    ticked (or when a per-game/global override already exists, so an existing choice stays editable).
    Veshiru sizes this automatically from the GPU's driver budget; showing the knobs invited users to
    cap the cache at 2 GiB and stutter.

Boot

  • main.npdm is parsed rather than assumed: the NCA loader read the eight bytes at offset
    0x28 as a heap size without checking the META magic, and the supplied HOME Menu log shows a
    file where that read produced 0x7463656c — the ASCII bytes of a text field — as a 1.8 GiB heap,
    which then sized the pointer buffer for a heap that does not exist. The heap size is now read
    only from a real NPDM, and anything unreasonable falls back to the default pointer buffer.

Tests

  • Added src/tests/common/vram_policy.cpp, covering the reserve, the critical threshold, and the
    4 GB case the report described (the cache keeps more than 2 GiB of a ~3 GiB budget).

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v1.9.0

Choose a tag to compare

@github-actions github-actions released this 19 Nov 03:49
a4767d5

The Legend of Zelda: Ocarina of Time & 4–8 GiB GPU Performance

  • Play Report (prepo) command 10500 support: Implemented SaveReport command 10500 on
    prepo (eliminating fatal guest IPC panic 1A80A during Ocarina of Time sessions) and added
    domain request error naming in hle_ipc for clearer diagnostics.
  • Anti-gloom async pipeline & compute protection: Stopped asynchronous draw and compute skip
    policies from dropping unbuilt storage-image-writing graphics draws or image-only tonemapping,
    auto-exposure, and lighting compute dispatches, preventing temporarily dark or gloomy scene
    transitions while shaders compile in the background.
  • 4 GiB VRAM ASTC→BCn chunked transcoding & staging safety: Split large multi-layer GPU
    ASTC→BCn transcodes into VRAM-tiered 32/48/64 MiB layer chunks with post-decode in-flight
    throttling (fixing cold-cache staging buffer reuse corruption and mid-batch pipeline stalls),
    automatic queue-drain retry on transient VK_ERROR_OUT_OF_DEVICE_MEMORY, and inter-chunk staging
    flushes on sub-5 GiB GPUs, while keeping dedicated transient RGBA8 scratch allocations from
    falsely triggering persistent texture pressure eviction.
  • Unified-RAM / iGPU budget scaling (no more 2,048 MiB UMA & 4 GiB caps): Sized integrated and
    unified-memory GPUs across both BIOS UMA carveouts and shared system GPU heaps scaled to total
    unified RAM (plus full dedicated BIOS UMA utilization on handhelds and 24–128 GiB APUs), unlocked
    the Texture Cache Memory Limit UI spinbox up to the full unified memory ceiling instead of
    clamping at 512/2,048/4,096 MiB, and expanded live iGPU budgets cleanly when an explicit cache
    limit is configured while preserving host commit-room protection.
  • v1.8.0 frame-time & streaming regression fixes: Replaced four per-frame full-LRU texture
    walks (DeleteSupersededImages, RetireStaleTargets, and BadOverlap GC passes) with an O(1)
    dense overlapping-image index, tracked in-flight background vkFreeMemory bytes per heap so
    async frees never trigger phantom VRAM eviction loops or false budget pressure, eliminated
    duplicate VkImage creation in render-target allocation and raised device-buffer pool blocks to
    8 MiB, gated Windows PrefaultGuestMemory with a K32QueryWorkingSetEx residency check and
    zero-allocation contiguous iteration, switched Windows RealVfsFilesystem read hits to shared
    locking with FILE_SKIP_SET_EVENT_ON_HANDLE, short-circuited capped speculative readback walks,
    and stopped shared-cache JIT invalidations of uncompiled pages from halting running CPU cores.
  • Transient render-target & texture cache optimizations: Skipped redundant guest uploads for
    new single-level 2D render targets completely covered by prior GPU-written images, added a fast
    path with per-frame LRU deduplication in PrepareImage, cached graphics descriptor table host
    page pointers with 64-bit word comparison, and enabled depth/stencil-write render-pass tracking
    to avoid unneeded feedback-loop transitions.
  • DMA pushbuffer, staging pool & cyclic readback speedups: Restricted per-entry pushbuffer
    writer sync waits to titles requiring them, skipped unnecessary dirty checks when record reads
    are bypassed, switched deferred Vulkan staging buffer reclamation to sorted tick binary search,
    and pre-armed sequential GPU-to-CPU ring-buffer readback pages on step detection to cut first-hit
    synchronous CPU readback stalls.
  • Configurable VRAM Reserve (vram_reserve_mib) & Ocarina of Time AA tip: Added a VRAM
    Reserve
    setting under Settings → Graphics → Advanced (Auto default: 1/8 of driver budget
    up to 1,024 MiB) so 4–8 GiB GPUs can reclaim extra headroom for textures, and added an
    EDEN_NX2_OOT_AA=0 override matching Settings → Graphics → Ocarina of Time anti-aliasing → No
    sharpening
    (recommended on 4–6 GiB GPUs such as GTX 1650 to bypass three post-process compute
    passes for substantial GPU frame-time savings).

Vulkan, SPIR-V & Texture Compatibility

  • Lean multi-buffer SPIR-V global-memory helpers: Marked generated multi-buffer global-memory
    load, store, atomic, and CAS helper functions DontInline across classic graphics stages while
    keeping single-buffer routes (including NVIDIA OpSelect single-buffer compute shaders),
    branch-routed Compute, Task, Mesh, and emulated mesh-as-compute shaders inline, slashing
    SPIR-V bloat and pipeline compile times while preserving Ocarina of Time foliage and tree
    accuracy.
  • AMD mesh-shader fallback & NVIDIA driver reporting: Enabled compute mesh-shader fallback
    properly on AMD hardware where needed, formatted NVIDIA proprietary driver versions using their
    10-8-8-6 bit scheme, added a quiet A8B8G8R8_UNORM fallback for zeroed guest texture headers,
    and gated byte-offset texture header handles strictly to titles that use them.

Switch HOME Menu (qlaunch) Full Library & .nup / .nx Integration

  • Full .nup, .nx, NSP, XCI & NRO discovery on HOME Menu: Synthesized decrypted Control NCAs
    with locale-normalized NACP metadata, cached HD artwork fallback, and strict ≤128 KiB baseline
    JPEG icons (with automatic PNG/JPEG transcoding and procedural fallback tiles) so Switch 1 and
    Switch 2 .nup and .nx packages, uninstalled containers, and homebrew appear on HOME Menu with
    titles, publishers, display versions, real occupied sizes, and artwork — including via -qlaunch
    and regardless of external-content directory settings.
  • Switch 2 title aliasing & seamless frontend launch handoff: Deterministically aliased Switch
    2 0x0400... Program IDs onto HOME Menu-compatible IDs exclusively for system applets, fixed a
    byte-indexing bug in ListApplicationIcon and transfer-memory handling in
    ListApplicationTitle, deduplicated multi-source application records, and routed HOME Menu game
    launches through the frontend with preselected user profile preservation, full per-game settings,
    and Switch 2 extended DRAM.
  • HOME Menu, User Page & Power Menu polish: Implemented missing ns, am, acc, and friend
    calls (GetNintendoAccountUserResourceCache, GetPlayHistoryStatistics, IGlobalStateController
    sleep/reboot handlers, rights/record/gamecard queries), guarded non-NCA manual provider lookups
    and embedded GRenderWindow handle connections, eliminated duplicate HLE shutdown stops, added
    friendly log names for firmware applets, and cleaned up false-alarm avatar and network log spam.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v1.8.0

Choose a tag to compare

@github-actions github-actions released this 18 Nov 12:48
e215abf

Mario Kart World & Switch 2 Frame-Time Improvements

  • Cyclic GPU-to-CPU readback tracking and coalescing: Expanded learned readback page tracking
    from 512 to 4,096 pages (up to 24 MiB/frame) so multi-thousand-page Switch 2 compute culling and
    visibility rings remain warm across wrap-arounds instead of dropping back to synchronous CPU
    readback flushes. Contiguous early-download pages are merged into single copy spans, same-buffer
    readback copies batch into one download call, and speculative cpu_read_ranges prefetching is
    bounded to a forward-biased 2 MiB window so isolated 4 KiB reads do not stall on multi-megabyte
    buffers.
  • Present fence pacing on Mario Kart World: Adaptive nx2:vi2 presentation now skips the
    blocked 3–4 ms current-frame suspension probe when Mario Kart World's current frame fence is
    still waiting on a post-present CPU semaphore release, pacing directly against the previous
    frame's fence while keeping immediate pass-through when the current fence is already signaled.
  • Unreported occlusion query suppression: When a guest leaves Z-pass pixel counting enabled past
    the 1,024-slot overflow guard without resetting or reporting, host Vulkan occlusion queries now
    stay paused until the next guest reset or report instead of repeatedly cycling query pools.
  • Parallel read-only Windows VFS I/O: Read-only RealVfsFile reads on Windows now run through
    cached, reference-counted overlapped file handles (up to 4,096 open handles independent of the C
    runtime FILE* cap) without holding RealVfsFilesystem::list_lock across disk I/O, allowing
    concurrent multi-core RomFS, audio, and video streaming while cleanly releasing cached handles on
    file and directory mutations.

Vulkan Renderer, Memory & Cache Efficiency

  • Shader stage translation cache: Added a thread-safe StageCache with RAM-tiered capacity
    that deduplicates translated IR and zstd-compressed emitted SPIR-V across pipelines sharing stage
    programs and constant/resource reads, accelerating shader compilation and cold pipeline builds.
  • Vulkan descriptor, layout & render-pass overhead reductions: Added cached VkPipelineLayout
    reuse, tighter fast-draw uniform and storage buffer pathways, render-pass retention across safe
    state transitions, and async draw/dispatch discard policy for unbuilt Switch 2 compute dispatches
    whose output buffers already hold GPU data and color draws targeting historical render targets.
  • Texture, ASTC & low-VRAM management: Improved 4 GB and tight-VRAM buffer/texture garbage
    collection guards so device-pressure collection avoids stalling on live GPU-written working sets,
    offloaded deferred Vulkan memory frees to a background worker, tracked stale render targets and
    superseded images safely, checked resolution-scaled image fit before allocation, and optimized
    ASTC upload and opaque-alpha handling.
  • DMA copy hazard & shader cache robustness: Tracked GPU-written destination subranges across
    buffer DMACopy operations so guest memory and texture uploads never read stale bytes, and
    chunked large shader cache v2 reads cleanly past 2 GiB on Windows.

Shader Recompiler, CPU JIT & System Services

  • Ampere shader compiler improvements: Expanded NVIDIA global-memory buffer routing and
    non-inlined bound-buffer selection helpers, added stage-buffer output (ISBE) and additional
    Ampere instruction lowerings, and reduced redundant pass overhead during shader translation.
  • CPU, host memory & NX2 services: Added shared x86-64 Dynarmic JIT cache reuse, guest memory
    prefaulting and faster Windows memory/zero-page queries, GPU-only region tracking, VP9 range
    encoder fixes, and nx2:gsv service stability improvements.

Tests

  • Added and expanded Catch2 test coverage for large cyclic readback rings and forward-windowed
    speculative downloads, nx2:vi2 present fence planning, concurrent Windows RealVfsFile reads
    and filesystem mutations, StageCache translation reuse, PipelineLayoutCache, stale render
    targets, superseded images, scaled image sizing, ASTC opacity, Ampere stage-buffer outputs, async
    draw/dispatch policy, VP9 range encoding, GPU-only regions, and shared x64 JIT caches.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v1.7.0

Choose a tag to compare

@github-actions github-actions released this 18 Nov 08:19
2498094

Native Windows diagnostics

  • Replaced the Qt imitation terminal and logo with the standard Windows console. The Qt UI stays
    available. Normal output is white, warnings are yellow, and errors are red on a Windows
    console; redirects receive plain UTF-8. Added --console, --no-console, --log-level and
    --log-file, bounded asynchronous logging, and orderly Ctrl+C/Ctrl+Break handling.
  • Save Diagnostic Log… replaces the export from the old console window. Logs retain build,
    host and configured-renderer diagnostics and redact common host paths and credential fields.

Performance and frame generation

  • Shallow library discovery no longer enumerates irrelevant assets inside immediate game folders.
    In the synthetic 110-title fixture, discovery median was 10.70–10.96 ms → 0.65–0.68 ms,
    with identical candidate and directory-watch counts. This is not startup or gameplay FPS evidence.
  • Open-Frame-Gen checks Vulkan device and image capabilities, pauses outside SDR, and falls back to
    game frames after preparation failures. Optional extra frames don't wait for presentation fences.
    Telemetry separates game FPS, queued generation, and original/generated Vulkan presents; the
    latter are not display scanout measurements. Display pacing and input latency still require a
    hardware pass. Packaged notices are included for the verified Nano weights.

Artwork and upgrading

  • Library discovery and startup no longer download artwork. Existing HD sidecars, custom artwork
    and container icons remain usable offline; online lookup is disabled in standard builds pending
    provider validation. No new API keys are saved to the profile.
  • Keep a profile backup before upgrading. No save or game-content migration is required by these
    changes. To roll back, use the previous verified build and the unchanged profile (or its backup).
    The previous build may resume its original artwork-network behavior and console UI.
  • 1.7 validation and release gate: download-only CI packages
    can be checked without creating a release or tag. Windows and matched hardware validation remain
    release gates.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v1.6.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 21:31
757a96e

Ryujinx-Inspired Startup Console

  • Authentic terminal console at launch: Veshiru now opens a dedicated startup console window
    automatically when the emulator launches, recreating the simple console experience of
    Ryujinx/Ryubing.
    • Pure black background with traditional CMD-style white, yellow and red text on a clean
      monospaced terminal surface (no gradients, borders or decorative styling).
    • Large, custom Veshiru ASCII logo printed at startup, followed by a compact system summary
      (CPU, cores/threads, OS, RAM/swap, Vulkan GPU) and a small version/build identifier
      (Veshiru v1.6.0 | build | commit | date).
    • Timestamped startup logs streamed live from the existing Common::Log live-console backend:
      white for INFO/SUCCESS, yellow for WARN, red for ERROR.
    • The console stays open throughout the application's runtime; closing it only hides it while
      log capture keeps running, and it can be reopened from the View > Console menu.
    • Reuses the existing logging and startup infrastructure — the live console backend is now
      refcounted so the diagnostic console window and the startup console can share it without one
      closing stopping the other.

Game List Artwork & Ocarina of Time Online Lookup

  • Fixed Ocarina of Time artwork refresh and online lookup (regression from 1.5):
    • Dump-filename and platform-tagged queries such as The Legend of Zelda Ocarina of Time Switch 2
      now resolve to the canonical The Legend of Zelda: Ocarina of Time title (trademark symbols
      stripped, Switch 2/NX2 platform tags dropped, series+subtitle catalog reconstruction), so the
      keyless Libretro/Wikipedia fallbacks receive the exact boxart name.
    • Added aliases for the full colon-less Zelda/OOT slugs and the Nintendo Welcome Tour form.
    • Wikipedia image hosts (thumb.wikimedia.org) are now allowlisted so REST-summary thumbnails
      resolve as well as originalimage.
    • nlib Title-ID icon URLs advertised over plain HTTP are upgraded to HTTPS so they pass through
      the validated, CA-checked request path.
    • Successful artwork resolutions are logged (Artwork lookup ... resolved from <source>) so the
      startup console and session log show where each icon came from.

Tests

  • Expanded the artwork_cache Catch2 suite with OOT refresh regressions: platform-tagged dump
    filenames, trademark stripping, series+subtitle reconstruction, and the bare-franchise guard.

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.

Veshiru v1.5.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 05:14
1abff37

Frame Generation, Pacing & Present Scheduling

  • Stable FrameGenPacer under real-world gameplay variance & hitches:
    • Replaced single-frame reset triggers with hysteresis-based hitch handling: isolated shader
      compile or streaming hitches (100–400 ms) now skip generation for that single frame without
      destroying active generation levels or poisoning exponential backoff; only genuine loading
      stalls (>= 400 ms) reset active pacing and clear stale backoff for quick post-load recovery.
    • Raised frame-time variance tolerance (35% jitter window vs the previous 15%), added a
      per-level probe-failure table (LevelFailures) so rejecting a higher multiplier (e.g. 2x)
      no longer drops a healthy lower multiplier (e.g. 1x), and added a base-FPS collapse guard
      that rejects probes which tank real game FPS while chasing 60 FPS.
    • Added per-frame FreeFrames() display-capacity trimming (GenerationsWithoutWaiting) and one
      extra spare frame in PresentManager::SetImageCount() so generated frames never starve or
      block the next real game frame on 60 Hz FIFO displays.
    • Replaced raw swapchain-acquire throttling with FramePacer (frame_pacer.h), pacing by real
      game frames and dividing each frame slot evenly across game_frame_presents so 30/60/90/120
      FPS pacing targets work accurately alongside frame generation.
    • Updated FrameGen::LogActivity() to report separate game FPS + generated FPS = output FPS,
      current multiplier limit, hitch skips, and display trims.
  • Open-Frame-Gen zero-allocation warp descriptor caching: pre-allocated a 16-slot cached warp
    descriptor set table in OpenFrameGen keyed by (prev_slot, destination, destination_view),
    eliminating per-frame descriptor allocations and vkUpdateDescriptorSets churn during active
    neural optical-flow generation.

Vulkan Sync, Memory Translation & General FPS

  • Present-fence handoff ordering (DueComposites): routed all Renderer::Composite calls
    through a thread-safe ordered queue (VideoCommon::DueComposites + GpuSplit::OwnsScheduler())
    so present fences signalled from service threads always composite on the scheduler owner in
    exact fence order without overlapping or racing command recording (upstream #1992/#1996).
  • Batched Switch 2 command-list copies & post-sync reads: gated SubmitNx2ListCopies() on
    !scheduler.DeferFlush() so compute/command-list scenes batch submissions instead of flushing
    thousands of times per second, and allowed Nx2ReadListCopy() to reuse up-to-date copies for
    draw_written pages past host sync without forcing Scheduler::Finish() (#2006/#2007).
  • OOM staging recovery without splitting open command buffers: StagingBufferPool::ReleaseMemory()
    now waits only on already-submitted GPU ticks (CurrentTick() - 1) without submitting the
    currently recording command buffer, preserving in-progress draw/dispatch bindings (#1993/#1997).
  • Faster GPU memory translation & submapped range queries:
    • Added a lock-free per-thread 2048-entry GpuToCpuAddress translation cache keyed by
      map_serial (with EDEN_NX2_NO_TRANSLATION_CACHE=1 escape hatch).
    • Stored device_addr in MappingSnapshot::Run and switched GetSubmappedRange /
      GetSubmappedDeviceRange to O(log R) binary search over runs (SubmappedRangeFromRuns,
      #1820), eliminating per-page table walks during buffer/texture binding.
    • Note on correctness: Eglantine's HotPages (f27522bfb) was intentionally not ported
      because unprotecting rewritten guest pages after a single per-frame upload allows subsequent
      mid-frame CPU writes to go untrapped and render stale GPU data.
  • Sampled CPU readback telemetry: replaced the unconditional 1-in-64 CPU read of GPU-written memory LOG_INFO spam in GPU::Impl::OnCPURead with a lock-free atomic 10-second summary
    reporting total reads, sync GPU waits vs async in-flight hits, MiB transferred, and avg/max
    latencies.

Shader Compilation, Pipeline Cache & 4 GB VRAM Management

  • Native mesh pipeline deduplication (MeshVertexInputs, #2012): lent the first seen
    leftover vertex input state to subsequent native mesh draw keys so unrelated vertex input
    registers no longer split identical mesh pipelines into redundant driver compiles (cutting
    duplicate mesh compiles in titles such as Ocarina of Time and Switch 2 mesh-shader workloads).
  • Safe driver pipeline cache persistence (#1838): added PrebuildStartsWithBootBuilds() so
    drivers that cannot safely read VkPipelineCache concurrently with builds (e.g. Intel Windows)
    persist boot and precache driver caches synchronously before starting background prebuilds.
  • 4 GB GPU / DXGI budget stabilization & sparse OOM feedback:
    • Ported RetentionBudget() low-water tracking with 16 MiB upward hysteresis per 30-frame
      check (#1860) so Windows DXGI budget fluctuations no longer trigger texture eviction/re-upload
      thrashing.
    • Made TextureCache pressure_margin proportional on <= 4 GiB GPUs (+256 MiB step,
      -64 MiB relax, 2 GiB cap vs +512 MiB / -128 MiB / 3 GiB on larger GPUs), wired
      MemoryAllocator::AllocateSparseMemory OOM failures to increment pressure_events, and
      deduplicated TrimmedHostInfo via HostInfoForOffset to eliminate repeated ASTC trim warnings.

Game List Artwork & Ocarina of Time Icon Refresh

  • Fixed wrong-game matching and stale icon refreshes:
    • Hardened ScoreArtworkCandidate with a subtitle guard, extra significant candidate word
      penalties, restricted prefix matching, and clean subtitle-complete matching so "The Legend of Zelda: Ocarina of Time" (0400486024DEC000) can never match bare "The Legend of Zelda" or
      unrelated Zelda entries, and "Hyrule Warriors: Age of Imprisonment" cannot match "Age of Calamity".
    • Switched switchiconshowdown.com secondary queries from the bare series prefix before : to
      the distinctive subtitle after : (ExtractSubtitleQuery).
    • Added No-Intro naming normalization (BuildLibretroNameVariants: ": " -> " - ", leading
      "The " -> ", The") across Libretro Nintendo Switch, N64, 3DS, and GameCube boxart
      collections, plus a MediaWiki Action API pageimages fallback after Wikipedia REST summary.
    • Replaced cpp-httplib's set_follow_location(true) with a validated <= 4-hop HTTPS
      redirect loop that reloads the bundled OpenSSL CA store (VESHIRU_BUNDLED_OPENSSL) on
      cross-host redirects and strips SteamGridDB bearer tokens outside steamgriddb.com.
    • Updated RefreshGameArtwork to clear cached sidecar PNG/JSON, failure cooldowns, and
      game_list/<TID>.jpeg thumbnails before searching, resolve canonical catalog titles, and
      overwrite stale wrong TitleRole values (force_title = true).
    • Propagated package.title_id through FileSys::Nup::ProbeNupMetadata into
      NupEditDialog::FindIcon() so NUP metadata icon lookups use the exact Program ID.

Tests

  • Expanded Catch2 unit test coverage across frame_gen_pacer (14 cases including FramePacer and
    GenerationsWithoutWaiting), due_composites (3 multithreaded ordering cases),
    mesh_vertex_input (4 deduplication cases), eviction_age (RetentionBudget),
    pipeline_eviction_policy (PrebuildStartsWithBootBuilds), memory_manager_runs
    (GetSubmappedRange / GetSubmappedDeviceRange), vulkan_buffer_oom (ReleaseMemory), and
    artwork_cache (OOT / Hyrule Warriors scoring, subtitle extraction, No-Intro Libretro variants,
    and cache clearing).

Veshiru is a Windows-exclusive emulator: it is built and tested for 64-bit Windows 10 and 11 only.

Extract the entire zip and run veshiru.exe, or veshiru-cmd.exe from a terminal.

Build Type Standard PGO (Recommended) Notes
amd64 / x86_64 zip PGO zip Both built with clang-cl and ThinLTO; the PGO zip uses a balanced multi-game Switch 1 & Switch 2 profile

The PGO build is compiled with profile-guided optimization using a balanced multi-game Switch 1 & Switch 2 runtime profile (veshiru-windows.profdata). Prefer it on modern x86_64 CPUs.