Submit a local AI benchmark

Benchmarking Qwen3.8-27B? Follow the text-first llama.cpp or Ollama workflow, then load the community GGUF or official FP8 starter below. On Apple silicon, use the Mac shared-memory guide and record the exact chip, total unified memory, macOS version, memory pressure and swap. Confirm the exact revision and loaded files; the starter fills no hardware, runtime, context, measured result, draft or submission.

Benchmarking Muse Glimmer 30B? Read the official 24GB-versus-32GB memory guide, then stage the matching 17GB Q4 or dynamic Q4 starter below. Confirm the exact revision and companion files; enter the actual hardware, runtime, context, modality, slots, offload, peak memory and measured result. The starter fills no hardware or outcome.

Reproducing a published Muse Spark Mac result? Read the 512GB M3 Ultra Q2_K and oQ3e evidence guide, then choose the matching starter below. Confirm the exact artifact revision and enter the actual Mac, runtime, prompt/output counts, memory pressure and measured value; the starter fills no hardware or result.

Benchmarking Muse Spark Open? Read the 533.011GB file-versus-700GB runtime guide, then stage the official NVFP4 starter below. Record exact revision, Blackwell hardware, device count, topology, tensor/expert parallelism, runtime build, modality, context, batch/concurrency and peak memory on every device. The starter fills no hardware or measured result.

Benchmarking Kimi K2.5? Read the 595.178GB capacity guide, then stage the official-checkpoint starter below. Record every device, topology, placement decision, offload path, modality, context, batch/concurrency and per-device peak; aggregate VRAM alone is not reproducible.

Prepare a benchmark record without stripping away the test conditions. The tool checks required fields in your browser, keeps the JSON export, and builds a copyable Reddit post for a user-initiated handoff to r/HighVRAMHardwareWatch. Nothing is uploaded or posted automatically. You can save an unfinished draft only in this browser and return later; HighVRAM does not receive that draft.

Benchmarking Intel Arc Pro B70? Read the 32GB model-fit and current-caveats guide, then load the exact configuration starter below. It stages hardware, capacity and correctness/version controls only; no measurement is filled or saved.

\n

Benchmarking Intel Arc Pro B60? Read the 24GB model-fit guide, then load the exact configuration starter below. It stages hardware, capacity and the Intel-stack checklist only; no measured field is filled or saved.

\n

Testing gpt-oss? Review the 20b GPU guide or 120b hardware guide, then load the matching workload starter below. Each stages only the model and format prompt; neither saves, submits or fills any measured value.

Benchmarking the RTX 4080 SUPER? Use the 16GB model-fit guide, then load the exact configuration starter below. It stages fields only and records no measured result.

Benchmarking RTX 4070 Ti SUPER? Use the 16GB model-fit guide, then load the exact configuration starter below. It stages fields only and records no measured result.

Benchmarking RTX 4070 SUPER? Use the 12GB model-fit guide, then load the exact configuration starter below. It stages fields only and records no measured result.

Benchmarking Intel Arc Pro B50 16GB? Read the model-fit and software guide, then load the exact configuration starter below. It stages hardware and topology fields only and records no measured result.

Benchmarking Intel Arc Pro B65 32GB? Read the model-fit, partner-board and host-memory guide, then load the exact configuration starter below. It stages fields only and records no measured result.

Submitting a Llama 4 result? Read the Scout and Maverick capacity guide, then load the exact official-artifact starter below. It stages only the model identity and precision; it does not select hardware, fill a measurement, save a draft or submit anything.

Submitting a GLM-4.7 result? Read the official checkpoint capacity guide, then load the matching starter below. It stages only repository identity and precision; it does not choose hardware, fill a result, save a draft or submit anything.

Submitting a DeepSeek-V3.2 result? Read the official checkpoint and multi-accelerator capacity guide, then load the standard or Speciale starter below. It stages only the exact repository identity and FP8 checkpoint prompt; it does not choose hardware, placement, offload, runtime, context, fill a measurement, save a draft or submit anything.

Submitting a MiniMax-M2.5 result? Read the official 230.134GB checkpoint guide, then load the exact starter below. It stages only repository identity and the native FP8 file-size prompt; it does not select hardware, topology, runtime, context, fill a measurement, save a draft or submit anything.

