Release history on Xo Language

Xo 0.32 release notes

Sun, 25 Oct 2026 19:58:16 -0400

Downloads: Xo 0.32.0 on GitHub, with archives for macOS (Apple silicon and Intel, signed and notarized), Linux (arm64 and x86-64), and Windows (x86-64, Authenticode signed), and a SHA256SUMS file. Getting started shows how to install one. Versions 0.28 to 0.31 were internal bootstrap compilers with no public archives, so these notes cover everything since 0.27.0.

Xo against Go

Each release is measured against Go on the same Mac (bench/results/release-vs-go-v0.32.0.md, lines 9 to 295):

Xo 0.27 release notes

Fri, 23 Oct 2026 13:35:07 -0400

Downloads: Xo 0.27.0 on GitHub, with archives for macOS (Apple silicon and Intel, signed and notarized), Linux (arm64 and x86-64), and Windows (x86-64, Authenticode signed), and a SHA256SUMS file. Getting started shows how to install one.

Xo against Go

Each release is measured against Go on the same Mac (bench/results/release-vs-go-v0.27.0.md, lines 11 to 24):

Run time: Xo is faster on 14 of 20 workloads, within noise on 2, and slower on 4 (conc rwmutex 3.58 times Go’s wall time, llvm nbody 1.57, conc spawn 1.20, conc pmap 1.07).
Peak memory of the run: lower than Go’s on all 20 (0.38 to 0.99).
Binary size: 1.85 to 1.94 MB against Go’s 2.39 to 2.43 MB.
Compile: cold builds 1.8 to 2.3 s against Go’s 1.6 to 1.9 s; a warm build of an unchanged program, 0.27 to 0.34 s against 0.04 s (0.42 to 0.64 s in 0.26.0), is still the largest gap, and xo’s build now peaks at 0.49 to 0.50 GB cold (0.76 to 0.89 GB in 0.26.0).

Breaking changes

A third-party use go needs a pin (decision 0356). A use go of a package outside Go’s standard library needs require go <module> <version> in xo.mod; without it the use is error XO1319. Before, the build followed the module’s latest version and recorded it only in the git-ignored .xo/, so two machines could build different code from the same commit. xo fix adds the line with the version the binding resolved, and xo mod tidy adds missing pins. xo.lock now records each pinned Go module’s go.sum hashes (go <module> <version> h1:...): a changed module is XO1304, a missing line XO1305 (run xo mod tidy). Go’s standard library packages need nothing.
std’s errors print plain messages (decision 0358). Display of std’s error enums is a sentence, as Go’s error strings are: PATH: no such file or directory, connection refused, no rows in result set, instead of nested Debug output such as Conn(msg: "Io(msg: \"tls: ...\")"). This covers FsErr, NetErr, IoErr, EnvErr, ProcErr, ClockErr, SqlErr, HttpErr, ClientErr, UrlErr, CookieErr, TlsErr, SmtpErr and TemplateErr. ${e:?} (Debug) is unchanged. A program or test that compares the printed text changes with it.

New

--release is a preset (decision 0354). Each setting it changes has its own flag in any build (xo build, run, test), which wins over the preset whatever the order: --debug-contracts, --dbg, --error-args, --debug-info=on|off|split, --profile-support, --trace-support (on|off, a bare flag is on) and --opt=O0..O3 (LLVM). --error-args=off no longer needs --release.
--debug-info=split (decision 0355) keeps the debug information beside the program: PROG.dSYM on macOS, PROG.debug on Linux, found by tracebacks, lldb, gdb and addr2line.
Build information in every binary. xo version -m BINARY prints what built it, as go version -m does: the xo, backend, target, every effective setting, the stamps and the sources’ hashes. A native crash report names the build on its second line.
Deterministic scheduling on the native backends (decision 0350): xo run --seed=N, xo build --seed=N, and xo test --seed=N / --explore=N run every task on one thread with a seeded choice at each scheduling point, so a seed reproduces an interleaving. --explore prints the command that reproduces a failure.
XO_PROF_HEAP_AT=TEXT (std/debug) writes the heap in use when a labeled point is reached.

