love benchmarks — milliseconds per iteration

Lower is better. Each language self-times its inner loop (reps auto-scaled past a 200 ms floor, so startup is excluded). The fastest cell per bench is green; the love axis is tinted; a dot means no implementation (or an unavailable toolchain). The ranking row orders the columns by the metric you pick above — default the geometric mean of each language's per-bench times, so every bench counts in proportion and no single heavy one dominates (a language is fast at some things, slow at others; try harmonic or arithmetic and watch the order shift). Below it, shown but not ranked: bell (bignum — not every language has it) and setup (cold start: source → trivial result, so compiled languages pay their compile).

SAT solvers — milliseconds to solve

A separate field: love’s own CDCL solver (crew/sat/flat.l: flat cask-resident state driven by four native kernels — propagation, the whole conflict handler, the decision, and the fbva grow step — each assembled through crew/holo/ at solver-build time, specialized to the instance size) against reference C solvers. Two row families: PHP(n) — (n+1) pigeons into n holes, UNSAT and resolution-hard, where clause learning alone is exponential and love’s fbva factoring pass (extended resolution) earns its keep — and rndn, random 3-SAT at the threshold (m = 4.26n, five fixed-seed instances summed; the verdict column is the per-instance SAT/UNSAT signature, identical across every solver): raw search with no factorable structure, the guard against pigeonhole specialization — and REAL instances from SATLIB, the classic competition-era benchmark library (uf/uuf = uniform random at the transition, satisfiable and proven-UNSATISFIABLE sets; flat = graph 3-coloring), byte-identical files raced by every solver. love is timed by its own solve clock (interpreter warmup and the one-time kernel assembly excluded); the C solvers by process wall-clock (their startup is ~ms). timeout = exceeded the cutoff. The families pull opposite ways: the big inprocessing solvers (cadical, kissat) are built for structure but their machinery costs them the small random instances, where the light classics (picosat, minisat) lead — love runs ahead of cadical on PHP(5–7) and mid-field on the pure random rows; the threshold-SAT rows are a documented per-instance lottery (uf250 races a 14-instance panel to damp it). The net is the geometric mean over rows — the same key the language table uses — so no single row owns the column order.

compilers — milliseconds to build love, and to test it

A third field, love’s C toolchain against the incumbents: mooncc is love’s own C compiler (crew/moon/), and it builds love with no gcc, glibc, or ld — mooncc lays every object, mksys emits the syscall leaf, and our own linker (crew/holo/) binds the executable. The build row is the wall-clock to compile every C translation unit (love.c + host/*.c + the am math floor) and link a working binary; the test row runs the full corpus (the same files test_host/test_raw feed) through the binary that build produced. All three lanes egg-boot (no baked image), so the corpus runs off the freshly eval’d egg either way — a level field, so the test row also reflects each binary’s own speed (it eval’s its compiler out of the egg before the first test runs). gcc and clang build the identical units at the host’s real -O2 flags (minus -Werror, a lint gate, not a speed factor). mooncc trades some compile and run throughput for that self-sufficiency; the gap to the optimizing compilers is modest, and the binary it emits passes the identical corpus.