Evidence · published records
Every number has a run behind it.
A performance figure appears on this site only with the machine that produced it, the load around the run, the exact binary and a checksum that had to agree. The record is public. The engine is not.
Run 11 November 2026, 19:55 UTC on an 11th Gen Intel(R) Core(TM) i3-1115G4 @ 3.00GHz.
The published run.
This is the reference result for the open hardware challenge, recorded end to end rather than transcribed from a terminal.
| Record | 20261111T195524Z-laptop-irk4s2rh |
|---|---|
| Run at | 11 November 2026, 19:55 UTC |
| Machine | 11th Gen Intel(R) Core(TM) i3-1115G4 @ 3.00GHz · 4 logical lanes · 7.8 GiB RAM |
| Buffer | 79.91 MiB (83,794,903 bytes), xorshift32 fill |
| Load around the run | 48% CPU before, 47% after (Win32_Processor LoadPercentage average) |
| Binary | 482,304 bytes83e38afb41e8f36a9202e73dfa25c138f65ac17e364369ba08f5d5fa7b13b1ca |
| Result | RESULT: PASS · exit code 0 |
What a PASS requires.
A run is published only when all four conditions hold. A figure that fails any of them never reaches this page.
- 01
The process exits 0.A crash, a timeout or a partial run is not a result.
- 02
The binary prints
RESULT: PASS.The line is emitted by the run, not added to the record afterwards. - 03
The invariant reads MATCH.Scalar and SIMD checksums must agree before any timing is read out.
- 04
All three checksums equal -7571.Scalar, single-thread and all-core must land on the same value.
The record writer refuses to publish a run that misses any condition: --publish exits instead of writing a number.
The kernel, measured.
Separate from the hardware challenge: this is the kernel verification build on the real 3.66 GiB packed file — its dot-product path against an independent scalar reference, and a full-file pass over every byte.
| Machine | AVX2 | Scalar | Warm single | Warm peak | GB/s by threads |
|---|---|---|---|---|---|
| Owner laptop 11th Gen Intel(R) Core(TM) i3-1115G4 @ 3.00GHz · 4 logical CPUs |
0.04 ns | 3.09 ns · 82× | 3.26 GB/s | 4.23 GB/s on 4 | 1→3.26 · 2→1.65 · 4→4.23 |
| AWS m6i.2xlarge Intel(R) Xeon(R) Platinum 8375C CPU @ 2.90GHz · 8 logical CPUs |
0.04 ns | 0.55 ns · 14× | 5.50 GB/s | 25.71 GB/s on 8 | 1→5.50 · 2→10.99 · 4→19.26 · 8→25.71 |
Laptop record · AWS record. The laptop's 2-thread point measured below its 1-thread point and is reported as recorded rather than dropped; the peak column is what each record carries.
| Record | 20261111T100054Z-m6i-8vcpu |
|---|---|
| Measured | 11 November 2026, 10:00 UTC |
| Binary | 7095c1876b7eabdab57f2f474aab215fe5f7818e8e8c7d9dafdd6e5314727367 |
| By file size | 3660 MB → 0.04 ns/weight |
| Licence | Full-file verification build; the shipped Windows artifact is licence-gated separately. |
| Full-file pass | 3.66 GiB, every byte: 5.50 GB/s warm on one thread, 25.71 GB/s on 8, cold first pass 4.45 GB/s (disk-bound) |
| Checksum | 8,730,749 reproduced over 3,926,621,056 bytes |
| Agreement | Reference, scalar and SIMD agreed on 23 lengths from 0 to 65,537 weights, and on 16 unaligned offsets. |
A score is a dot product over packed weights, not inference. No norm, residual or layer order is involved, which is what makes it checkable against a reference. Full-file throughput is measured after the cold first pass, so it describes page-cache reads rather than the disk; repeat runs on this m6i ranged from 25.71 to 27.73 GB/s as the cache changed. The laptop ran the licensed Windows binary, the m6i the Linux full-file build: two machines, one kernel, the same 8,730,749 checksum.
End to end, on the same machine.
The kernel scan measures a memory ceiling. This measures what a standard engine actually sustains while generating tokens on the same kind of machine, stated as a fraction of that ceiling.
| Machine | 11th Gen Intel(R) Core(TM) i3-1115G4 @ 3.00GHz · 4 logical CPUs |
|---|---|
| Engine | llama.cpp · cd959bae9 |
| Model | qwen2.5-3b-instruct-q4_k_m.gguf · 9c9f56a391a3abbd… |
| Measured | 512 prompt tokens, 128 generated, 3 rounds, 4 threads |
| Prefill | 34.9 tokens/s |
| Bytes per token | 1.93 GB — a dense model reads every weight once per token |
| Ceiling | 23.00 GB/s from 20261111T195524Z-laptop-irk4s2rh |
| Record | record 20261112T192745Z-inference |
Measured with llama.cpp, not the Damnit kernel. The kernel scores tensors and has no layer graph, so this is what the machine sustains against its measured memory ceiling — not proof that our kernel produces these tokens. The decode figure includes KV-cache attention, RoPE, softmax and dequantization; the 23.00 GB/s scan includes none of them.
Software checks.
The engine ships with the suite that gates it. These are the counts from the last recorded run, 13 November 2026.
1,612 tests
Pass with exit 0 across 152 test files.
1,491,284 lines
Of source under those tests, across 2,435 files.
Licence path tested
Signed keys, seat limits, expiry, revocation and a remote control plane that fails closed.
What stays private.
The evidence is public because it can be checked without the recipe. The recipe stays with the company.
- Source trees and headers.Never shipped, never published, never in a client download.
- The quantization model and weight format.Held offline; not part of any licence.
- Internal invariants and memory budgets.Described in public only in terms of their effect.
- Any number without a record.If it cannot be reproduced from a published run, it is not claimed.
The challenge CLI is a standalone memory-bandwidth workload. It contains no model weights and no kernel source, so downloading it discloses nothing about how the engine is built. Source evaluation is available under a mutual NDA.
Reproduce it, or refute it.
7.89 GB/s is one laptop with 4 lanes, not a ceiling. The same kernel also ran full-file on an AWS m6i.2xlarge at 25.71 GB/s on 8 vCPU. Run the same CLI on your own hardware and compare.
Download the challenge CLI How the comparison works
Your run is yours: the CLI prints its own topology, throughput and checksum. Nothing is uploaded.