Re-check a Published GPU Hardware Check, Line by Line

On 16 and 17 October 2026 we rented one standard machine per GPU model and ran hwcheck on each. hwcheck is our open-source hardware check. The outputs are public. This tutorial takes one of them, the H100 run, and shows what you can check from the public files alone. You can confirm that the script is the open-source one. You can confirm that the printed result follows from its rules. You can see how the same tool behaves on your own machine. Then come the limits, and they are real: a published output is a text file, not a signature.

If you only want the one-liner to run on a machine you rent, How to Check the GPU You Rented Is the One You Paid For explains it. Every command below was run on 20 October 2026 on Ubuntu 24.04, in a fresh directory, exactly as printed. Outputs are pasted as printed, except our workstation's name.

Step 1: read the published run

mkdir hwcheck-audit && cd hwcheck-audit
curl -sSfO https://voltagegpu.com/hwcheck-proofs/2026-10-17/h100.txt
cat h100.txt

VoltageGPU hwcheck proof
date: 2026-10-17T18:20:18.246Z
machine: d4093d0c-8d7c-448a-b4e0-a34e44468ea8 (standard tier, rented directly from our standard provider: the machines our listing shows)
listing: 1x H100 (rented on a node of 8 GPUs)
command: curl -fsSL https://voltagegpu.com/hwcheck.sh | bash -s -- --gpu "H100" --gpus 1 --no-net
exit code: 0 (0 = matches the listing, 2 = does not)
VoltageGPU hardware check (read-only, nothing about this machine is sent anywhere)
  2026-10-17 18:20 UTC · 09c3eb27fd21

                 LISTED                   MEASURED                           
  GPU model      H100                     NVIDIA H100 80GB HBM3              OK
  GPU count      1                        1                                  OK
  VRAM per GPU   -                        80 GB                              info
  Driver / CUDA                           580.173.02 / 13.0                  OK
  CUDA compute                            matmul on 1/1 GPU                  OK
  CPU                                     192 threads                        info
  RAM            -                        124 GB (container limit)           info
  Disk (/)       -                        118 GB, 118 GB free                info

RESULT: MATCHES THE LISTING

The first six lines were written by our publishing script. The machine was one GPU of an 8-GPU node, rented directly from the provider behind our standard listing, not through a customer account. The command passed the model and the GPU count, and nothing else. The rest is what hwcheck printed. The short hex string after the date is the machine's hostname. The index of the 17 October runs lists the other models.

Step 2: check that the script is the open-source one

curl -fsSL https://voltagegpu.com/hwcheck.sh -o hwcheck-site.sh
git clone -q https://github.com/VoltageGPU/hwcheck
sha256sum hwcheck-site.sh hwcheck/hwcheck.sh
git -C hwcheck log --format='%h %ad %s' --date=iso-strict -- hwcheck.sh

a8120ccf8b1a33034ed836cbbd6ed5c55b901bafbfce8321c07c769d8053feeb  hwcheck-site.sh
a8120ccf8b1a33034ed836cbbd6ed5c55b901bafbfce8321c07c769d8053feeb  hwcheck/hwcheck.sh
9378d1a 2026-10-16T08:43:58+02:00 hwcheck 1.0: check a rented GPU machine against its listing

The file the site serves today is byte for byte the one on GitHub. The repository has a single version of the script, committed on 16 October, the day before the H100 run. The two test runs we published that morning print the first 16 hex characters of the script's hash, and they match: a8120ccf8b1a3303 (rtx3060ti-match.txt).

What this cannot show is which file the site served on 17 October. Git dates are also declared by whoever commits. They are a record, not a proof.

Step 3: compare a published file with the repository copy

The 16 October runs are also in the repository's examples/ folder. Take the RTX 4090 run:

curl -sSf https://voltagegpu.com/hwcheck-proofs/2026-10-16/rtx-4090.txt | sha256sum
sha256sum hwcheck/examples/rtx-4090.txt
git -C hwcheck log --format='%h %ad %s' --date=iso-strict -- examples/rtx-4090.txt

