StressLab v10.0

Internal Hardware Testing Suite for Windows

StressLab is an all-in-one hardware stress testing, diagnostics, and Windows repair tool built for PC builders, repair shops, and QA workflows. It runs sequential stress tests across CPU, RAM, GPU, VRAM, and Disk, with live temperature monitoring, deep SMART diagnostics, SMART self-tests, Windows system repair (SFC/DISM), and one-click service resets.

---

What's new in v10

• Bundled .NET 10 sensor reader — the entire LibreHardwareMonitor stack ships pre-compiled inside StressLab.exe via PyInstaller. Customer machines need zero runtime downloads, zero compilation, zero external dependencies. No more "Rebuild Sensors" lock-while-running races.
• PawnIO replaces WinRing0 entirely — Microsoft-signed kernel driver, no Defender false positives. The PawnIO installer is bundled inside StressLab.exe and runs silently on first admin launch. Legacy WinRing0 binaries from previous installs are automatically cleaned up (including locked .sys files via reboot-deletion fallback).
• Per-test detailed metrics in stress reports — both .txt and .html exports now include CPU total ops + ops/sec, RAM passes/errors, GPU frame counts + average FPS, VRAM bandwidth (read/write GB/s) + total verified, disk SEQ1M Q8T1 speeds + total written/verified.
• Full-test HTML graph coverage — graph history expanded from 90 seconds to 30 minutes so the embedded report charts cover the entire stress run, not just the last minute.
• Direct SMART IOCTL reader — CrystalDiskInfo-style direct drive access via IOCTL_STORAGE_QUERY_PROPERTY (NVMe) and IOCTL_ATA_PASS_THROUGH (SATA). Actual SMART attribute reads on every drive instead of "N/A" defaults.
• Drive identity in health check — model, serial number, firmware revision, total host data read/written (TBR/TBW), all read directly from the drive.
• TBW endurance warnings — heuristic warning at 80% of estimated rated TBW (600 TBW per TB), error at 100%.
• SMART self-tests — short and long (extended) self-test triggers and result reading for both SATA (full support) and NVMe (read always works; trigger depends on driver).
• Windows Repair tools — SFC /scannow and the full DISM trio (CheckHealth / ScanHealth / RestoreHealth) with live streaming output.
• Service reset presets — one-click reset for Windows Update, Network Stack, Audio, Print Spooler, Windows Search, and Explorer/Shell, with cache cleanup.

For the full version history, see CHANGELOG.md. For a quick orientation to the app's tabs and buttons, see QUICKSTART.md.

---

Features

• Sequential stress testing — run CPU → RAM → GPU → VRAM → Disk in order, or pick individual tests
• Power mode — simultaneous CPU + GPU load for PSU/thermal stress testing
• CPU stress — multi-process integer + float workload, targets 95%+ utilization across all cores
• RAM verify — multi-threaded pattern testing with VirtualLock (pinned pages), uses memcmp for fast in-place verification with 5 test patterns + inversions
• GPU stress — adaptive OpenGL raymarching shader that auto-tunes to ~95% GPU utilization
• VRAM verify — integrates memtest_vulkan for Vulkan compute-based memory error detection (NVIDIA, AMD, Intel)
• Disk verify — unbuffered write + readback verification with per-block latency measurement, bus-type-aware speed benchmarking, configurable write cap, plus SEQ1M Q8T1 benchmark for accurate NVMe sequential speeds
• Live temperature monitoring — CPU, GPU, VRM, and SSD temps via the bundled .NET 10 sensor reader using LibreHardwareMonitorLib v0.9.6 over the Microsoft-signed PawnIO driver
• Live performance graphs — temperature, load%, and power graphs that update in real time during stress runs and embed in the HTML reports for the full duration of the test
• Voltage rail monitoring — +12V, +5V, +3.3V tracking with ATX12V tolerance warnings (where the motherboard SuperIO chip exposes them)
• Direct SMART reader — reads NVMe SMART/Health (Log Page 0x02) and SATA SMART attributes directly via IOCTL — works where Windows' Get-StorageReliabilityCounter returns nothing
• SMART self-tests — trigger and read short/long self-tests on SATA drives; read self-test logs on NVMe drives (trigger depends on your NVMe driver supporting IOCTL_STORAGE_PROTOCOL_COMMAND)
• TBW endurance tracking — warns when SSDs approach their rated total bytes written
• Windows repair — SFC and DISM with live streaming output, no PowerShell window required
• Service reset presets — one-click recovery for the most commonly broken Windows services
• Speed benchmarking — auto-detects NVMe vs SATA and warns on underperformance (NVMe <1800 MB/s, SATA <400 MB/s)
• Auto-export — health and stress reports automatically saved to Documents\StressLab Reports\ on completion
• Health checks — driver status, BIOS age, TPM, Secure Boot, Windows activation, BSoD history, and direct-IOCTL SMART
• System info — CPU, RAM, GPU (with PCIe link gen/width), OS build, and disk summary
• Export — generate timestamped certificates with pass/fail results and per-test detailed metrics (auto or manual)
• Dark themed UI — modern dark interface built with tkinter