Faster

xo check is about 2.5 times faster on a warm run (xo itself 1.8 s to 0.67 s, a small server 0.59 s to 0.26 s) and peaks a third lower in memory: an unchanged module is skipped and its diagnostics replayed, and the native runtime’s bodies are checked as a build checks them. xo check --support is 2.3 to 2.6 times faster (3.7 s to 1.6 s on xo itself). The output is unchanged; XO_CHK_CACHE=off checks everything.
Warm builds: the module check cache and a shared cache pack are on by default (a warm build of xo itself 0.885 of the wall time; a new program’s first build 0.831), front end cache keys that are never stored are no longer looked up, and std and runtime function bodies are parsed only when needed (a small program’s warm build peaks about 40% lower in memory). XO_CHK_CACHE=off, XO_SHARED_PACK=off and XO_LAZY_PARSE=off turn them off.
Runtime: channels of one-word values (integers, Float, Bool, enums without payloads) send the word instead of a one-element list (ping pong 0.835 of the wall time); List.sort sorts runs of 16 and merges between two buffers (1M Ints 0.82 of the wall time, now level with Go); derived JSON decoders find every field in one pass; the macOS monotonic clock is read as Go reads it.
Code generation on x86_64: a better register ranking for long hot ranges, cold-path saves, and a larger inlining budget for a function called once.
std/http and std/url: a URL is parsed once, a plain query is read in place, and router path parameters skip a range check.

Fixes

Most of these come from field testing of 0.26.0 on an Intel Mac and on Windows. Thank you to the testers: every report below was reproduced, fixed with a test, and checked again.

Xo 0.26 release notes

Thu, 22 Oct 2026 23:51:42 -0400

Downloads: Xo 0.26.0 on GitHub, with archives for macOS (Apple silicon and Intel, signed and notarized), Linux (arm64 and x86-64), and Windows (x86-64, Authenticode signed), and a SHA256SUMS file. Getting started shows how to install one.

Xo against Go

Each release is measured against Go on the same Mac (bench/results/release-vs-go-v0.26.0.md, lines 11 to 22):

Run time: Xo is faster on 14 of 20 workloads, within noise on 3, and slower on 3 (conc rwmutex 3.78 times Go’s wall time, conc pingpong 1.51, llvm nbody 1.43).
Peak memory of the run: lower than Go’s on all 20 (0.38 to 0.97).
Binary size: 1.81 to 1.89 MB against Go’s 2.39 to 2.43 MB.
Compile: cold builds 2.0 to 2.4 s against Go’s 1.9 to 2.0 s; a warm build of an unchanged program, 0.42 to 0.64 s against 0.04 to 0.08 s, is the largest gap.

Behavior changes to read before upgrading

