Benchmarks

slang is measured against C, Go, Rust, Java, Zig and C# on the same machine, in the same session, with every toolchain version and the exact commit recorded. The full record below is reproduced verbatim from bench/RESULTS.md, including the runs where slang loses.

The headline is a loss. In that file's own words: slang does not win Phase E HTTP vs Go / C / Rust.

It is faster than Go on HTTP throughput and on compute wall time, and compiles far faster than Rust — but it loses tail latency and memory to Go, C and Rust, and those are the axes that were declared the win conditions before the numbers came in.

The rule that makes this worth reading #

RPS alone is not a win. A win against Go requires higher throughput or lower p99, and lower RSS. slang has the first and not the second, so it is recorded as a loss. Benchmarks that quote only the number that flatters them are the reason nobody believes benchmarks.

Where it stands #

Median of three rounds at c=50, Linux, 4-core Xeon. Full per-round tables, the c=200 set, compute wall times and the machine specification are below.

Also measured #

Beyond the cross-language comparison, stress_test/ holds a scaling suite for slang on its own: request-count scaling from 10k to 100k, concurrency scaling to 2,000 connections, per-endpoint characterisation, a breaking-point probe, a soak test, CPU profiles, and a concurrent-task curve with no network in the way at all. Its write-up is stress_test/reports/stress_report.html.

