XS (xslang)

XS is a programming language whose pitch is a single 2.9 MB statically-linked binary that contains the compiler, language server, debugger, formatter, linter, test runner, profiler, and package manager — and runs unchanged on Linux, macOS, Windows, WASI, iOS, Android, ESP32, and Raspberry Pi. Same source, six backends, three transpile targets, zero runtime dependencies, 132 KLOC of C source (excluding BearSSL).

What it claims

• Six execution backends from one source:

  • xs --interp — tree-walk interpreter for the REPL and AST-level plugin debugging.
  • xs (default) — bytecode VM, what normal runs go through.
  • xs --jit — register-allocating JIT for x86-64 and aarch64; opcodes outside its supported set fall back to the VM.
  • xs --emit c — C transpiler producing self-contained source for any reasonable C compiler.
  • xs --emit js — JavaScript transpiler for Node or browser; ships less than the WASM build if you only need one program.
  • xs.wasm — WASM build of the compiler itself, with a virtual filesystem so any XS program can be evaluated at runtime in the browser.

• Benchmarks (cold from disk, best of three, Linux x86-64):

  • Startup hello-world: 3 ms.
  • fib(30): xs --jit 31 ms, VM 138 ms, node 20 ~62 ms, cpython 3.13 ~71 ms.

• Both installers (sh for macOS/Linux, irm pipe for Windows) verify the GitHub release against published SHA-256 sums before running.

Sample syntax

{- classic recursive fib, memoised -}
@memoize fn fib(n) {
    if n < 2 { return n }
    return fib(n - 1) + fib(n - 2)
}

println(fib(30))   -- 832040

Curly-brace, Haskell-style block comments {- ... -}, decorators (@memoize), expression-based if with implicit returns.

Why it's notable

The set of claims is unusual together. Cross-target single-binary languages exist (Tcl, embedded JavaScript engines), JIT'd dynamic languages exist (Lua/LuaJIT, V8, SpiderMonkey), language-server-in-the-compiler exists in modern designs (Zig, Crystal). Bundling the whole toolchain — including the JIT and the LSP — into one 2.9 MB binary that targets ESP32 and macOS is the part worth looking at.

The compiler being 132 KLOC of C is on the small side for this surface area. Comparison points: Lua is ~30 KLOC C, V8 is millions, the Zig compiler is ~250 KLOC of Zig.

Watchlist

Added to watchlist — single-author project with limited public history at time of ingest. Things to re-check at the 90-day mark:

• Real-world adoption: does anyone outside the author ship code in this?
• Whether the iOS/Android/ESP32 claims hold up under scrutiny (mobile and microcontroller targets often imply ABI/runtime caveats).
• License posture — the site doesn't make this obvious, and a "use everywhere" language without a clear license is a no-go for serious adoption.

Where it sits

Adjacent to ryelang-blog / rye-lang (small-binary embeddable language built around explicit capability whitelisting) and zig (the cross-platform-systems-language reference point). Each is making different choices about the cross-platform-plus-one-binary problem. XS bets on a much larger bundle (everything in one binary) than Rye does, and uses a more conventional syntax than Zig.

Site: xslang.org — version 1.2.32 at ingest.