xo run DIR runs exactly DIR; a plain directory never walks below it (decision 0345). In a parent of two programs, xo run . used to run the first one it found; it now says which subdirectories hold a program. build, check, test, vet, doc, fmt, fix, parse and audit cover subdirectories only with DIR/..., which stops past 6,000 .xo files or 60,000 entries. Write xo check ./... where xo check . used to cover the tree.
xo build and xo run no longer read _test.xo files (decision 0348). A type error in a test file no longer fails a build, a helper declared only in a test file is not visible to the program, and a use that only tests have is neither fetched nor bound. xo test and xo check report test files’ errors as before.
Fault tracebacks by default. An uncaught fault in a native program prints traceback: and one line per frame down to main, as a hardware fault’s report already did. XO_TRACEBACK=0 restores the one-line report. The binary is unchanged; each fault costs about 0.55 us more, a caught one included.
Embedded DWARF on macOS (decision 0346). Darwin executables carry their debug information in a __DWARF segment instead of a NAME.dSYM beside them, so a copied or packaged binary keeps file and line names in crash reports, tracebacks, the profiler, --race, atos and lldb. --dsym also writes the bundle; -s and --release leave both out (--release --debug-info keeps the segment). Release binaries ship with their DWARF: the darwin archive grows from 23.2 MB to 34.4 MB (+11 MB).
--race is native by default wherever a prebuilt ThreadSanitizer runtime ships (darwin/arm64, darwin/amd64, linux/arm64, linux/amd64, windows/amd64), so it no longer needs clang. In 0.25.2 xo build --race . picked the LLVM backend and failed without clang. Other targets still use LLVM. (decision 0273 addendum)
opt? on an Option in a test block fails the test (decision 0347) with error: missing value: EXPR, instead of being error XO0204. Helper functions and fn literals keep the usual rules.
xo has a memory budget (decision 0349): past three quarters of physical memory, at least 16 GiB (18 GiB on a 24 GB Mac), xo stops with fatal error: memory budget exceeded: ... and the phase it was in, instead of swapping the machine. Builds of xo itself peak at 9.9 to 11.2 GB counted. XO_MAX_MEM sets another budget (off for none); any native program can use it.
Daylight saving gaps: Ambiguity.Earlier and Later were swapped. For a local time inside a spring-forward gap, Earlier now gives the earlier instant and Later the later one, as in an overlap: 02:30 on 2026-03-08 in New York is 01:30 EST with Earlier and 03:30 EDT with Later. A program that relied on the old result swaps the two arguments.
Large Maps branch instead of copying (decision 0291): on the native backends, a Map or Set of 1024 or more entries written while another value shares it no longer copies its lists; the written copy reads the shared lists in place. bench/perf/xo branch: 0.071 of the wall time (65.6 to 4.7 ms), 0.733 of the peak RSS; the HTTP CRUD server within noise. XO_MAP_LOG=1 builds without it.
LLVM builds of large programs split: over 100 MB of IR (xo itself), --backend=llvm splits into modules of about 50 MB with thin LTO and runs as many clang jobs as three quarters of memory allows at 3.5 GB each; the LLVM build of xo peaks at 11.1 GB instead of passing 20 GB. Smaller programs are unchanged (one module, full LTO). XO_LLVM_SPLIT and XO_LLVM_JOBS override.

Xo 0.25 release notes

Thu, 22 Oct 2026 08:41:57 -0400

0.25.2: the first binary release

Downloads: Xo 0.25.2 on GitHub, with archives for macOS (Apple silicon and Intel, signed and notarized), Linux (arm64 and x86-64), and Windows (x86-64, not code signed yet), and a SHA256SUMS file. Getting started shows how to install one.

0.25.2 is the first Xo release with prebuilt binaries. It is 0.25.0 plus the fixes below. 0.25.1 was tagged but never got binaries: its Windows xo.exe crashed on every build, because Xo’s COFF writer overflowed the 16-bit relocation count of a section with 65,535 or more relocations. 0.25.2 writes the extended count, as LLVM’s COFF writer does.

Xo 0.24 release notes

Wed, 21 Oct 2026 14:25:46 -0400

Introduction

Xo 0.24 makes native Maps and Sets a hybrid persistent map, which takes a mixed CRUD server at 1024 connections from 18.0k to 83.0k requests per second. Native code generation is level with LLVM on arm64 and about 6 percent behind on amd64, builds are faster, and the standard library gains XML, big numbers, compression, and a streaming JSON decoder.

Changes to the language

Moves of the move-only builders are flow sensitive: a return, break, continue, or failing ? ends its path’s moves, so a value moved there is still usable after the branch (decision 0300).
embed puts files in the binary (decision 0304).
A program’s own values convert to the capability interfaces (Fs, Proc, Env, Net) on the native backends (decision 0307).
Wire names per format for JSON, SQL, and XML, and derive Xml (decision 0315).
Prelude additions.

Compiler and runtime

Native Maps and Sets are the hybrid persistent map by default; the micro benchmarks stay within 1.2 times the lists (decision 0291).
Preemption polls on amd64 and on LLVM’s x86-64 code, with the thread-local table no longer reused across a poll (decision 0286).
Native code generation level with LLVM on arm64 and about 6 percent behind on amd64 (the comparison).
Faster builds: std interface hashing from tokens, per-file LLVM test splits, a run cache for std module tests, and reference counting insertion in about half its cold time.
The Go backend compiles path and uuid from their Xo source and supports tuples of up to 64 elements (decision 0312).