Submitting a controlled RTX 3060 8GB-versus-12GB pair? Use the RTX 3060 capacity controls, load each exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU and board, 128-bit or 192-bit interface identity, used condition, power limit, display use, exposed memory, peak use and CPU offload. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 3060 12GB against RTX 4060 8GB? Start with the cross-tier comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU/board, power limit, display use, exposed memory, peak use, CPU offload and complete-system power. Do not normalize a spilled or offloaded 8GB run against a resident 12GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 3060 12GB against RTX 5060 8GB? Start with the capacity-versus-Blackwell comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU/board, Blackwell support, power limit, display use, exposed memory, peak use, CPU offload and complete-system power. Do not normalize a spilled or offloaded 8GB run against a resident 12GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Acceptance rules

• The source must be public and attributable to the tester or project maintainer, or clearly labeled as a secondary transcription.
• Hardware, model artifact, precision, runtime, metric definition and value are required.
• For multi-device results, report interconnect, parallelism and per-device placement; aggregate capacity alone is insufficient.
• Report memory exposed per accelerator separately from measured peak accelerator use and from host, unified or system memory; disclose offload.
• For capacity-boundary results, record the value exposed to the runtime and reconcile any product-class difference (for example, B200 180GB or B300 288GB-class versus the 270GB HGX datasheet figure).
• For multimodal results, identify text, image, video or mixed input and preserve preprocessing details in the notes.
• Prompt length is not context capacity. Unknown fields remain null.
• Warm-ups and repetitions must be stated; one run is allowed but cannot imply variance or repeatability.
• Separate prompt processing, generation, time-to-first-token, combined throughput and memory observations.
• Results with materially different models, runtimes, contexts, concurrency or timing boundaries are not normalized into one ranking.
• HighVRAM may reject unverifiable, promotional, ambiguous or cherry-picked submissions.

Review states

Unreviewed records have only passed the browser’s minimum-field check. Source-checked records have been matched to the cited source. Reproduced is reserved for an independent rerun with a documented matching profile. These labels must never be inferred from one another.

Read the current benchmark database to see how source-specific definitions and unknowns are preserved.

Submitting a controlled Ampere comparison? Use the RTX A6000 vs A100 controls to keep the artifact, runtime, context, concurrency and timing boundary constant while recording exact PCIe/SXM, cooling, MIG and exposed-memory details.

Submitting an Ada-workstation versus Ampere-accelerator pair? Use the RTX 6000 Ada vs A100 controls while keeping artifact, runtime, context, concurrency and timing constant and recording cooling, MIG, topology and exposed memory.

Submitting a controlled server comparison? Use the L40S vs A100 controls to hold artifact, runtime, context, concurrency and timing constant while recording airflow, MIG/interconnect, exposed memory and peak use.

Submitting an Ada-server versus Hopper pair? Use the L40S vs H100 controls while holding artifact, runtime, context, concurrency and timing constant and recording airflow, MIG/interconnect, exposed memory and peak use.

Submitting a controlled Ampere server pair? Use the A40 vs A100 controls while holding artifact, runtime, context, concurrency and timing constant and recording airflow, power, MIG/NVLink, exposed memory and peak use.

Submitting a controlled passive-server versus active-workstation pair? Use the A40 vs RTX 6000 Ada controls while holding artifact, runtime, context, concurrency and timing constant and recording airflow, connector, NVLink, exposed memory and peak use.

Submitting a controlled 32GB-consumer versus 48GB-server pair? Use the RTX 5090 vs A40 controls while holding artifact, runtime, context, concurrency and timing constant and recording power, airflow, connector, NVLink, exposed memory and peak use.

Submitting a controlled desktop-GPU versus data-center-accelerator pair? Use the RTX 5090 vs A100 controls while holding artifact, runtime, context, concurrency and timing constant and recording the exact A100 capacity/form factor, MIG state, airflow, power, exposed memory and peak use. The existing RTX 5090 and A100 starters only stage the form; nothing is saved or submitted until you use the form controls.

Submitting a controlled desktop-GPU versus Hopper-accelerator pair? Use the RTX 5090 vs H100 controls while holding artifact, runtime, context, concurrency and timing constant and recording exact H100 variant/form factor, MIG state, airflow, power, topology, exposed memory and peak use. The existing RTX 5090, H100 80GB and H100 NVL 94GB starters only stage the form; nothing is saved or submitted until you use the form controls.

Submitting a controlled desktop-GPU versus 141GB Hopper pair? Use the RTX 5090 vs H200 controls while holding artifact, runtime, context, concurrency and timing constant and recording exact H200 SXM/NVL identity, MIG state, cooling, power, topology, exposed memory and peak use. The RTX 5090 and H200 starters only stage the form; nothing is saved or submitted until you use the form controls.