Requirements

For end users (running the built exe)

• OS: Windows 10 (1903+) or Windows 11 (x64)
• Privileges: Administrator (the exe self-elevates via UAC manifest)
• Network: Not required. Everything ships inside the exe.
• Runtime: None. .NET 10 is bundled, PawnIO installer is bundled, sensor reader is bundled.

For developers (building from source)

• OS: Windows 10 (1903+) or Windows 11 (x64)
• Python: 3.10 or newer
• .NET 10 SDK: required to build the sensor reader. Install from dotnet.microsoft.com.
• GPU stress: OpenGL 3.3+ capable GPU and drivers (integrated or discrete)
• VRAM test: Vulkan 1.1 capable GPU and drivers (any modern NVIDIA, AMD, or Intel GPU)

Python Dependencies

psutil>=5.9.0
wmi>=1.5.1
pywin32>=306
moderngl>=5.8.0
glcontext>=2.5.0
pyinstaller>=6.0

Install with:

pip install -r requirements.txt

Note: moderngl and glcontext are used only for the GPU stress test (OpenGL shader). They are optional — if not installed, the GPU stress test will be unavailable but everything else works.

Bundled Components

These ship inside StressLab.exe. No runtime downloads, no GitHub access, no external dependencies on customer machines.

Component	Purpose	Size	License	Source
lhm_reader.exe	.NET 10 sensor reader (self-contained)	~30 MB	MIT (StressLab)	Built locally via helper\build.bat
LibreHardwareMonitorLib v0.9.6	Bundled inside lhm_reader.exe (NuGet)	included	MPL 2.0	GitHub
PawnIO_setup.exe	Microsoft-signed kernel driver installer	~3 MB	MIT	GitHub
memtest_vulkan.exe	VRAM error detection (Vulkan compute)	~600 KB	zlib	GitHub

On first launch, StressLab extracts lhm_reader.exe to %LOCALAPPDATA%\StressLab\lhm\ and runs PawnIO_setup.exe -install -silent (when running as Admin) to install the kernel driver. Both happen silently with no user interaction. Subsequent launches reuse the deployed files.

memtest_vulkan is downloaded silently in the background on startup — typically ready by the time the user clicks Start.

Usage

Run the prebuilt EXE

dist\StressLab.exe

The exe self-elevates via UAC manifest, so it always runs as Administrator. No _admin.bat wrapper needed.

Run from source

python stresslab.py

For full functionality (PawnIO install, direct SMART access, self-tests, SFC/DISM, service resets):

stresslab_admin.bat

Or right-click → Run as Administrator.

Build standalone EXE

build_exe.bat

This 5-step script:

1. Installs Python dependencies via pip
2. Builds the .NET 10 sensor reader (helper\build.bat)
3. Stages bundled assets (copies lhm_reader.exe to assets\, verifies PawnIO_setup.exe is present)
4. Runs PyInstaller against stresslab.spec
5. Verifies dist\StressLab.exe was produced

Produces dist\StressLab.exe — a single-file executable with admin elevation built in. Final size is approximately 31 MB (UPX-compressed).

One-time setup before first build: download PawnIO_setup.exe from github.com/namazso/PawnIO.Setup/releases/latest and save it as assets\PawnIO_setup.exe. The build is otherwise fully offline-capable.

Running a test

1. Select which tests to run (CPU, RAM, GPU, VRAM, Disk) using the checkboxes
2. Set the duration per test (5m, 15m, or 60m)
3. Optionally set the disk write cap (200GB, 500GB, or 1TB) — default 200GB
4. Click ▶ START
5. Tests run sequentially — progress, temperatures, and metrics update live
6. When complete, a pass/fail summary is shown in the log
7. Reports auto-export to Documents\StressLab Reports\ (uncheck "Auto-export" to disable)
8. Click Export for manual save-as to a custom location