Phase E HTTP-only remasure (545d99b, PR #9-equivalent tree)#

HTTP-only remasure on this Linux VM at 545d99b (Revert "perf(codegen): intern bytes literals and cap glibc malloc arenas"). Every post-#9 request-path experiment is off: interned b"..." + M_ARENA_MAX, arena freelist, interned for-in, and io_wake. Compute was not rerun.

slang does not win Phase E HTTP vs Go / C / Rust. A true PR #9-equivalent HTTP tree did not restore the ~15 ms p99. Median c=50 p99 is 23.02 ms (rounds 21.78 / 23.02 / 28.46) vs PR #9 15.52 and PR #13 105.97. RPS is below #9 and above #13. RSS is a few percent below #9 (~56–62 MB) and still 3–32× Go / C / Rust.

Question this run answers: dropping intern + M_ARENA does recover the #13 ~100 ms tail down to the ~20 ms class, but it does not bring back the #9 15 ms number. That is still a lose vs Go / C / Rust on p99 and RSS.

Do not treat higher RPS than Go / Java / Zig / C# as a win. The file's own HTTP win conditions need p99 and RSS, and slang has neither vs Go / C / Rust.

Measured SHA: 545d99b738dd1c185bdc72d7e69b6dfc12c68fb7 (cursor/http-remeasure-pr9-equiv-b546 RESULTS commit is after this tree). Branch: async-preemption 545d99b + this RESULTS commit. Log/TSV: /tmp/slang_phase_e_http.

Machine#

No language was skipped. slang HTTP did not SIGSEGV. Zig compiled; c=200 still errors (harness limit). 8-worker floor unchanged.

Commands / env#

make slangc
HTTP_ROUNDS=3 HTTP_DUR=10s HTTP_CONCS="50 200" ./bench/run_http.sh

HTTP only. Did not run ./bench/run_phase_e.sh or ./bench/run_compute.sh.

Pinned HTTP ports: slang 18180, Go 18181, C 18182, Rust 18183, Java 18184, Zig 18185, C# 18186.

HTTP RSS: /proc/$pid/status VmHWM (kB). Order rotates (and reverses on even rounds) each round.

Compile notes:

• slangc time includes generated cc -O3 -flto
• C HTTP: cc -O3 -flto -std=c11
• Rust HTTP: cargo build --release after cargo fetch + cargo clean
• Java: javac then java -cp
• Zig: zig build-exe -O ReleaseFast
• C#: dotnet restore then timed dotnet publish -c Release --no-restore
• Go / Rust / Zig / C# compile seconds are higher than PR #9 on this boot (cold module / crate cache). Do not treat that as a slang compile win.

HTTP#

GET /, 200-byte text/plain body, Connection: close, no TLS. slang / C / Zig write HTTP/1.0 bytes. Go net/http, Rust axum, Java HttpServer, and C# HttpListener speak HTTP/1.1; body length was 200 on every probe.

wrk -t4 -c{50,200} -d10s --latency (threads = min(nproc, conc)). 3 rounds.

Compile times (seconds)#

Per-round, c=50#

Per-round, c=200#

Medians (n=3)#

c=50

c=200

Zig at c=200 is a raw accept + Thread.spawn per connection with no pool. It drops connections (median 2 wrk socket errors; rounds 1 / 37 / 2) and the tail blows out. That is a Zig harness limit, not a slang win to lean on.

This box's C / Go / Rust RPS is a few percent below the PR #9 rows (C 95660 vs 105133 at c=50). slang p99 is still in the 22–28 ms band on every round, not 15 ms.

HTTP vs peers (median)#

Need higher RPS or lower p99, and lower RSS to call a win vs Go. Need ~10% of C on RPS/p99. Need faster compile than Rust and p99/RSS no worse.

slang vs PR #9 / #13#

Verdict#

No language skipped. No slang SIGSEGV. Zig compiled; c=200 still drops connections. No LLVM. 8-worker floor unchanged. HTTP only. No slang syntax or bench changes.

---

Phase E results (rerun)#

Measured on this Linux VM after the -O3 SIGSEGV fix, cheap back-edges, flat arithmetic, nested-while skip, 256KB pthread stacks, 8KB green-stack freelist, and net.recv scratch-off-GC.

slang does not win the original Phase E goals vs Go / C / Rust. It is faster than Go on compute wall and HTTP RPS, and faster than C/Rust on HTTP compile, but it loses compute wall to C and Rust, loses HTTP RPS to C, and loses HTTP p99 and RSS to Go, C, and Rust.

Java / Zig / C# are first-class peers in this run. slang beats those three on compute wall and HTTP RPS. That does not make an overall win.

Harness SHA for this run: 2541d08cb619c8517f8a7010892f143e7bc83e9e (cursor/phase-e-rerun-0b3a). Base: async-preemption a64f079.

Machine#

No language was skipped.

Commands / env#

make slangc
CC_TASKS=200 CC_WORK=8000 CC_ALLOC=50 CC_ROUNDS=3 ./bench/run_compute.sh
HTTP_ROUNDS=3 HTTP_DUR=10s HTTP_CONCS="50 200" ./bench/run_http.sh

Or ./bench/run_phase_e.sh (same defaults).

Pinned HTTP ports: slang 18180, Go 18181, C 18182, Rust 18183, Java 18184, Zig 18185, C# 18186.

Compute RSS: GNU /usr/bin/time -f '%M' (kB). HTTP RSS: /proc/$pid/status VmHWM (kB). Order rotates (and reverses on even rounds) each round.

Compile notes:

• slangc time includes generated cc -O3 -flto
• C compute: cc -O3 -std=c11 -D_GNU_SOURCE (flag only; alloc half unchanged)
• C HTTP: cc -O3 -flto -std=c11
• Rust compute: rustc -C opt-level=3
• Rust HTTP: cargo build --release after cargo fetch + cargo clean
• Java: javac then java -cp
• Zig: zig build-exe -O ReleaseFast
• C#: dotnet restore then timed dotnet publish -c Release --no-restore

Compute#

Workload: 200 tasks, primes in [0, 8000) with trial division and no early break, plus list + string-keyed map of 50 entries (C keeps the existing malloc / strlen half; its total_alloc_sum is not comparable).

Every language reported total_primes=201400. Map-comparable total_alloc_sum=490000 (slang, Go, Rust, Java, Zig, C#). C reported 508000.

Compile times (seconds)#

Per-round#

Round 1 order: slang, go, c, rust, java, zig, csharp

Round 2 order: slang, csharp, zig, java, rust, c, go

Round 3 order: c, rust, java, zig, csharp, slang, go

Extra (not vs maps): slang arena wall_ms=57 rss_kb=3544 tasks_per_sec=3508 total_primes=201400 total_alloc_sum=490000 (n=1).

Medians (n=3)#

No compute crashes. slang GC did not SIGSEGV.

Compute vs peers (median wall)#

C's alloc path is weaker (no string map). Do not treat C's wall as a map-vs-map win for C, but C still wins the prime loop + pthread spawn on this box.

HTTP#

GET /, 200-byte text/plain body, Connection: close, no TLS. slang / C / Zig write HTTP/1.0 bytes. Go net/http, Rust axum, Java HttpServer, and C# HttpListener speak HTTP/1.1; body length was 200 on every probe.

wrk -t4 -c{50,200} -d10s --latency (threads = min(nproc, conc)). 3 rounds.

Compile times (seconds)#

Per-round, c=50#

Per-round, c=200#

Medians (n=3)#

c=50

c=200

Zig at c=200 is a raw accept + Thread.spawn per connection with no pool. It drops connections (median 15 wrk socket errors) and the tail blows out. That is a Zig harness limit, not a slang win to lean on.

HTTP vs peers (median)#

Need higher RPS or lower p99, and lower RSS to call a win vs Go. Need ~10% of C on RPS/p99. Need faster compile than Rust and p99/RSS no worse.

Verdict#

Narrow facts, not overall wins:

• slang compute no longer SIGSEGVs at -O3 -flto on this workload.
• slang HTTP median RPS beats Go, Rust, Java, Zig, and C# at both concurrencies.
• slang HTTP compiles much faster than tokio/axum (0.40s vs 9.69s).
• C still owns HTTP RPS, p99, and RSS. Rust owns HTTP tail latency among the managed/async servers.
• slang HTTP RSS (~60 MB) is the standout loss vs C / Rust / Go.

No LLVM. No slang syntax changes. count_primes_range in stress_test/programs/concurrent_compute/main.sl is unchanged.