one place for every number

Results.

Official lab benchmarks, reviewed community runs, and published model outputs — filtered in one table, each record with its workload coordinates, evidence, and trust state. Submissions stay private until a reviewer approves them.

XeCores reproduced rerun on controlled lab hardware Cross-confirmed a second independent system matches Automated community schema-reviewed runner record Pending received, private, not published

01 · benchmark records

Ranking-eligible results.

Official records load live from the public cookbook catalog. Community records come from the reviewed API queue. Records without complete workload coordinates stay outside the ranking as capabilities.

Loading catalog…

Loading the public benchmark catalog…

Reviewed community runs

Loading…

Loading approved community results…

Pending submissions never appear here.

02 · model outputs

What these models actually wrote.

Reviewer-approved prompt and response pairs from Intel Arc hardware — code completions, reasoning, instruction following. Each record carries the exact model revision, quantization, and engine that produced it. Submitted code is rendered as text and never executed.

Loading…

Loading approved model outputs…

03 · contribute

Two ways in. Both start private.

Benchmarks come from the official runner with machine-recorded numbers. Model outputs are opt-in artifacts: prompt, response, and how it was tested. Nothing you send is public until review.

A · Benchmark run (official runner)

Requirements: Python 3.10+ and a local OpenAI-compatible endpoint. The runner measures vLLM, SGLang, or llama.cpp servers at C1, C2, C4, C8, C16, and C32 with streaming SSE and saves xecores-results.json locally first.

curl -fsSLo xecores-runner.py https://xecores.com/xecores-runner.py
python3 xecores-runner.py \
  --engine vllm \
  --endpoint http://127.0.0.1:8000/v1 \
  --model Qwen3-32B-AutoRound-INT4 \
  --quantization autoround-int4 \
  --dtype int4 \
  --concurrency c1,c2,c4,c8,c16,c32

B · Model output (browser form)

Send one prompt and the exact response a model produced on your Intel GPU. You preview the public projection before anything leaves your browser, and approval is manual.

04 · methodology

Why these numbers are comparable.

The measurement rules behind every record on this page. No naked tok/s without hardware coordinates.

Rule 01CLAIM-SIZED TESTING LANES

The Four Protocol Lanes n=5 Median

Lane 1 Model Card: 5 anchor cells, n=5 samples, median ± range

Lane 0 smoke check, Lane 1 five-cell model card (p512/g128, p8192/g128, cold input anchors), Lane 2 speculation screens, Lane 3 full context and concurrency characterization.

Rule 02ANTI-CACHE GUARDRAIL

Anti-Cache Inflation Zero Delta

≥64 chars unique prompt entropy mandatory on cold runs

Shared prompt templates let prefix caching accelerate repetitions 5×. Cold runs inject entropy and require prefix_cache_hits delta of zero.

Rule 03METRIC HYGIENE

C1 Latency vs Cn Concurrency Monotonic Timing

Cold input rate = actual prompt tokens / client TTFT

C1 isolates single-user latency. Cn is total tokens over wall time. Per-request rates are never summed into aggregate throughput.

Rule 04POWER TELEMETRY

Configured Cap ≠ Physical Draw Energy Integrals

MoE 35B self-limits to ~140 W · 150 W cap saves 80 W of heat

Hardware energy-counter deltas over steady state. MoE sweet spot 150 W, dense 180 W. Cooldown to ≤55 °C before matched A/B sweeps.

Intel issues this page answers directly

"My two-GPU tensor-parallel run dies in oneCCL"

The xe driver rejects per-message IPC exchange on hosts without P2P. The validated fix is spawn-time worker affinity plus oneCCL simple-threshold variables.

Fix walkthrough ↗

"Benchmark numbers look inflated"

Prefix caching repeats a 5× illusion. Check the zero-delta rule and cold anchors — every record here lists its cache policy and sample count.

Rules on this page ↓

"Full power cap gives no benefit"

Sparse MoE decode reads ~3 GB of experts per token. A 150 W cap matches 230 W throughput with 80 W less heat.

Measurements ↗

"Which quantization keeps quality?"

AutoRound INT4 beat GPTQ conversationally on Qwen3.6; GPTQ stacks MoE errors. Measured per-model, on the table above.

Quality data ↗

"Can I trust a random tok/s claim?"

Compare coordinates: P/G/C, samples, engine version, driver. Missing coordinates are why capabilities render outside the rankings.

See evidence per record ↓

"I want to help with real workloads"

Run the official client or send a model output above. Schema-reviewed community runs join the tables after review.

Submit ↓
API contract (v1)

Benchmark records

GET /api/v1/challenge (runner UA only) · POST /api/v1/results one concurrency profile, 256 KiB cap, HTTP 202 pending · GET /api/v1/results approved projections only, filter by engine, GPU, model, concurrency. Schema: result.schema.json.

Model outputs

POST /api/v1/model-outputs/challenge browser-issued one-time token · POST /api/v1/model-outputs consented artifact, 128 KiB cap, HTTP 202 pending · GET /api/v1/model-outputs approved records, filter by category and model. Schema: model-output.schema.json.

Security: one-time challenges bound to a hashed client ID, replay blocked, exact-content idempotency, secret-pattern rejection, executable markup rejected, private pending storage, server-owned review state. Never put inference keys in payloads.