Test Details

CPU Stress Spawns worker processes (one per logical core) running tight integer and floating-point loops. Targets 95%+ CPU utilization. Temperature is monitored throughout.

RAM Verify Allocates ~75% of available RAM using VirtualAlloc with VirtualLock (pins pages to physical RAM, preventing swapping). Runs 5 test patterns (Solid 0x00, Solid 0xFF, Checkerboard 0xAA, Checkerboard 0x55, Random) plus their bitwise inversions across multiple worker threads. Verification uses msvcrt.memcmp for fast in-place comparison — only falls back to byte-level inspection on mismatch.

GPU Stress Renders a computationally expensive raymarching shader (SDF scene with reflections, refractions, soft shadows, ambient occlusion, and fractal noise). Adaptive algorithm adjusts shader complexity (ray steps and noise octaves) to maintain ~95% GPU utilization. Uses a background nvidia-smi poller thread for utilization feedback (no CPU impact from process spawning).

VRAM Verify Launches memtest_vulkan as a subprocess — a Vulkan compute-based memory tester that allocates as much VRAM as possible and writes/reads test patterns directly via compute shaders. Uses non-sequential memory access patterns designed to catch address bus errors that linear patterns miss. Output is read by tailing memtest_vulkan's own log file (avoids Windows pipe buffering issues). Reports iteration count, read/write bandwidth, and any bit-level errors detected. Works on any GPU with Vulkan 1.1 support.

Disk Verify Creates a temporary test file (25% of free space, up to 2GB) and performs unbuffered write + readback verification using the Windows CreateFileW API with FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH — bypasses the entire OS filesystem cache so every write goes to NAND and every read comes from NAND.

Each pass:

1. Writes 1MB blocks with a test pattern + position-dependent stamp
2. Reads back each block, measures per-block latency, and verifies via memcmp
3. Cycles through 5 patterns: Random (incompressible), 0xAA, 0x55, 0xFF, 0x00

Plus a SEQ1M Q8T1 benchmark phase using 8 worker threads with interleaved offsets to saturate NVMe controller queues — catches drives that pass verification but are running below their spec sequential speed.

What it catches that SMART misses:

• Bad NAND cells — write succeeds but readback data differs
• Degrading cells — blocks >10ms read latency (SSD needs internal retries)
• Controller issues — data corruption in the I/O path
• Fake/counterfeit drives — later blocks return garbage
• Speed degradation — auto-detects NVMe vs SATA via WMI and warns if speeds fall below expected thresholds

The write cap (200GB / 500GB / 1TB) limits total bytes written to protect drive endurance. A 200GB test uses ~0.03% of a typical 600 TBW SSD's lifetime. If the cap is reached before the timer expires, the test completes early automatically.

Power Mode Runs CPU stress and GPU stress simultaneously for maximum system-wide thermal and power delivery stress testing.

SMART Health Check

The SMART check on the Health tab uses direct IOCTL reads (CrystalDiskInfo-style) for accurate data on every drive — no more falling back to "N/A" defaults.

For each drive it reports:

• Identity: model, serial number, firmware revision
• Health, wear percentage, power-on hours, power cycles, temperature
• Total host data read and written (TBR / TBW)
• NVMe-specific: critical warnings, available spare percentage
• SATA-specific: pending sectors, uncorrectable sectors, reallocated sectors

Warning thresholds

Trigger	Status	Threshold
Wear % over 80	Error	NVMe Percentage Used > 80, or SATA Wearout (0xE9) value < 20
Wear % over 50	Warning	(same attributes, intermediate range)
Power-on hours over 35,000	Warning	About 4 years of 24/7 operation
Uncorrected read errors	Error	Any non-zero count
NVMe media errors	Error	Any non-zero count
NVMe critical warning bits set	Warning	Any of bits 0–4 from the SMART log byte 0
NVMe spare below threshold	Warning	Available spare % < drive's reported threshold
SATA pending sectors	Error	Any non-zero count
SATA uncorrectable sectors	Error	Any non-zero count
SATA reallocated sectors over 100	Warning	Attribute 0x05 raw count
Drive Windows HealthStatus not "Healthy"	Error	From Get-PhysicalDisk
TBW over rated endurance	Error	Host writes >= estimated 600 TBW per TB capacity
TBW approaching rated endurance	Warning	Host writes >= 80% of estimated 600 TBW per TB

