Methodology
Everything that produces a LotofBench number is documented here: what the 16 workloads do, how throughputs become scores, how the composite is built, and what happens between a submission and its publication on the board.
1. Design principles
Three rules govern every workload:
- Identical work on every machine. All inputs are synthetic and generated from a fixed seed (
--seed, default 1): the compression corpus, the road network, the web pages, the photos, the meshes are byte-identical everywhere. Work amounts are deterministic — for example, Navigation always relaxes exactly 52,954,982 edges per pass on the default seed. Inputs are generated off the clock. - Every answer is checked. The suite verifies results against references prepared before the run — SHA-1 digests of rendered frames and encoded streams, exact counters (rays, MACs, pixels), and planted ground truths (the object to detect, the horizon to find, the pose to recover). Any drift aborts the run instead of scoring.
- Reproducible timing. Every workload is timed as a whole with a monotonic clock, and each result is the median over 5 runs (default
--runs 5). The full suite — 16 workloads × 5 runs × single-core and multi-core passes — takes minutes; the site rejects results claiming less.
2. From throughput to score
Each workload measures a throughput in its own unit (pages/s, Mpixel/s, Mray/s…), and the score is a fixed-ratio rescaling:
score = round(throughput / baseline × 1000)
Rounding is half-up. Each baseline is a LotofBench calibration constant (see §5): a machine performing exactly at baseline scores 1000 on that workload.
Worked example (single-core Photo Library, from the reference sample run): throughput 196.2 img/s against a 200.0 img/s baseline → 196.2 / 200.0 × 1000 = 981.
3. Sections and the composite score
The 16 workloads are grouped into two sections:
- Integer (65%) — File Compression, Navigation, HTML5 Browser, PDF Render, Photo Library, Clang, Text Processing, Asset Compression.
- Floating-Point (35%) — Object Detection, Background Blur, Object Remover, Horizon Detection, Photo Filter, HDR, Ray Tracer, Structure from Motion.
Each section score is the geometric mean of its member workloads' scores, rounded half up. The composite is the weighted arithmetic mean of the two sections:
composite = round(0.65 × Integer + 0.35 × Floating-Point)
Single-core and multi-core composites are computed the same way from their own per-workload scores. A machine scoring exactly 1000 on every workload scores 1000 on both sections and on the composite. Because the section means are geometric, a workload scoring 0 (a dead pipeline, which in fact aborts the run) would zero its section rather than drag the mean down slowly.
Worked example (from the published sample run on a 12-thread development machine):
- Single core: Integer section 534, Floating-Point section 704 → 0.65 × 534 + 0.35 × 704 = 593.5 → 594.
- Multi-core (12 threads): Integer 2634, Floating-Point 3603 → 0.65 × 2634 + 0.35 × 3603 = 2973.15 → 2973.
4. The multi-core model
Threads cooperate on one shared task instead of running independent copies: each workload's task set is split into equal contiguous slices, one per thread (several workloads run 4× the task in the multi-core pass — e.g. 16 PDF documents instead of 4, 48 stereo pairs instead of 12). Threads synchronize through a start gate — the clock starts when every thread is ready and stops when the last one finishes — so elapsed time always measures the whole task.
- Default thread count: every online CPU (capped at 64); override with
--threads. - Single-core is always one thread over the whole task.
5. Baselines — the 16 calibration constants
Baselines are LotofBench's own calibration, fixed when each workload landed and published here. They are not Geekbench numbers. A workload performed exactly at its baseline scores 1000. The two score columns are the published sample run — a default run (seed 1, 5 runs) on a 12-thread development machine — shown for illustration only.
| # | Workload | Section | Metric | Baseline (= 1000 points) | Sample single | Sample multi |
|---|---|---|---|---|---|---|
| 1 | File Compression | Integer | Compression throughput (MB/s) | 250.0 MB/s | 429 | 2373 |
| 2 | Navigation | Integer | Edge relaxations (Medge/s) | 100.0 Medge/s | 431 | 2286 |
| 3 | HTML5 Browser | Integer | Pages rendered (pages/s) | 650.0 pages/s | 458 | 2750 |
| 4 | PDF Render | Integer | Device pixels rasterized (Mpixel/s) | 10.0 Mpixel/s | 313 | 1399 |
| 5 | Photo Library | Integer | Photos ingested (img/s) | 200.0 img/s | 981 | 4384 |
| 6 | Clang | Integer | Source tokens compiled (Ktokens/s) | 8500.0 Ktokens/s | 570 | 2800 |
| 7 | Text Processing | Integer | Text bytes processed (MB/s) | 200.0 MB/s | 484 | 2178 |
| 8 | Asset Compression | Integer | Asset bytes through codecs (MB/s) | 50.0 MB/s | 916 | 4149 |
| 9 | Object Detection | Floating-Point | Photos through the network (img/s) | 25.0 img/s | 811 | 3939 |
| 10 | Background Blur | Floating-Point | Frames blurred (fps) | 50.0 fps | 313 | 1802 |
| 11 | Object Remover | Floating-Point | Filled output pixels (Mpixel/s) | 30.0 Mpixel/s | 1131 | 5419 |
| 12 | Horizon Detection | Floating-Point | Input pixels detected (Mpixel/s) | 50.0 Mpixel/s | 979 | 5450 |
| 13 | Photo Filter | Floating-Point | Output pixels filtered (Mpixel/s) | 50.0 Mpixel/s | 565 | 3088 |
| 14 | HDR | Floating-Point | Fused output pixels (Mpixel/s) | 6.0 Mpixel/s | 978 | 4403 |
| 15 | Ray Tracer | Floating-Point | Rays traced (Mray/s) | 5.0 Mray/s | 1039 | 5466 |
| 16 | Structure from Motion | Floating-Point | Stereo pairs reconstructed (pairs/s) | 100.0 pairs/s | 372 | 1821 |
Sections from the same sample run: Integer 534 / 2634, Floating-Point 704 / 3603 (single / multi). Composites: 594 single-core, 2973 multi-core.
What each baseline represents — the reference pace behind 1000 points
- File Compression — 250.0 MB/s: the full compress + decompress + verify cycle at two LZ4 effort levels, decimal MB/s (1 MB = 1,000,000 bytes).
- Navigation — 100.0 Medge/s: the reference machine relaxes one graph edge per nanosecond.
- HTML5 Browser — 650.0 pages/s: a full page (parse + layout + raster of an 800×600 viewport) in about 1.5 ms.
- PDF Render — 10.0 Mpixel/s: a 1224×1584 map page — parse included — in roughly a fifth of a second.
- Photo Library — 200.0 img/s: a 1280×960 photo — thumbnail ladder, classifier, auto-tag, record store — in about 5 ms.
- Clang — 8500.0 Ktokens/s: about 8.5 million source tokens per second through lex, parse, code generation and verify.
- Text Processing — 200.0 MB/s: about 200 million text bytes per second (each document counts once for the Markdown→HTML conversion and once per pattern for the 8 regex scans).
- Asset Compression — 50.0 MB/s: the 16-asset set through the BC1/BC3 texture codecs and the geometry codec in about 93 ms single-core.
- Object Detection — 25.0 img/s: one 300×300 photo through the 12-convolution int8 network (316,225,344 exact MACs) in about 40 ms.
- Background Blur — 50.0 fps: one 1920×1080 frame — segmentation, blur, composite — in 20 ms.
- Object Remover — 30.0 Mpixel/s: one 1600×1200 inpainting pass in about 64 ms.
- Horizon Detection — 50.0 Mpixel/s: the full grayscale → Gaussian → Sobel → NMS → hysteresis → Hough chain over a 1600×1200 photo in about 38 ms.
- Photo Filter — 50.0 Mpixel/s: the five-stage stack over a 1600×1200 photo in about 45 ms.
- HDR — 6.0 Mpixel/s: the four-scene, six-exposure fusion in about 1.28 s single-core.
- Ray Tracer — 5.0 Mray/s: the 8-view showroom pass through the BVH in about 1.1 s single-core.
- Structure from Motion — 100.0 pairs/s: the 12-pair reconstruction set in about 120 ms single-core.
6. How the board aggregates results
The board does not display raw submissions. It displays one aggregate row per identity:
- Official rows — one per cloud instance type. These runs are performed by Cloud Mercato's internal fleet with the public binary (the fleet pipeline runs the suite offline and streams results through the internal path — CLI uploads never produce official rows).
- Community rows — one per CPU model. These come from anonymous
./lotofbenchuploads, with identical CPU models resolved to the same entry.
Each aggregate holds the sample count, average, standard deviation, minimum, maximum and latest date per score side (single-core and multi-core). Charts sort on average multi-core score. A single-sample aggregate shows n=1 and no spread.
Every row carries:
- a build badge — Official or Community;
- an environment badge — Bare metal, VM or Container — detected by the binary at bench time (container heuristics, then hypervisor/DMI probes; a wrong badge is cosmetic and never affects a score);
- the system profile: CPU model, cores, RAM, OS, architecture.
7. Integrity checks before publication
Nothing reaches the board untouched. Every community submission passes an automated pipeline; failures are rejected, logged for audit, and never published.
- Signed session + proof-of-work. Each upload starts with a signed session handshake and a lightweight proof-of-work; one result per session; replayed or expired sessions are rejected.
- Full score recomputation. The server recomputes every per-workload score from the raw throughputs and baselines, then rebuilds both section scores and the composite. Any mismatch — even by one point — rejects the document.
- Pinned work amounts. On the default seed, deterministic work counts are pinned (e.g. Navigation's 52,954,982 edge relaxations, Clang's 986,328 tokens). A document claiming different work at the same seed is rejected.
- Credible-throughput ceilings. Throughputs beyond a generous multiple of the fastest known hardware are rejected.
- Runtime sanity. The suite takes minutes: results below the minimum runtime floor are rejected, and a claimed runtime must fit the observed session lifetime (a result cannot claim 600 s if it arrived 30 s after the handshake).
- Cross-checks. Multi-core results slower than single-core on plausible single-vCPU machines are flagged for review rather than silently dropped.
Results that pass publish automatically — there is no manual curation step, and no account required.
8. Privacy
- No hostnames are uploaded, ever.
- Submitter IP addresses are stored only as salted hashes, for abuse control.
- The published result contains scores, the system profile (CPU model, cores, RAM, OS, architecture) and the detected environment — nothing else.
9. What LotofBench is not
- Not comparable with Geekbench. Same structure, different calibration: the baselines above are LotofBench's own, and LotofBench scores must not be compared with Geekbench scores.
- Not a GPU benchmark. Geekbench 6 also runs GPU compute workloads; they are out of scope.
- Not an accuracy benchmark. The ML-shaped workloads (Object Detection, Background Blur, Object Remover, HDR) use fixed, documented compute pipelines as deterministic stand-ins — they measure throughput on exactly specified work, not model accuracy.
- Not a gaming or storage benchmark. 16 CPU workloads, single-core and multi-core, nothing else.
LotofBench is not affiliated with Primate Labs. LotofBench scores are not comparable with Geekbench scores. LotofBench is an open-source project by Cloud Mercato, released under the MIT license.
Source of truth: the workload list, scoring rules and calibration live in the repo — github.com/cloudmercato/lotofbench (docs/benchmarks.md). This page mirrors them; if they ever diverge, the repo wins. Last reviewed: 2026-11-16 (v1.0.0).