Standard library

std/xml (decision 0314).
std/big, with Karatsuba multiplication and recursive division (decision 0311).
JSON omitempty and a streaming decoder (decision 0309).
std/compress and gzip responses; client_ip.
The HTTP/1.1 client keeps connections alive (decision 0303).

Tools

xo def, refs, rename, and symbols cover runtime names, fields, variants, and interface methods.
The strict inliner verifier runs in xo dev goldens and codegen checks.
Every Go test names the xo it runs and refuses a stale one.
--no-preempt; xo build --profile.
Backend cache pruning fixed (an overflow, concurrent accounting, a prune version guard).

Fixes

CI and fresh builds work again: 0.23.0 cannot build them, because its inliner verifier rejects main.

Xo 0.23 release notes

Tue, 20 Oct 2026 21:52:07 -0400

Introduction

Xo 0.23 makes Xo’s own backend the default on x86-64 hosts, keeps build caches across compiler rebuilds and shares them across programs, runs --race on arm64 with no clang, cuts HTTP tail latency under CPU-bound handlers from about 86 ms to about 3 ms at p99, and adds the first batch of a standard library modeled on Go’s.

Changes to the language

Field wire names, field as "key": T, and case rules for derived encodings (decision 0277).
A newtype encodes to JSON as its underlying value on every backend (decision 0097).
An interface value holding a handle or a function equals nothing.
ServerConn for accepted connections (decision 0280).

Tools

--race on the arm64 backend: Xo’s own linker loads a TSan runtime shipped with Xo, so no clang is needed (decision 0273).
One name resolver behind xo def, refs, doc, symbols and query, covering std too, with text output at a terminal; xo vet runs on std (decision 0289).
x86-64 native binaries carry DWARF line tables and variables on Linux and macOS. XO_TRACEBACK=locals shows the faulting frame’s values and inlined callees’ variables.

Compiler

Native is the default backend on x86-64 hosts too (macOS, Linux and Windows): xo build uses Xo’s own x86-64 backend, with no C toolchain, and --backend=llvm still selects LLVM (decision 0270).
Build caches are keyed by the code generation sources instead of xo’s binary, so a rebuilt xo keeps them: rebuilding xo after a driver-only change takes about 41% of a cold build (decision 0275). Standard library function bodies are shared across programs (decision 0271).
x86-64: immediates, load sinking and branch on compare (RSA signing 6% fewer instructions, other compute 2 to 8%).

Runtime

A parked root task hands its next task to an idle worker, so an accept loop is no longer stuck behind a running handler. With 8 CPU-bound handlers on Linux arm64, p99 from dial to response went from 86 ms to 2.4 to 3.1 ms (Go: 7.5 to 12.5 ms) (decision 0286).

Standard library

The standard library now follows Go’s for scope, code and tests, with Xo’s own API (decision 0276). New in this version:

Xo 0.22 release notes

Mon, 19 Oct 2026 21:13:49 -0400

Introduction

Xo 0.22 builds Windows programs with Xo’s own backend and no C toolchain, cuts the size of LLVM builds to between a half and a third, speeds up the edit loop, makes HTTP and TLS cheaper, and fixes a heap overrun every native program had at startup since 0.21’s development.

Fixes

The runtime’s root context registry used a byte offset as a slot index and wrote about 2 KB past a 296-byte runtime record at startup on every OS. It was silent on macOS and Linux and a crash at startup on Windows.

Ports

Windows: Xo’s own x86-64 backend builds windows/amd64 (--backend=amd64) with its own COFF writer and PE linker, a checked-in import table, manifest and version resources, and no C runtime: no clang, lld-link, or Windows SDK (decision 0254). The default backend on x86-64 hosts stays LLVM for now (decision 0270).