The TBW heuristic of 600 TBW per TB is representative of mid-to-high consumer TLC SSDs (Samsung 970 EVO, WD Black SN850, Crucial MX500). QLC drives are typically rated lower (Samsung 870 QVO 1TB is 360 TBW). The warning surfaces both written total and estimated rating so you can compare against the manufacturer's actual datasheet.

SMART Self-Test (Utilities tab)

Triggers the drive's built-in self-test. The drive runs the test in its own firmware so you can keep using your computer normally.

• Short test (~2 min): electrical/mechanical health check
• Long test (1–2+ hours): reads every sector

SATA drives — full support via IOCTL_ATA_PASS_THROUGH with SMART EXECUTE OFF-LINE IMMEDIATE (cmd 0xB0 / feat 0xD4). Trigger and read both work.

NVMe drives — read always works (uses IOCTL_STORAGE_QUERY_PROPERTY with NVMe Log Page 0x06). Trigger requires the NVMe driver to expose IOCTL_STORAGE_PROTOCOL_COMMAND writes, which most consumer NVMe drivers (including Microsoft's stornvme on older Windows builds) don't do. StressLab detects this on click and shows a list of vendor utilities you can use to trigger the test, then come back to View Results to see the outcome.

Windows Repair (Utilities tab)

Live-streamed output for the standard Windows repair toolkit:

• SFC /scannow — scans and repairs system files (typically 5–15 minutes)
• DISM /CheckHealth — quick component store check (no changes)
• DISM /ScanHealth — full integrity scan (5–10 minutes, read-only)
• DISM /RestoreHealth — repair component store from Windows Update (10–30 minutes, downloads if needed)

Output streams in real-time to the panel — no detached PowerShell window. SFC's UTF-16 console output is decoded properly.

Service Reset Presets (Utilities tab)

One-click stop / cache-cleanup / start cycle for commonly broken services. Each preset shows a confirmation dialog with what it will do before running.

Preset	What it does
Windows Update	Stops BITS, wuauserv, appidsvc, cryptsvc; renames SoftwareDistribution and catroot2 with timestamped backup; restarts services
Network Stack	Stops Dnscache; runs netsh winsock reset, netsh int ip reset, ipconfig /flushdns /release /renew
Audio	Stops/starts Windows Audio + Audio Endpoint Builder
Print Spooler	Stops spooler, clears %SystemRoot%\System32\spool\PRINTERS\*, starts spooler
Windows Search	Stops/starts WSearch (often fixes Start menu search)
Explorer / Shell	Kills and restarts explorer.exe (taskbar, Start menu, desktop)

Auto-Export

When enabled (default), health check results and stress test certificates are automatically saved to:

%USERPROFILE%\Documents\StressLab Reports\

Filenames include the hostname and timestamp, e.g. StressLab_Stress_DESKTOP-ABC_20260301_143022.txt. Both .txt and .html versions are saved every time. The "Auto-export" checkbox appears on both the Health and Stress tabs. Manual export via the Export button is always available regardless of this setting.

The HTML version of the stress report includes embedded SVG performance charts covering the full test duration, a peak readings dashboard, and per-test detailed metrics (CPU ops/sec, RAM passes, GPU frame counts, VRAM bandwidth, disk MB/s).

Architecture

StressLab is a single-file Python application (~5,500 lines) plus a separate .NET 10 sensor reader (~700 lines of C# across 5 files). Both ship pre-compiled inside StressLab.exe.

Top-level layout

StressLab/
├── stresslab.py            # Main application (Python)
├── stresslab.spec          # PyInstaller spec - bundles helper + PawnIO into exe
├── stresslab.ico           # Application icon
├── requirements.txt        # Python dependencies
├── stresslab_admin.bat     # Run-as-admin launcher (source mode)
├── build_exe.bat           # 5-step build pipeline
├── helper/                 # .NET 10 sensor reader source
│   ├── lhm_reader.csproj   # Project file (NuGet ref to LibreHardwareMonitorLib 0.9.6)
│   ├── Program.cs          # Entry point, poll loop, JSON output
│   ├── SensorReading.cs    # Output struct + source-generated JSON context
│   ├── SensorMatcher.cs    # Per-SensorType dispatch with vendor-name matching
│   ├── SensorDumper.cs     # Diagnostic dump mode
│   ├── StdoutRedirector.cs # Module initializer - silences native lib chatter
│   ├── build.bat           # dotnet publish wrapper
│   └── README.md           # Helper-specific docs
├── assets/                 # Bundled into exe via PyInstaller --add-data
│   ├── lhm_reader.exe      # Built by helper/build.bat
│   └── PawnIO_setup.exe    # Manual one-time download from namazso/PawnIO.Setup
├── LICENSE                 # MIT license
├── THIRD_PARTY_LICENSES    # Bundled component licenses
├── README.md               # This file
├── CHANGELOG.md            # Version history
└── QUICKSTART.md           # Quick orientation guide for end users

Python dependencies

• tkinter — UI framework (ships with Python)
• psutil — CPU/RAM metrics and process management
• wmi — Windows system information queries
• moderngl — OpenGL context and shader rendering for GPU stress
• ctypes — direct Windows API calls (VirtualAlloc, VirtualLock, CreateFileW, kernel32, msvcrt, IOCTL pass-through, MoveFileEx for reboot-deletion)
• subprocess — manages memtest_vulkan, lhm_reader, PawnIO installer, and SFC/DISM streaming
• multiprocessing — CPU stress worker processes
• threading — RAM verify workers, disk verify worker, nvidia-smi poller, temperature reader, async stop handlers, repair output streamers

Temperature Monitoring Priority Chain

1. lhm_reader.exe (bundled) — pre-compiled .NET 10 helper using LibreHardwareMonitorLib v0.9.6 over the PawnIO driver. Best coverage; this is the primary path on every Phase 2 install.
2. WMI OHM/LHM namespace — fallback if user runs LHM/OHM GUI separately
3. nvidia-smi — fallback for NVIDIA GPU temperature only
4. WMI thermal zone — basic CPU fallback

The helper subprocess streams JSON sensor lines on stdout at 1 Hz. Python parses each line and updates the live displays. Native library chatter (Intel Level Zero, NVIDIA driver banners) is silenced via a [ModuleInitializer] that redirects the OS-level stdout handle to NUL before any other code runs.

SMART Reading

Direct IOCTL pass-through, requires Administrator. Two paths:

• NVMe → IOCTL_STORAGE_QUERY_PROPERTY with StorageDeviceProtocolSpecificProperty reading NVMe Log Pages 0x02 (SMART/Health), 0x06 (Self-test log), and CNS 0x01 (Identify Controller). Works on every NVMe driver including Microsoft's stornvme.
• SATA → IOCTL_ATA_PASS_THROUGH sending SMART READ DATA (0xB0/0xD0), SMART READ LOG (0xB0/0xD5), IDENTIFY DEVICE (0xEC), and SMART EXECUTE OFF-LINE IMMEDIATE (0xB0/0xD4) for self-tests.

Runtime data (auto-created)

%LOCALAPPDATA%\StressLab\
├── lhm\
│   └── lhm_reader.exe       # Extracted from bundle on first launch (~30 MB)
└── memtest_vulkan.exe       # Downloaded on first launch (~600 KB)

PawnIO driver lives at C:\Program Files\PawnIO\PawnIO.sys and is registered as a kernel-mode service named PawnIO. It's installed silently on first admin launch via the bundled PawnIO_setup.exe -install -silent.

Auto-exported reports

%USERPROFILE%\Documents\StressLab Reports\
├── StressLab_Health_HOSTNAME_YYYYMMDD_HHMMSS.txt
├── StressLab_Health_HOSTNAME_YYYYMMDD_HHMMSS.html
├── StressLab_Stress_HOSTNAME_YYYYMMDD_HHMMSS.txt
└── StressLab_Stress_HOSTNAME_YYYYMMDD_HHMMSS.html

Build

The default stresslab.spec produces a single-file --onefile exe with admin elevation and bundled assets. The full pipeline is just build_exe.bat. For better Defender behavior (occasionally an issue with single-file PyInstaller bootstraps), switch to --onedir by editing stresslab.spec:

exe = EXE(pyz, a.scripts, [], exclude_binaries=True, name='StressLab',
    debug=False, strip=False, upx=True, console=False,
    uac_admin=True, icon='stresslab.ico')
coll = COLLECT(exe, a.binaries, a.datas, strip=False, upx=True,
    upx_exclude=[], name='StressLab')

This produces a dist\StressLab\ folder you ship as a zip. Defender heuristics flag the self-extracting --onefile mode much more aggressively than --onedir.

Troubleshooting

Temperatures show as "—" Run as Administrator so PawnIO can install. Once the driver is registered, temperatures will appear after a quick app restart. PawnIO is Microsoft-signed and won't trigger Defender.

"PawnIO needed — restart as Admin to install" StressLab needs administrator privileges to install the PawnIO kernel driver. The exe self-elevates via UAC, so this typically only appears when running from source — use stresslab_admin.bat or right-click → Run as Administrator.

SMART check shows "100% health" or "N/A" power-on hours You're running without admin privileges, so the direct IOCTL path is unavailable and StressLab falls back to PowerShell's Get-StorageReliabilityCounter which returns nothing on many drives. Run as Administrator for the full direct-IOCTL SMART data.

NVMe self-test "Cannot trigger" error Your NVMe driver doesn't expose IOCTL_STORAGE_PROTOCOL_COMMAND for command writes. This is the case for most NVMe drivers including Microsoft's stornvme on older Win10/11 builds. Workaround: trigger the test from the drive vendor's utility (Samsung Magician, WD Dashboard, Crucial Storage Executive, etc.), then come back to StressLab and click "View Results" — the result reading path works on all NVMe drives.

"memtest_vulkan not found" during VRAM test The auto-download may have failed (firewall, no internet). Go to the Utilities tab and click "Download memtest_vulkan" manually. Requires internet access to GitHub.

Windows Defender flags the exe With v10's switch to PawnIO and pre-compiled bundled helper, the WinRing0 false-positive issue is gone. If your bundled StressLab.exe is still flagged, it's likely the PyInstaller --onefile heuristic. Switch the spec to --onedir mode (see Build section). You can also submit the binary to Microsoft for whitelisting at microsoft.com/wdsi/filesubmission.

Sensor reader not deployed / "Reinstall Sensors" button On the Utilities tab there's a Reinstall Sensors button that re-extracts the bundled lhm_reader.exe to %LOCALAPPDATA%\StressLab\lhm\ and restarts the helper subprocess. Useful after StressLab updates (auto-detected by helper file size — anything under 1 MB at the helper path is recognized as a legacy stub and replaced automatically on launch). No reboot needed.

GPU stress test unavailable Install moderngl and glcontext: pip install moderngl glcontext. Requires OpenGL 3.3+ drivers.

GPU utilization settles below target The adaptive algorithm needs nvidia-smi for feedback. Ensure NVIDIA drivers are installed. On AMD/Intel GPUs, the shader runs at fixed high complexity without adaptive tuning.

Disk test shows low speeds on NVMe If the test file is small relative to the drive's SLC cache, speeds may appear normal even on a degrading drive. Use the 500GB or 1TB write cap to push past the cache and measure steady-state performance. Low speeds on pass 1 are ignored (cold start).

UEFI reboot fails the first time, works the second Fixed in v10. The reboot flow now clears stale shutdown state with shutdown /a and retries automatically before reporting failure.

Windows shows "Not Activated" in health checks Correctly reports Windows activation status. WMI license codes 0 (Unlicensed) and 5 (Notification) are both reported as "Not Activated".

SSD shows 94°C false alert (older builds) Fixed in v10. Earlier builds were reading the SSD's static "Critical Temperature" SMART threshold (a fixed value the drive reports as "this is what hot would be") as the live current temp. The matcher now skips Warning/Critical/Threshold-named sensors and only uses live temp readings.

Build fails: "lhm_reader.exe not found" Run helper\build.bat first to produce the .NET 10 sensor reader, then re-run build_exe.bat. Or just run build_exe.bat directly — it chains the helper build automatically. Requires the .NET 10 SDK on the build machine.

Build fails: "PawnIO_setup.exe not found" One-time setup: download PawnIO_setup.exe from github.com/namazso/PawnIO.Setup/releases/latest and save it as assets\PawnIO_setup.exe. The build is otherwise fully offline-capable.

License

StressLab is licensed under the MIT License.

Third-party components have their own licenses — see THIRD_PARTY_LICENSES for details.

Credits

StressLab — Cincy Power Computers, LLC

Built with:

• LibreHardwareMonitor (MPL 2.0) — hardware sensor access
• PawnIO (MIT) — Microsoft-signed kernel driver
• memtest_vulkan by GpuZelenograd (zlib) — Vulkan VRAM error detection
• psutil (BSD 3-Clause) — system metrics
• moderngl (MIT) — OpenGL rendering