fastC

compare · all

The five-language matrix

This is the ten-thousand-foot view. Per-language pages have the nuance and the worked examples — if a row matters to your decision, click through.

Dimension fastC C Rust Zig Go
Memory safety without GC Yes — runtime traps + contracts No — UB on every UB site Yes — borrow checker Partial — explicit allocators GC — not no-GC
Capability-typed I/O Yes — caps in signatures No — ambient open/socket No — ambient std::fs/net No — ambient std.fs/net No — ambient os.Open
Mandatory contracts on pub APIs Yes — @requires / @ensures No — runtime assert only No — assert!() at runtime Partial — comptime asserts No — panic only
Supply chain (sigstore + provenance) sha256 + cosign + SLSA L3 Project-by-project Per-project; not enforced Project-by-project go.sum + checksum DB
Stripped 'hello' binary 53 KB 33 KB 342 KB 50 KB 2.4 MB
Compile time (release) ~30–40% faster than Rust Fastest Baseline Fast Very fast (design wedge)
Cross-compile setup 8 presets via zig cc Toolchain-dependent rustup target add + sysroot 50+ targets natively GOOS / GOARCH, ~40 targets
Async story Deferred to stage 2.3 None — threads + poll Yes — pin/Send/Sync are hard None — colorless via async fn Yes — goroutines (CSP)
Borrow checking No — runtime traps instead No Yes — gold standard No No — GC handles it
Ecosystem size 11 curated fastc-core pkgs Every Unix + every libc 150K+ crates Zon ecosystem (small) Broad stdlib + modules
Agent-friendly tooling (MCP, JSON diags) Yes — fastc-mcp + JSON everywhere Standard CLI Project-by-project Standard CLI Standard CLI
No executable build scripts Yes — declarative manifest Makefile is structural No — build.rs, proc_macro No — build.zig is arbitrary Yes — `go generate` optional
Runtime overhead Trap shim only (~kilobytes) None None None GC + scheduler (megabytes)

Cells are short verdicts (3–10 words). The per-language pages have the row notes, the worked examples, and the honest framing.

Per-language deep-dives

  • fastC vs C
    The baseline.
    C is the language fastC compiles to. Every row in this comparison is something fastC adds on top: capability typing, contracts, runtime traps. C wins on ubiquity and toolchain breadth.
  • fastC vs Rust
    The obvious comparison.
    Rust has more safety machinery and a vastly larger ecosystem. fastC has structural answers to build.rs, capability typing, and binary size that Rust cannot retrofit without breaking its ecosystem.
  • fastC vs Zig
    The closest in spirit.
    Zig wins on cross-compilation maturity and C-interop. fastC chooses capability typing and mandatory contracts over comptime as the wedge for agent-generated code.
  • fastC vs Go
    The GC'd alternative.
    Go wins on ergonomics, goroutines, and stdlib breadth. fastC wins on binary size (53 KB vs 2.4 MB), capability typing, and audit-by-disassembly.

See also

← back to compare