# memtest_vulkan: a Vulkan compute stress test for GPU video memory

> memtest_vulkan is a Rust tool that writes and reads back GPU video memory through Vulkan compute shaders to find unstable memory, aimed at overclockers and repair work. It reports errors the moment they appear, needs only a Vulkan 1.1 driver, and comes as a Windows executable or a Linux archive with X86_64 and AARCH64 builds.

**GpuZelenograd/memtest_vulkan** — Vulkan compute tool for testing video memory stability

- Repository: https://github.com/GpuZelenograd/memtest_vulkan
- Website: https://github.com/GpuZelenograd/memtest_vulkan/blob/main/Readme.md
- Stars: 923 · Forks: 52
- Language: Rust
- License: Zlib
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/gpuzelenograd-memtest-vulkan

## A memory correctness test, not a benchmark

memtest_vulkan is an open source cross-platform tool written in Vulkan compute to stress test video memory for stability during overclocking or repair. That framing matters, because it narrows what the tool is for. It is not a graphics benchmark and it does not produce a performance score for comparing cards. It is asking a single question: does this memory return the same bytes it was given? The audience is narrow and clear. An overclocker who has pushed memory clocks and wants to know whether the result is stable, or someone repairing a card whose artefacts look like memory faults, wants a hammer that writes a pattern into video memory and reads it back to see if anything changed. The tool runs as long as you let it and reports the moment it finds a discrepancy rather than at the end, which is what makes it usable as a watch-while-you-do-something-else tool.

## Errors surface as they happen, with a per-bit breakdown

The reporting is where a memory test earns its keep. Any found errors are reported immediately during the run, with a multi-line detail block rather than a single count. The sample run in the documentation shows a single-wire, single-bit error on an NVIDIA P104-100, and the detail is genuinely diagnostic. The output gives the error mode, NEXT_RE_READ or INITIAL_READ, the total error count out of the tested count with a percentage, and the address range the errors fall in. Under that is a hexadecimal breakdown of which bit positions carry errors, alongside counters for errors per bit index and per memory bit count, which tells you whether the fault is concentrated in one bit or spread across the memory. There is also a comparison of the actual value against the expected one, with the actual maximum and minimum. A fault pattern that repeats on the same bit positions points at a specific memory cell, while a spread points at something else, and the tool hands you the data to tell them apart.

## The documented procedure is simple: start it, wait at least six minutes, stop with Ctrl+C

The usage instructions are almost too short to need a section. Just start the application, wait at least 6 minutes, and stop testing by Ctrl+C. On Windows you take the .exe from the latest release, or the CI build artifacts if you would rather have the current build, though GitHub keeps those for only the last 3 months. There is no installation, no parameters, no configuration and no admin rights required. You start the test by double-clicking the utility. On Linux the archives carry prebuilt binaries for X86_64 desktops and AARCH64 embedded boards, and the instruction is specific: open a terminal in the folder with the extracted file and explicitly run the binary, because double-clicking it in a GUI would start the test in the background with no way to stop it. That is a real trap and it is tracked as an issue in the repository, which tells you it has bitten people.

On Linux, from a terminal in the folder holding the extracted binary:

```bash
./memtest_vulkan
```

And when several Vulkan drivers are installed and you need to pick one explicitly:

```bash
VK_DRIVER_FILES=/usr/share/vulkan/icd.d/nvidia_icd.json ./memtest_vulkan
```

The second form is the way to guarantee you are testing the discrete card rather than a software driver.

## Device selection on Linux, and the llvmpipe trap

On Linux the tool shows a device selection menu after startup, because the platform commonly ships an additional pure-CPU Vulkan driver called llvmpipe alongside the real hardware driver. You can wait 10 seconds for automatic selection or type the device number yourself. That menu is the single most important thing to get right, because if the automatic choice picks the software rasteriser you will be testing the CPU's memory emulation rather than the graphics card, and the result tells you nothing about the card. On Windows the tool prints the device it found, with its bus address, device id and memory size, such as 8GB Intel Iris Xe Graphics, and confirms it as the device under test. Where several driver packages are installed, the documentation shows that you may need to set environment variables explicitly, for example pointing VK_DRIVER_FILES at a specific ICD file to select the NVIDIA driver. The reasoning behind those variables is in the troubleshooting section of the readme.

## Building from source with Cargo, and what the manifest says about the project