Compiler

Smaller binaries: xo’s code went from 40.18 MB to 31.78 MB built natively and from 89.82 MB to 32.59 MB built with LLVM; the Windows xo.exe from 160 MB to 63.65 MB.
A faster edit loop: packed and lazily decoded cache entries, parallel borrow inference, and a front end cache for function bodies (decision 0220). Rebuilding xo after a one-constant edit went from about 9.5 s to about 6 to 8 s.

Runtime and standard library

TLS is 8.2% and HTTP/2 9.2% cheaper per request on arm64, with cheaper JSON encoding and HTTP/1 headers.
Faster allocation while other threads run.
Task stacks are kept at their peak size: 97% fewer page faults in connection bursts.

Xo 0.21 release notes

Sun, 18 Oct 2026 15:12:17 -0400

Introduction

Xo 0.21 builds Intel Mac programs with Xo’s own backend and no C toolchain, makes native binaries smaller, brings dbg to every backend, adds Int word methods and lookup commands for agents, and makes TLS and HTTP cheaper.

Changes to the language

dbg(expr) works on every backend and in --no-gc builds, and --release strips it (decision 0265).
Int’s word operations are methods that compile to inline operations: wrapping_shl, shr_logical, rotate_right, rotate_right32, swap_bytes, mul_hi_unsigned, lt_unsigned and le_unsigned, next to the existing wrapping_add, wrapping_sub and wrapping_mul (decision 0260).

Tools

Lookups for agents: xo def, xo refs, xo type, xo doc and xo symbols (decision 0261).
Miscompile triage: XO_PASSES turns optional optimization passes off by name, and xo dev bisect-pass finds the first pass whose build behaves differently. Property tests reduce a failing case automatically.
xo test --std-module runs a standard library module’s own tests (decision 0262).
XO_POISON_FRAMES for finding reads of stale stack memory.
Test programs no longer outlive their tests: each runs in its own process group.
xo vet warns about large copies with XO0530 (decision 0263).

Compiler

Native builds drop every function nothing calls. hello is 26.5% smaller, and the JSON, HTTP and TLS servers 13.5 to 16.7% smaller on an Apple silicon Mac, smaller than LLVM’s builds. xo itself went from 57 MB to 42 MB.
Tuple folding after inlining: HTTP/2 11.5% and TLS 8.9% fewer instructions per request.
Fixes to range analysis, including a crash on an empty interval.

Standard library

Bytes from outside the program that are not valid UTF-8 become a valid Str at every boundary (decision 0259).
TLS handshakes are 13.9% cheaper on arm64 and 22% on x86-64; HTTP/2 is 11.6% cheaper, and more from moving reference counted payloads. P-256 and X25519 are faster.

Ports

Intel Macs: Xo’s own x86-64 backend now targets darwin/amd64, with its own Mach-O assembler (objects byte identical to clang’s) and linker. All 193 test programs pass on an Intel Mac with no C toolchain (decision 0254).
Windows: Xo’s own calls on Windows will use the System V convention, decided for the coming windows/amd64 port.

Xo 0.20 release notes

Sun, 18 Oct 2026 00:54:28 -0400

Introduction

Xo 0.20 adds Xo’s own x86-64 backend, brings native code within about 10% of LLVM’s instructions, makes TLS and HTTP much faster, and gives debuggers DWARF variables and types. See Correct first, fast later for how the backends caught up. In the source, the compiler moved from selfhost/ to compiler/, and the licenses are MIT, with MIT-0 for the standard library.

Changes to the language

A discarded result of a pure call is an error, XO0209 (decision 0258).
A native fault inside deferred code is handled as the spec says (section 5.6).

Tools

Debugging: DWARF variables and types (Str, List, Map, enums) on the arm64 and LLVM backends, constant locations, and gdb and lldb backtraces that end cleanly (decision 0252). xo debug, a debugger written in Xo, has its reader, unwinder, batch session and JSON protocol working on recorded threads (decision 0253).

Runtime

