Language Comparison and Competitive Assessment

This page compares seed with the languages it is most likely to meet in systems tools, services, and performance-sensitive applications. It combines the current implementation status, a reproducible 1-10 systematic score, and the canonical local benchmark snapshots. The goal is to describe seed's competitive shape, not to claim universal superiority.

All 1-10 scores are derived from instruments in bench-compare/ — see bench-compare/CRITERIA.md (rubric) and bench-compare/SCORES.md (table). Adding a language = corpus/<workload>/<lang>/ + scripts/measure.sh + scripts/run.sh recalculates 10*best/measured without subjective judgment.

Systematic 1-10 scores (reproducible)

Weights: Security 40% + Efficiency 35% (runtime/RSS+binary/compile) + Ergonomics 25% (LOC/diagnostics/tooling). 10 = best in corpus, 1 = >10× worse.

Language	Security (40%)	Efficiency (35%)	Ergonomics (25%)	Total	Notes
seed	10 — 6/6 `safety/` + `linear` + `unsafe` only libs	9 — 10.49s (9.7) + 27.8 KiB (10) + 33.2 MiB (10) + 0.84s (4)	7 — LOC 218 (5.0) + `Hxxx` (10) + `check` 0.8s (8)	8.9	`C-like` with proof, artefact <32 KiB
Rust	9 — borrow checker + `Send`	6 — 12.14s + 2.04 MiB (0.1) + 33.3 MiB + 2.69s	9 — LOC 142 (7.6) + 9 + 10	8.0	safe, binary large
C	2 (4 w/ ASan) — manual UAF	10 — 10.17s (10) + 28.3 KiB (9.8) + 33.1 MiB (10) + 0.33s (10)	5 — 6.2 + 3 + 5	5.6	fastest, unsafe
Zig	2 — manual	6 — 11.19s + 204 KiB + 32.9 MiB + 4.23s	6	4.6	manual
Nim	6 — GC	8 — 7.69s* + 52 KiB + 50 MiB + 1.44s	6	6.7	*fib 0.09s folding
Go	6 — GC	5 — 15.32s + 1.53 MiB + 52.9 MiB + 2.83s	8	6.2	GC
Mojo	6 — partial ownership	7 — 89s benchgame 0.96× seed	5	6.2	Python superset
Java/C#	6 — GC	3-4	8	5.1-5.8	VM, RSS 300-500 MiB
Python	6 — GC	1-2 — 302s (0.16) + RSS 153 MiB	7 — LOC 127 (8.5) + diag 4 + 7	4.0-4.5	JIT, no `Hxxx`

Python is 7 in ergonomics, not 10, because here ergonomics = systems workload (primes/mandelbrot/trees) with wc -l + Hxxx + tooling: Python has 8.5 in LOC but 4 in diagnostics (runtime only) vs seed/Rust 10/9 with span+suggestion.

Full rubric and 10*best/measured formula in bench-compare/CRITERIA.md. Raw CSV in bench-compare/results/results.csv and benchmarksgame/comparison/RESULTS.md.

Language snapshot

Axis	seed	C	Rust	Zig	Go	Nim	Java	JavaScript/TypeScript	Python
Type discipline	Static, inferred, nominal	Static, weakly constrained	Static, strict	Static, explicit	Static, inferred	Static, inferred	Static, nominal	Dynamic, optional TypeScript	Dynamic
Memory-safety (1-10)	10	2	9	2	6	6	6	6	6
Efficiency (1-10)	9	10	6	6	5	8	3	4	1
Ergonomics (1-10)	7	5	9	6	8	6	8	9	7
Memory model	Ownership, move-only resources, borrowed views, regions, explicit sharing	Manual	Ownership and borrow checking	Manual with explicit allocators	GC	GC, ARC, or ORC	GC	GC	GC
Cleanup	Deterministic, exact-once on structured exits	Manual	Deterministic through ownership	Manual and `defer`	GC plus `defer`	Runtime strategy dependent	GC and scoped resources	GC	GC and context managers
Concurrency	Structured `spawn`; library channels, typed task results, and synchronization	OS and library threads	Threads and async ecosystems	Threads and async libraries	Goroutines and channels	Threads and async libraries	Threads and virtual threads	Event loop and workers	Threads, processes, and async libraries
Low-level access	High and explicit through `unsafe`	Very high	High	Very high	Medium	Medium	Medium through FFI/JNI	Low	Low through extensions/FFI
Compilation model	Native LLVM, separate compilation, reusable libraries	Native	Native LLVM	Native LLVM	Native	Native C backend	JVM bytecode or source launch	JIT or interpretation	Interpretation or JIT
Ecosystem	Small operational core; larger Grove porting corpus	Very large	Large	Medium	Very large	Small	Very large	Very large	Very large
Tooling maturity	Operational but early	Excellent	Excellent	Good	Excellent	Good	Excellent	Excellent	Excellent
Learning overhead	Low to medium	Medium	High	Medium	Low to medium	Medium	Medium	Low to medium	Low
Best fit	Systems tools and controlled native applications	General systems code	Safety-focused systems code	Low-level systems code	Network and cloud services	Native productivity applications	Enterprise applications	Web and UI applications	Automation, data, and scripting