Testing RTX 3090 against RTX 4090 at the same 24GB capacity? Start with the Best 24GB GPU for local AI controls, load each existing hardware starter separately, and hold model revision, quantization, runtime/version, context, cache, prompt/output profile, concurrency and timing boundary constant. Record exact partner board, power limit, display use, exposed memory and peak use. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

Testing A100 80GB against H100 80GB? Start with the Best 80GB GPU for local AI controls, load the existing exact A100 80GB and H100 80GB starters separately, and hold model revision, quantization, runtime/version, context, cache, modality, prompt/output profile, concurrency and timing boundary constant. Record PCIe/SXM identity, directed cooling, power mode, MIG profile, topology, exposed memory and per-device peak. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

\n

Testing RTX 5090 against RTX 5000 Ada at the same 32GB capacity? Start with the Best 32GB GPU for local AI controls, load each exact hardware starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact board, driver mode, ECC state, power limit, display use, exposed memory and per-device peak. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 3060 against RTX 5070 at the same 12GB capacity? Start with the Best 12GB GPU for local AI controls, load each exact hardware starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU or partner board, power limit, display use, exposed memory, peak use and any CPU offload. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 4060 against RTX 5060 at the same 8GB capacity? Start with the Best 8GB GPU for local AI controls, load each exact hardware starter separately, and hold model revision, quantization, projector, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact partner board, power limit, display use, exposed memory, peak use and any CPU offload. Starters only stage hardware fields; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 5070 12GB against RTX 5060 Ti 16GB? Start with the cross-tier Blackwell comparison, load each exact hardware starter separately, and hold model revision, quantization, projector, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU, board, power limit, display use, exposed memory, per-device peak and any CPU offload. Starters stage hardware fields only; nothing is saved or submitted until you use the form controls.

\n

Testing RTX 5060 Ti 8GB against 16GB? Start with the same-family capacity comparison, load each exact starter separately, and hold model revision, quantization, projector, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU and board, power limit, display use, exposed memory, per-device peak and CPU offload. Starters fill hardware fields only; nothing is saved or submitted until you use the form controls.

\n

Testing RTX 4060 Ti 8GB against 16GB? Start with the same-family Ada capacity comparison, load each exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency and timing boundary constant. Record exact SKU and board, power limit, display use, exposed memory, per-device peak and CPU offload. Starters fill hardware fields only; nothing is saved or submitted until you use the form controls.

\n\n

Testing RTX 5080 16GB against RTX 5090 32GB? Start with the capacity-versus-throughput comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, power limit, clocks, display use, exposed memory, peak device memory, CPU offload, system RAM and wall power. Do not normalize an offloaded or spilled 16GB run against a resident 32GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

\n\n

Testing RTX 4090 24GB against RTX 5080 16GB? Start with the capacity-versus-generation comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, power limit, clocks, display use, exposed memory, peak device memory, CPU offload, system RAM and wall power. Do not normalize an offloaded or spilled 16GB run against a resident 24GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 4090 24GB against RTX 5090 32GB? Start with the 24GB-versus-32GB flagship comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, power limit, clocks, display use, exposed memory, peak device memory, CPU offload, system RAM and wall power. Do not normalize an offloaded or spilled 24GB run against a resident 32GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 3090 24GB against RTX 5090 32GB? Start with the used-Ampere-versus-current-Blackwell comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, used condition, power limit, clocks, display use, exposed memory, peak device memory, CPU offload, system RAM and wall power. Do not normalize an offloaded or spilled 24GB run against a resident 32GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Testing RTX 3090 24GB against RTX 5080 16GB? Start with the used-capacity-versus-Blackwell comparison controls, load each existing exact starter separately, and hold model revision, quantization, runtime/version, kernel path, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, used condition, power limit, clocks, display use, exposed memory, peak device memory, CPU offload, system RAM and wall power. Do not normalize an offloaded or spilled 16GB run against a resident 24GB run. Starters fill hardware fields only; nothing is saved or submitted until you explicitly use the form controls.

Benchmarking an RX 7900 XTX? Use the 24GB fit and compatibility guide, then load the exact starter above. Keep model file, context, backend, OS, driver, ROCm/runtime, unsupported operators, fallback and power settings explicit; the starter stages fields only and submits nothing.

Submitting a controlled RX 7900 XTX versus RTX 3090 pair? Start with the cross-platform comparison controls, load each existing exact starter separately, and hold artifact, quantization, context, cache, modality, prompt/output profile, batch, concurrency, timing and repetitions constant. Record exact board, OS, driver, backend, CUDA or ROCm/runtime version, unsupported operators, fallback, offload, exposed memory, peak use, power limit and wall power. Starters stage hardware fields only; nothing is saved or submitted until you act.