Memory copies use SIMD, atomics use LSE on Linux arm64, and task spawn is faster (on Linux, below tokio’s current_thread).
Reads and writes over 2 GiB work.
Small maps have no hash table.
Fewer reference count operations: immortal values are not counted, and retain and release pairs cancel.

Compiler

x86-64 backend (decision 0254): xo build --backend=amd64 builds linux/amd64 programs with no C toolchain, with Xo’s own assembler and linker, and uses AES-NI, PCLMULQDQ and SHA-NI. Its geometric mean went from 1.63 to 1.14 times LLVM’s instructions.
arm64: the geometric mean went from 1.32 to about 1.09 times LLVM’s, and P-256 is at parity. Load and store pairing now works on Linux, along with reload reuse, address and rotate folding, inline string pushes, constant hoisting in loops that call, loop invariant fields (decision 0257), and inlining of closures, map lookups, and callees with landing pads at closure sites (decision 0256).

Standard library

TLS keep-alive requests take 19 to 27% fewer instructions (no copy of the connection state per read and write), plain HTTP/1.1 about 10% fewer, and ML-KEM 60% fewer.

Ports

WebAssembly: file handles and file operations over WASI, and time zones when a program uses them; 169 test programs pass.

Known issues

On Intel Macs with the LLVM backend, this version’s standard library does not catch faults (a stale register in the unwinder’s frame cache). Fixed in 0.21.

Xo 0.19 release notes

Sat, 17 Oct 2026 04:08:21 -0400

Introduction

Xo 0.19 makes native code the default, links Linux programs with no C library, makes servers much smaller, runs the playground on Xo’s own compiler, and makes tasks faster.

Tools

Native is the default backend: arm64 on arm64 hosts, LLVM elsewhere. Use --backend=go for programs that use go (decision 0248).
Contract fuzzing on the native backends (decision 0250), and xo dump of a running program’s tasks on SIGQUIT (decision 0251).
An execution trace: XO_TRACE and xo trace (decision 0240).
The profiler is gated in release builds and samples on Windows too; its writers moved to xo prof (decision 0245).
DWARF types and variables for arm64, first stages (decision 0252).
The browser playground runs on Xo’s WebAssembly backend (decision 0242).
Lazy runtime bodies: hello builds in 622 ms instead of 947 ms (decision 0247).

Runtime

Single thread task spawn went from about 4.8 to 1.13 times tokio current_thread’s cycles.
RWMutex readers stay on the worker that granted them: the rwmutex benchmark went from 90 to 40 ms, and HTTP p99 latency from 1,536 to 1,328 us.

Compiler

Smaller binaries: TLS and HTTP/2 are linked only when a program calls with_tls, so a JSON server went from 2.51 to 0.94 MB on arm64 (decision 0244), and code for other targets is folded away (decision 0246).
arm64: if-conversion, carry intrinsics inlined, constant folding of *, / and %, and cold slow paths kept out of line.
The first part of Xo’s own x86-64 backend: its assembler (decision 0254).

Standard library

Time zones ship with the standard library (IANA 2026e); no Go needed.

Ports

Linux without C: programs that do not use c link no C library. Xo’s ELF linker builds them as static binaries, also when cross built from a Mac (decision 0243).

Xo 0.18 release notes

Fri, 16 Oct 2026 16:21:00 -0400

Introduction

Xo 0.18 adds a profiler, debug line tables, and race checking, moves the runtime’s stress tests to Xo, and makes arm64 code faster.

Tools

Profiling: XO_PROF=cpu,heap, or xo run and xo test with --profile=cpu,heap, writes pprof output and a text summary, on the arm64 and LLVM backends, on macOS and Linux (decision 0238).
Debug information: DWARF line tables from both native backends (a dSYM on macOS), so lldb stops at .xo lines and shows inlined calls, and the profiler names .xo lines. XO_TRACEBACK prints a fault’s frames, and xo test sets it (decision 0239).
Races: xo build --backend=llvm --race builds every function, the runtime’s too, with ThreadSanitizer. The races it reported in the runtime are fixed.

Runtime

