LotofBench

The open-source CPU benchmark with a public, integrity-checked results board.

Sixteen everyday workloads — compression, routing, web rendering, photo pipelines, compiling, machine learning, ray tracing — measured single-core and multi-core, scored against a fixed, published calibration, and checked for integrity before anything appears on the board.

Download from GitHub Browse results

Open source (MIT) · Zero dependencies · Builds with one command · A full run takes minutes

Three steps, a few minutes

  1. Build or download.

    Grab a release binary (Linux amd64 / arm64) or build from source: one command, no external libraries, any C11 compiler on Linux, macOS or BSD.

  2. Run.

    ./lotofbench runs all 16 workloads, single-core and multi-core, and prints a readable report plus machine-readable JSON.

  3. Publish — or not.

    By default the binary uploads your result to this site, where it passes an automated integrity check before publication. Add --no-upload to keep the run entirely offline.

What it measures

The 16 workloads mirror the structure of Geekbench 6's CPU suite: recognizable, everyday jobs, each reporting an honest throughput — pages per second, megapixels per second, rays per second. Every output is verified inside the timed run; a broken pipeline aborts instead of scoring.

Integer section

File Compression

IntegerMB/s

Compress and decompress a 100 MB corpus with LZ4 at two effort levels, verifying every byte with SHA-1.

Navigation

IntegerMedge/s

Plan 64 routes with Dijkstra's algorithm over a ~1.26-million-edge synthetic road grid, re-checking every route before it counts.

HTML5 Browser

Integerpages/s

Parse, lay out and render 32 synthetic web pages into an 800×600 framebuffer with a from-scratch tokenizer, layout engine and rasterizer.

PDF Render

IntegerMpixel/s

Rasterize four vector park-map PDFs at 144 dpi with anti-aliased fills, strokes, dashes and clipping.

Photo Library

Integerimg/s

Import 16 photos through a thumbnail ladder, a fixed auto-tagging pass and an in-memory record store.

Clang

IntegerKtokens/s

Lex, parse and compile 32 synthetic source files (about 986,000 tokens) to bytecode with a from-scratch compiler.

Text Processing

IntegerMB/s

Scan 32 Markdown documents with 8 regex patterns each and convert every document to HTML.

Asset Compression

IntegerMB/s

Push 16 game assets — opaque and alpha textures, meshes — through BC1/BC3 block codecs and a geometry codec.

Floating-point section

Object Detection

Floating-Pointimg/s

Run a fixed int8 MobileNetV1-shaped network with an SSD-lite head over photos — 316,225,344 multiply-accumulates per photo, counted exactly.

Background Blur

Floating-Pointfps

Segment a planted subject in 1080p video frames and blur the background — the video-call effect — in a 100% integer pipeline.

Object Remover

Floating-PointMpixel/s

Erase a masked object from photos with push-pull pyramid inpainting (content-aware fill) that never reads the hidden pixels.

Horizon Detection

Floating-PointMpixel/s

Find the horizon line in photos through the full Canny edge chain — then a 0.25°-bin Hough transform.

Photo Filter

Floating-PointMpixel/s

Run a five-stage stack — saturation, levels, blur, crop, rescale — over photos, bit-identically on every machine.

HDR

Floating-PointMpixel/s

Fuse a six-exposure bracket into one well-exposed image with Mertens-style exposure fusion.

Ray Tracer

Floating-PointMray/s

Render a synthetic showroom with a Whitted tracer over a BVH: Phong shading, shadow rays, mirror reflections.

Structure from Motion

Floating-Pointpairs/s

Reconstruct 3D camera poses and points from stereo image pairs: FAST corners, RANSAC, triangulation.

Scores you can audit

  • One formula, no magic. Every workload score is throughput ÷ baseline × 1000 against a published baseline; a machine hitting the baseline exactly scores 1000.
  • Two sections, one composite. Integer and Floating-Point section scores are the geometric means of their member workloads; the composite weighs Integer 65% and Floating-Point 35%.
  • Median of five runs. Each workload result is the median over five timed runs — not one lucky pass.
  • Verified, not trusted. Seeded synthetic inputs are byte-identical on every machine; outputs are checked against prepared references — digests, exact counters, planted answers — inside the timed run.

A default run on a 12-thread development machine:
594 single-core composite · 2,973 multi-core composite

Every per-workload score ships alongside. See the methodology for the full baseline table and worked examples.

A board you can check

The board publishes aggregates, not cherry-picked runs: average ± standard deviation over n verified results, sorted by average multi-core score. Every aggregate is one row — per cloud instance type for official runs, per CPU model for community runs.

  • Official — run by Cloud Mercato's internal fleet with the same public binary: latest-generation instances from AWS, Google Cloud, Azure, Oracle Cloud and Alibaba Cloud, aggregated per instance type.
  • Community — anonymous uploads from ./lotofbench, aggregated per CPU model.

Badges: every row carries a build badge (Official / Community) and an environment badge (Bare metal / VM / Container) detected at bench time.

Read the full rules →

Add your machine in three minutes

git clone https://github.com/cloudmercato/lotofbench
cd lotofbench
make
./lotofbench              # runs the suite and uploads by default
./lotofbench --no-upload  # stay offline

Release binaries skip the build — they upload by default too. A from-source build without libcurl stays offline and tells you so.

What gets published: your scores, CPU model, core count, RAM, OS, architecture — and whether the binary detected bare metal, a VM or a container.

What never leaves your machine: your hostname and your files. Submitter IP addresses are stored only as salted hashes, for abuse control.

Anonymous results are welcome. Every submission passes an automated integrity check — full score recomputation, pinned work counts, credible-throughput bounds, minimum runtime — before it appears on the board. Submissions that fail are never published.

LotofBench is not affiliated with Primate Labs. LotofBench follows the structure of Geekbench 6 but uses its own calibration: LotofBench scores are not comparable with Geekbench scores.