The 1-10 scale is the systematic rubric (0-3 low/manual, 4-6.9 partial, 7-8.9 strong, 9-10 strong by default), not a benchmark, and unsafe hatches weaken every language.

Measured canonical snapshots

benchLANG — 5 workloads, 19 languages (2026-07-12, Ryzen 5900X)

Language	Suite execution (s)	Compile (s)	LOC	Peak RSS	Binary
Nim	7.698	1.44	119	50.0 MiB	52.1 KiB
C	10.171	0.33	172	33.1 MiB	28.3 KiB
seed	10.496	0.84	218	33.2 MiB	27.8 KiB
Zig	11.194	4.23	180	32.9 MiB	204.0 KiB
Rust	12.146	2.69	142	33.3 MiB	2.04 MiB
Java	13.331	—	127	561.8 MiB	—
Go	15.322	2.83	157	52.9 MiB	1.53 MiB
JavaScript (Node)	19.319	—	108	303.2 MiB	—
Python (Python3)	302.933	—	127	153.1 MiB	—

Surface v2 re-run (benchLANG/languages/seed after ret→return/else if/Some): 16.38s total (4.31s primes 20M + 3.75s fib + 2.44s strings + 2.78s mandelbrot + 3.07s trees), 226 loc, 1.53s compile — same checksums, slower wall due to non-isolated host.

benchmarksgame — 7 programs, C×Rust×seed×Mojo (2026-08-13)

Program	C	Rust	seed	seed/C	seed/Rust
binarytrees 21	17.34s	16.56s	18.05s	1.04×	1.09×
fannkuchredux 12	38.39s	35.45s	34.97s	0.91×	0.99×
fasta 25M	3.42s	7.73s	3.23s	0.94×	0.42×
knucleotide	3.68s	5.41s	3.76s	1.02×	0.69×
mandelbrot 16k	21.68s	21.52s	21.27s	0.98×	0.99×
nbody 50M	3.20s	3.20s	3.24s	1.01×	1.01×
spectralnorm 5.5k	1.36s	2.13s	1.53s	1.13×	0.72×
TOTAL	89.07s	92.00s	86.05s	0.97×	0.94×

seed wins aggregate (3% vs C, 6% vs Rust) byte-for-byte. Full bench-compare smoke (prime 2M) in this repo: seed 0.16s / 53 KiB vs C 0.14s / 16 KiB vs Rust 0.17s / 3.9 MiB.

Complete 19-language tables and methodology in Canonical cross-language benchmarks and bench-compare/.

Where seed is strongest

native performance within 3% of C on both corpora;
smallest binary (27.8 KiB < C 28.3 KiB, 74× < Rust) and sdi reuse;
deterministic cleanup without GC, linear + regions;
ownership without lifetime syntax, Hxxx with suggestion;
6/6 safety/ mutantes rejected (S001/V001/H067/K001);
0.84s suite build vs 2.69s Rust.

Where seed remains weaker

Grove breadth, IDE/debugger polish, production history;
LOC +15-30% vs Rust/C on small programs (explicit Ok/Some/mut []);
optimizer depth beyond controlled corpus;
portability (Linux x86-64 closed, AArch64/Windows object-only).

Competitive fit

Strong: CLI/tools, native services with curated deps, security-sensitive binary/network libs, freestanding experiments. Weak: web frontend, data science, large enterprise frameworks, broad embedded/driver.

Bottom line: seed is 8.9/10 total — the only C-like with 10 safety and 9 efficiency at <32 KiB. Reproduce via bench-compare/scripts/run.sh and CRITERIA.md.