The scheduler has a monitor thread and defers wakes for channel hand offs and spawns, bounded by the waker’s next runtime call. Real-time programs get none, XO_DEFER_WAKE=0 turns it off, and mutex wakes stay direct (decision 0077).
The runtime’s C stress tests are Xo programs (decision 0241).

Compiler

arm64: SHA-256 on the SHA instructions; add with carry chains with constant operands and the zero register; bic, orn, eon and extr; one more register for the allocator. RSA, P-256, P-521 and X25519 are faster on arm64.
The WebAssembly backend passes its compiler build test again (it failed since 0.15).

Ports

macOS arm64 links with Xo’s own linker by default again. The XProtect false positive and the stall at a program’s first launch from each path are fixed. TLS loads Security and CoreFoundation only at the first certificate check.

Xo 0.17 release notes

Fri, 16 Oct 2026 08:31:52 -0400

Introduction

Xo 0.17 makes public key crypto and bulk TLS much faster and fixes a macOS XProtect false positive.

Runtime

Faults on Linux unwind without /proc (and under valgrind): the auxiliary vector is read from memory.
Native standard input from a FIFO sees its end of input on macOS.
Processes have 256 static words for the runtime’s own state (decision 0237).
Security and CoreFoundation load lazily on macOS: start up went from 28.5M to 14.4M instructions on LLVM.

Compiler

Add with carry chains on arm64, up to 8 pairs an instruction (decision 0231).
Large constant integer lists are kept as data: the HTTP client went from 2.51 to 2.12 MB on LLVM.

Standard library

P-256, X25519 and RSA use the carry chains: RSA 4096 server handshakes take 45.6% fewer instructions on arm64 and 43.3% on LLVM, RSA 2048 32.9% and 29.9%.
P-384 and P-521 signing use fixed base tables made on first use (0.37 to 0.45 of the time); ML-KEM takes 8 to 12% fewer instructions on arm64.
AES-GCM: GHASH folds four blocks per reduction and CTR runs 64 byte chunks. Bulk TLS beats Mbed TLS on both backends (AES-128, TLS 1.2: arm64 13.6, LLVM 11.8, Mbed 14.0 million instructions per MiB).

Ports

macOS: binaries from Xo’s own linker no longer match an XProtect signature (a program hung waiting for assessment); all 179 test programs scan clean.

Xo 0.16 release notes

Fri, 16 Oct 2026 01:29:36 -0400

Introduction

In Xo 0.16 the native runtime has no C left. On 2026-10-13 it was 26,743 lines of C, with 206,879 more in third party libraries. See No C left in the runtime.

Runtime

The runtime’s C is 0 lines. main is Xo (decision 0234), the backends emit the program’s entry, and Windows’ stack overflow handler is Xo. The compiler builds no C into a native program.
Faults unwind through a frame cache: 0.57 to 0.64 of the time before the runtime moved to Xo, on arm64.
The native in-memory file system has every Fs method.

Changes to the language

File, FileLock and Child are handles: comparing them with == is error XO0404.

Tools

xo test runs native tests in batches, shrinks failures over a pipe, runs chunks in parallel, caches runs, builds LLVM test binaries at -O0, and takes --timeout. A warm run of the notes-service example went from about 43 s to about 0.25 s (decision 0235, decision 0236).

Compiler

LLVM runtime slow paths are cold; AES-GCM and ML-KEM are faster.

Ports

Linux: every test program passes on linux/arm64 with both native backends. linux/amd64, run under emulation, passes after two unwinder fixes and a thread local fix in the LLVM backend. ThreadSanitizer and AddressSanitizer builds pass.

Xo 0.15 release notes

Thu, 15 Oct 2026 20:46:40 -0400

Introduction

Xo 0.15 moves a program’s entry toward Xo: the runtime’s C went from 476 lines to 343.

Runtime

Xo functions can be exported under exact C names, and the backends define the data symbols a program with no C library needs (environ, stdin, stdout, stderr) (decision 0234).
With no C library, the process entry (_start, the thread pointer, the stack switch) is emitted by the arm64 and LLVM backends, and the runtime’s own printf is gone.