Submitting a controlled RX 7900 XTX versus RTX 4090 pair? Start with the cross-platform comparison controls, load each existing exact starter separately, and hold artifact, quantization, context, cache, modality, prompt/output profile, batch, concurrency, timing and repetitions constant. Record exact board, OS, driver, backend, CUDA or ROCm/runtime version, unsupported operators, fallback, offload, exposed memory, peak use, power limit and wall power. Starters stage hardware fields only; nothing is saved or submitted until you act.

Submitting a controlled RX 7900 XTX versus RTX 5090 pair? Start with the 24GB-versus-32GB cross-platform comparison controls, load each existing exact hardware starter separately, and hold model revision, artifact, quantization, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, OS, driver, backend, CUDA or ROCm/runtime version, unsupported operators, fallback, offload, exposed memory, peak use, power limit and wall power. Do not normalize an offloaded or spilled 24GB run against a resident 32GB run. Starters stage hardware fields only; nothing is saved or submitted until you act.

Submitting a controlled RX 7900 XTX versus RTX 5080 pair? Start with the 24GB-versus-16GB cross-platform comparison controls, load each existing exact hardware starter separately, and hold model revision, artifact, quantization, context, cache, modality, prompt/output profile, batch, concurrency, timing boundary and repetitions constant. Record exact board, OS, driver, backend, CUDA or ROCm/runtime version, unsupported operators, fallback, offload, exposed memory, peak use, power limit and wall power. Do not normalize an offloaded or spilled 16GB run against a resident 24GB run. Starters stage hardware fields only; nothing is saved or submitted until you act.

Submitting a controlled RX 7900 XTX versus RTX 4080 SUPER pair? Start with the 24GB-versus-16GB comparison controls, load each existing exact starter separately, and hold artifact, quantization, context, cache, modality, prompt/output profile, batch, concurrency, timing and repetitions constant. Record exact board, OS, driver, CUDA or ROCm/runtime, unsupported operators, fallback, offload, exposed and peak memory, power limit and wall power. Do not normalize an offloaded 16GB run against a resident 24GB run. Starters stage fields only; nothing is saved or submitted until you act.

Submitting a controlled RX 7900 XTX versus RTX 4070 Ti SUPER pair? Start with the 24GB-versus-16GB comparison controls, load each existing exact starter separately, and hold artifact, quantization, context, cache, modality, batch, concurrency, timing and repetitions constant. Record board, OS, driver, CUDA or ROCm/runtime, unsupported operators, fallback, offload, exposed and peak memory, power limit and wall power. Do not normalize an offloaded 16GB run against a resident 24GB run.

Comparing Arc Pro B65 and B70? Read the controlled-comparison guide, then load each exact starter separately. Hold model revision, quantization, context, cache, runtime/build, backend, flags, prompt/output, batch, concurrency and timing constant; record board, power, host RAM/swap, exposed and peak memory, fallback, wall power and output correctness. Starters stage fields only.

Comparing Arc Pro B50 and B60? Read the controlled-comparison guide, then load each exact starter separately. Hold artifact, quantization, context, cache, runtime/build, backend, flags, prompt/output, batch, concurrency and timing constant; record board, power, exposed/peak memory, fallback, wall power and correctness. Do not normalize an offloaded 16GB run against a resident 24GB run.

Comparing Arc Pro B60 and B65? Read the controlled-comparison guide, then load each exact starter separately. Hold artifact, quantization, context, cache, runtime/build, backend, flags, prompt/output, batch, concurrency and timing constant; record board, PCIe width, power, host RAM/swap, exposed/peak memory, fallback, wall power and correctness. Do not normalize an offloaded 24GB run against a resident 32GB run.

Comparing Arc Pro B60 with RTX 3090? Read the 24GB platform comparison, then load the existing Arc Pro B60 and RTX 3090 starters separately. Match software, model, placement, context, power and correctness; do not normalize results when fallback or offload differs.

Comparing Arc Pro B70 with RTX 5090? Read the 32GB platform comparison, then load the existing Arc Pro B70 and RTX 5090 starters separately. Match software, model, placement, context, power and correctness; do not normalize results when fallback or offload differs.

Comparing Arc Pro B60 with RTX 4090? Read the 24GB platform comparison, then load the existing Arc Pro B60 and RTX 4090 starters separately. Match software, model, placement, context, power and correctness; do not normalize results when fallback or offload differs.