2884bfeed0f5e18dbd39a75d3ae586e522eba367f023901a74e03f248d0f9408  -
2884bfeed0f5e18dbd39a75d3ae586e522eba367f023901a74e03f248d0f9408  hwcheck/examples/rtx-4090.txt
fa2e458 2026-10-16T17:03:06+02:00 docs: four real runs on rented RTX 4090, RTX 5090, H200 and B300 machines, all matching

The two copies are identical. The repository copy was committed at 15:03 UTC, ten minutes after the run's timestamp (14:53 UTC). If we edited the site copy later, it would stop matching. Both copies still come from us, so this is not independent evidence. The 17 October runs, the H100 included, exist only on the site.

Step 4: see which lines were actually compared

Not every row in the output is a check. The script shows which ones are:

grep -n -E 'row "(VRAM per GPU|Driver / CUDA|CUDA compute)"' hwcheck-site.sh

71:    if at_least "$VRAM_GB" "$VRAM" 0.93; then row "VRAM per GPU" "$VRAM GB" "$VRAM_GB GB" "OK"
72:    else row "VRAM per GPU" "$VRAM GB" "$VRAM_GB GB" "DOES NOT MATCH"; fail "VRAM"; fi
73:  else row "VRAM per GPU" "-" "$VRAM_GB GB" "info"; fi
75:  row "Driver / CUDA" "" "${DRIVER:-?} / ${CUDA:-?}" "OK"
97:  if [ "$OKGPUS" -ge "$COUNT" ]; then row "CUDA compute" "" "matmul on $OKGPUS/$COUNT GPU" "OK"
98:  else row "CUDA compute" "" "matmul on $OKGPUS/$COUNT GPU" "DOES NOT MATCH"; fail "CUDA compute"; fi
100:  row "CUDA compute" "" "not tested (no PyTorch)" "info"

Read against the H100 run:

• GPU model: compared. The rule is in step 5.
• GPU count: compared. The machine must show at least the listed number.
• VRAM per GPU: compared only when --vram is passed (line 71). The H100 run did not pass it, so "80 GB" is information (line 73).
• Driver / CUDA: always OK once nvidia-smi answers (line 75). It is information, not a check.
• CUDA compute: a 2048 by 2048 matrix product on each GPU, when the image has PyTorch. "matmul on 1/1 GPU" means it ran on the one GPU.
• CPU, RAM, disk: information, unless --ram or --disk is passed. Neither was.
• No download line: --no-net skips the speed test.

So in this run, three things were checked against the listing: the model name, the GPU count, and that CUDA work runs on every GPU.

Step 5: replay the model rule

The model check is two small shell functions. Extract them and feed them names:

sed -n '/^norm()/p; /^model_matches()/,/^}/p' hwcheck-site.sh > match.sh
. ./match.sh
for pair in "H100|NVIDIA H100 80GB HBM3" "RTX 4090|NVIDIA GeForce RTX 3060 Ti" \
            "H100|NVIDIA H100 PCIe" "H100 80GB HBM3|NVIDIA H100 PCIe"; do
  listed=${pair%%|*}; measured=${pair#*|}
  if model_matches "$listed" "$measured"; then r=OK; else r="DOES NOT MATCH"; fi
  printf '%-16s vs %-28s %s\n' "$listed" "$measured" "$r"
done

H100             vs NVIDIA H100 80GB HBM3        OK
RTX 4090         vs NVIDIA GeForce RTX 3060 Ti   DOES NOT MATCH
H100             vs NVIDIA H100 PCIe             OK
H100 80GB HBM3   vs NVIDIA H100 PCIe             DOES NOT MATCH

Every word of the listed name that contains a digit must appear in the name the driver reports. The first line is the published H100 run: it follows from the rule. The second is the case the tool exists for: a cheaper card under a bigger name. The last two show the rule's reach. "H100" alone also accepts a card whose driver reports "NVIDIA H100 PCIe", a different board. Passing the full name, "H100 80GB HBM3", rejects it.

Step 6: run it on your own machine

This needs a Linux machine with an NVIDIA GPU. Ours is a workstation with an RTX 3060 Ti, under WSL2, without PyTorch. First the true listing, then a false one:

curl -fsSL https://voltagegpu.com/hwcheck.sh | bash -s -- --gpu "RTX 3060 Ti" --gpus 1 --vram 8 --no-net; echo "exit code: $?"
curl -fsSL https://voltagegpu.com/hwcheck.sh | bash -s -- --gpu "RTX 4090" --gpus 1 --vram 24 --no-net; echo "exit code: $?"

VoltageGPU hardware check (read-only, nothing about this machine is sent anywhere)
  2026-10-20 13:13 UTC · <hostname>

                 LISTED                   MEASURED                           
  GPU model      RTX 3060 Ti              NVIDIA GeForce RTX 3060 Ti         OK
  GPU count      1                        1                                  OK
  VRAM per GPU   8 GB                     8 GB                               OK
  Driver / CUDA                           610.88 / ?                         OK
  CUDA compute                            not tested (no PyTorch)            info
  CPU                                     12 threads                         info
  RAM            -                        16 GB                              info
  Disk (/)       -                        1007 GB, 936 GB free               info

RESULT: MATCHES THE LISTING
exit code: 0
VoltageGPU hardware check (read-only, nothing about this machine is sent anywhere)
  2026-10-20 13:13 UTC · <hostname>

                 LISTED                   MEASURED                           
  GPU model      RTX 4090                 NVIDIA GeForce RTX 3060 Ti         DOES NOT MATCH
  GPU count      1                        1                                  OK
  VRAM per GPU   24 GB                    8 GB                               DOES NOT MATCH
  Driver / CUDA                           610.88 / ?                         OK
  CUDA compute                            not tested (no PyTorch)            info
  CPU                                     12 threads                         info
  RAM            -                        16 GB                              info
  Disk (/)       -                        1007 GB, 936 GB free               info

RESULT: DOES NOT MATCH THE LISTING (GPU model, VRAM)
Release the pod from your dashboard and write to contact@voltagegpu.com with this output.
exit code: 2

These match the two workstation files we published on 16 October (match, mismatch). Only the date and the free disk space differ. Note the "Driver / CUDA" row. The CUDA version shows as "?" because this driver's nvidia-smi labels it "CUDA UMD Version: 13.3", and the script looks for "CUDA Version:". The row still says OK, as line 75 predicts. Because the exit code is 0 or 2, you can put the command at the top of a startup script and stop as soon as a machine is wrong.

What this proves, and what it does not

Proved from the public files:

• The script on the site is byte for byte the only version in the public repository, which was committed before the H100 run.
• The published H100 result follows from that script's rules and the printed values. The driver name contains "H100", one GPU is visible, and a CUDA matrix product ran on it.
• The tool says DOES NOT MATCH, and exits 2, when a card is listed under a bigger name. You can see that on your own machine.

Not proved:

• That the published file is the unedited output of a real run. It is plain text, not signed. For that you trust us. The 16 October runs have a second copy in git; the H100 file does not.
• Which script ran on 17 October. You can only check that today's site copy equals the public one.
• Anything a host determined to cheat would hide. hwcheck reads what the driver reports, and whoever controls the machine can change that. Proof against the operator needs hardware attestation: a confidential VM where NVIDIA's service signs the GPU's evidence.
• VRAM, RAM and disk in the H100 run. They were printed, not compared.
• Which H100 board it was. The rule accepts any name containing "h100". The printed name, "NVIDIA H100 80GB HBM3", is the only clue.
• Anything about another machine, or this one later. It is one machine at one moment, and the run used a direct rental, not a customer account.
• Confidentiality. Standard machines have no enclave.

The run that counts is yours: rent the machine, pass every value from its listing (--gpu, --gpus, --vram, --ram, --disk), and keep the output. The source is at github.com/VoltageGPU/hwcheck. If you need proof that does not rest on what the host's driver says, rent a Confidential VM with the quickstart and generate the attestation yourself, as in Verify a confidential GPU attestation offline.