Compiler

LLVM builds of a single module use no LTO at -O0 (the compiler built in 129 s instead of 1,871 s) and full LTO at -O2 (XO_LLVM_LTO).
arm64: Int constants fold after inlining; ML-KEM and SHA-3 run about 2.8 times faster.

Xo 0.14 release notes

Thu, 15 Oct 2026 17:36:42 -0400

Introduction

In Xo 0.14 the runtime’s C went from about 2,660 lines to 476.

Runtime

The services records, the scheduler’s statistics and fiber records, the poller’s and shutdown’s callbacks, the signal and console handlers, and the code that runs main are Xo (decision 0233).
The C record layouts of the task runtime, the heap, and the event loop are gone.
Large allocations use Xo’s allocator with a per-thread cache.
Optional features register their own exit functions.

Compiler

Error XO0608 reports an export name defined in two modules.
The empty list and the zero handle are emitted per program.

Xo 0.13 release notes

Thu, 15 Oct 2026 14:19:20 -0400

Introduction

Xo 0.13 deletes the last third party C: TLS is written only in Xo. The runtime’s C went from about 5,800 lines to about 2,660.

Runtime

Mbed TLS and fiat-crypto are deleted (206,879 lines of third party C).
The Windows event loop, main’s threads, the network, clock, scope and fault entries, the x86-64 unwinder, the allocator’s entries, and the handle code are Xo.
The backends call the Xo runtime directly for faults, string compare, number formatting, network, clock, scope, cancellation, and real-time entries.
A fault in a native server’s connection ends only that connection.
Sanitizer builds map the heap through libc, so ASan and TSan see it.

Xo 0.12 release notes

Thu, 15 Oct 2026 11:58:07 -0400

Introduction

Xo 0.12 moves most of the native runtime into Xo: its C went from 26,743 lines to about 5,900.

Runtime

The scheduler, the event loop, sockets, processes, the test world, the HTTP/1.1 and HTTP/2 client and server, standard input, the file system, and the program’s entry are Xo.
The backends call the Xo runtime’s allocation, reference count, list, string, heap, and Any entries directly.
A fault in middleware or a connection no longer stops the native HTTP server.

Compiler

Crypto intrinsics: add and subtract with carry, AES rounds, and carry-less multiply (decision 0231). External C symbols can be referenced from Xo weakly (decision 0232).
== on enum constants folds at compile time.
An inlining verification failure is reported, not hidden.

Standard library

TLS 1.2 and 1.3, X.509 parsing and verification, and the crypto under them (SHA-2, SHA-3, HMAC, HKDF, AES-GCM, ChaCha20-Poly1305, X25519, P-224 to P-521, RSA, Ed25519, and the ML-KEM-768 and -1024 hybrids) are Xo, matching Go 1.26’s behavior and group list (decision 0202). The default build links no Mbed TLS or fiat-crypto.

Xo 0.11 release notes

Wed, 14 Oct 2026 13:51:55 -0400

Introduction

Xo 0.11 has no language or spec changes from 0.10: programs build and behave the same. It moves more of the runtime from C into Xo, with every moved piece within 5 percent of the C’s instructions (decision 0180), and makes rebuilds faster.

Runtime

About 4,900 lines of runtime C deleted. Standard output and error, exit, environment and arguments, the constant time barrier (decision 0222), the HTTP/1.1 client parser and response writer, the HTTP/2 HPACK coder, string and list objects (decision 0226), the test world, file system operations on Linux and macOS, and the linux/arm64 unwinder for programs with no C library (decision 0221) are Xo.

Compiler

arm64 shrink wrapping and tail calls: the compiler’s own build runs 0.985 of the instructions (decision 0224).
Constant Int expressions fold to one constant.

Tools

Per function back-end and reference counting caches: a one module edit of the compiler rebuilds in about 12 s instead of 31 s on a Mac (decision 0220).
Build caches are pruned by age and size (decision 0223).