The repository is a Rust project with a Cargo.toml, a Cargo.lock and a workspace. The manifest names the package memtest_vulkan at version 0.6.0, on edition 2024 with a minimum rust-version of 1.89. The Vulkan side comes from erupt at 0.23 with default features off, and libloading at 0.9.0 with default features off, which is how the tool loads the system Vulkan runtime rather than linking a bundled one. Platform code is split cleanly: windows-sys 0.61.2 on Windows for console, foundation and threading, and nix 0.30.1 on unix with the signal feature, which is the Ctrl+C handling. There is a local workspace member called memtest_vulkan_build with its own path dependency, and helper scripts run-build.sh and run-lint.sh sit at the top level. The release profile is tuned for small binaries, with codegen-units set to 1, lto enabled and strip enabled.

## Large PCIe BAR handling changed in v0.5.0, and the version trail explains the age

The release history is worth reading because it explains the current state of the tool. v0.3.0 from September 2022 is labelled as the first public release and marked outdated. v0.4.0 followed in the same month, also labelled older. Then v0.5.0 came on 2025-09-11 with a note about tuning behavior with large PCIe BARs, which is a real change in how the tool addresses memory on modern GPUs with large BAR windows. The manifest is already at 0.6.0, so work continues past the last tagged release. The repository is not archived and the last push was on 2026-06-02. The Zlib licence is on the permissive side and carries no obligation beyond preserving the notice, which is a sensible choice for a diagnostic utility that people may want to bundle.

## What this tool cannot tell you about a faulty card

The limitation worth stating plainly is scope. A Vulkan compute memory test exercises the memory path that a compute shader can reach, and that path is not the whole card. It does not run your games, it does not test the display output path, the video encoder or decoder, the ray tracing units, or the PCIe link between card and system, and it says nothing about the core logic or the power delivery. A card that passes memtest_vulkan can still produce artefacts in a workload that stresses a different block. The tool also gives you no aggregate verdict about card health beyond the presence or absence of memory errors within the test duration, and the documentation itself points out that most of the time it is enough just to check whether errors are absent or present, with the detailed breakdown there for advanced cases. If you need to localise a fault, the error address range and bit pattern are the handles to work with.

## Conclusion

memtest_vulkan suits someone testing a graphics card they have overclocked, repasted or suspect of a memory fault, and willing to sit through a six minute run with the card under load. It does not suit someone who wants a general hardware diagnostic or a benchmark, since it measures nothing but memory correctness, and it will report nothing useful on a machine whose Vulkan stack is a pure-CPU driver such as llvmpipe. Before you trust a pass, run it for longer than the six minutes the documentation suggests and confirm the device it selected is your discrete GPU rather than a software rasteriser, since the tool happily tests whichever device you pick from its selection menu.

## FAQ

### How do I run memtest_vulkan on Windows?

Download the .exe from the latest release and double-click it. No installation, parameters, configuration or admin rights are required, and detected errors are displayed immediately during the run. You stop the test with Ctrl+C.

### How do I run memtest_vulkan on Linux?

Unpack the archive with prebuilt binaries for X86_64 or AARCH64 from Releases, open a terminal in that folder and explicitly run ./memtest_vulkan. Do not double-click the binary in a file manager, because that starts the test in the background with no way to stop it.

### What does memtest_vulkan require to run?

It requires a system-provided Vulkan loader and driver supporting Vulkan 1.1, which is already installed with graphics drivers on most operating systems. The Linux release also shows cases where VK_DRIVER_FILES has to be set explicitly when several driver packages are installed.

### How long should the GPU memory test run?

The documentation says to start the application, wait at least 6 minutes and stop testing with Ctrl+C. Longer runs give a better picture of intermittent faults, and the tool prints progress reports with iteration counts and cumulative bytes written and read.

## Sources

- [GpuZelenograd/memtest_vulkan on GitHub](https://github.com/GpuZelenograd/memtest_vulkan)
- [License: Zlib](https://github.com/GpuZelenograd/memtest_vulkan/blob/main/LICENSE)
- [Project website](https://github.com/GpuZelenograd/memtest_vulkan/blob/main/Readme.md)
- [README](https://github.com/GpuZelenograd/memtest_vulkan/blob/main/README.md)
- [Releases](https://github.com/GpuZelenograd/memtest_vulkan/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gpuzelenograd-memtest-vulkan