# Xo 0.35 release notes


**Downloads:** [Xo 0.35.0 on GitHub](https://github.com/xo-lang/xo/releases/tag/v0.35.0),
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.

Xo 0.35.0 makes the edit link reuse the standard library's half: a separately compiled build keeps std's laid-out code from the last link and links only your program against it, so the HTTP server's edit link on macOS arm64 takes 9.89 ms instead of 23.68, and on Linux arm64 13.84 ms instead of 39.07. `use go` now reaches real Go libraries: Go generics, Go interfaces implemented by Xo functions, callbacks that return errors, pointers to basic types, channels and functional options all bind, and chi routing, zap logging and an AWS SDK v2 S3 put and get run in a tracked workflows suite. It also adds std/x509, authenticated encryption, html/template's contextual escaping, DNS record lookups, rate limiting and backoff, fixes a silent miscompile (two same-named modules shared one function body), and fixes the Windows tester's `use go` bugs 18 to 20. Archives for darwin/arm64 and darwin/amd64 (Developer ID signed and notarized), linux/arm64, linux/amd64 and windows/amd64 (Authenticode signed), each `xo` stamped with the commit it was built from (`xo version -v`).

Six changes break source, all additions to interfaces or types of the prelude and std/json: a user type implementing `Net`, `Proc` or `Env` adds the new methods, code destructuring `FileInfo` field by field adds the field, and an exhaustive `match` on `json.Value` adds an arm. The list is below.

## Breaking changes

Interfaces have no default bodies, so a user type that implements one of these interfaces adds the new methods; a wrapper forwards them to its inner value.

- **`Net` gains `dial_timeout` and `lookup_host`** (decision 0406).
- **`Proc` gains `notify`, `stop_notify` and `request_stop`** (decision 0407), signal delivery as Go's signal.Notify.
- **`Proc` gains `pid` and `ppid`** (decision 0410).
- **`Env` gains `hostname()`** (decision 0410).
- **`json.Value` gains a variant for trusted template content** (decision 0408, for html/template's trusted types below): an exhaustive `match` on `json.Value` needs a new arm, which `xo fix` adds as a hole.
- **`FileInfo` gains `is_symlink: Bool`** (default false): `read_dir` and `walk` report a link as itself, `stat` follows it. A pattern that destructures `FileInfo` field by field adds the field; struct literals keep working.

## The edit link reuses std's half

0.34.0 compiled only your code on an edit; 0.35.0 also links only your code. The first separately compiled link keeps std's half (its code, read only data and DWARF already laid out and relocated) in the back-end cache, and later links place the program after it. `XO_STD_HALF=off` turns it off.

- **macOS arm64** (decision 0409): the HTTP server's edit link 23.68 to 9.89 ms, fib's 9.40 to 3.31 ms. The program's code is in its own section (`__TEXT,_ptext`) after std's; lldb, dsymutil, codesign, Xo tracebacks and profiles read it as before.
- **Linux** (decision 0420): the HTTP server's edit link 39.07 to 13.84 ms on linux/arm64 against 0.34's link; on linux/amd64, where x86-64 had no split layout before, 60.10 to 39.27 ms against the same layout without the half. An earlier step of the same decision (no second walk of std's objects) took linux/arm64 from 48.61 to 38.31 ms.
- **windows/amd64** takes the first step: std's sections come first and keep their addresses and bytes whatever the program grows or imports; the program's own sections follow (decision 0409's PE port). The half itself on Windows is not in 0.35.
- **Smaller macOS binaries:** an edit build no longer embeds std's DWARF; tracebacks read a compact `__XODW` segment, and lldb and dsymutil read std's full DWARF through a debug map into the back-end cache (decision 0401). A small program's binary 2.03 to 1.32 MB, link time unchanged. A binary copied elsewhere after the cache was pruned still prints tracebacks with lines; `dsymutil ./prog` keeps std's names and variables for good.
- **A build that rebuilt nothing hits the binary cache again** (a cold build's spill files no longer change the link's cache key).
- **A failed std store build is no longer silent:** each separately compiled build prints one warning with the std file:line and builds the whole program.

## `use go` reaches real Go libraries

- **Go generics** (decision 0415): generic Go functions and generic Go types bind as Xo generics.
- **Xo implements Go interfaces** (decision 0416): Xo functions implement a Go interface through a constructor with named callback parameters, and Go callbacks that return an error bind.
- **Go's `any`** (decision 0412): a parameter or result of `any` (and `...any`, `[]any`) binds as `go.Any`.
- **Pointers to basic types** (decision 0419) bind as `T?`, a copy at the boundary.
- **Channels** (decision 0421): a receive-only Go channel, or one with both directions, given to Xo is a `go.Recv[T]`.
- **Functional options** (decision 0422): a variadic of an unnamed Go function type (`...func(*s3.Options)`) binds as a List of Xo functions, so AWS SDK v2's `s3.new_from_config` and every s3 client operation bind.
- **Also:** Go `error` outside a final result binds as `go.Error?`; handles convert to an interface their Go type satisfies (the `as_` upcasts cover other packages' interfaces too); Go function values, struct fields and package variables of function type, methods of named basic types, nested Go modules (aws-sdk-go-v2's) and callbacks with several results bind; go.uber.org/zap binds again.
- **A tracked Go workflows suite** runs real library workflows end to end: chi routing, zap logging and an AWS SDK v2 S3 put and get pass; pgx, toml and yaml are expected failures, each with its cause recorded.
- **Coverage** of the Windows tester's survey set (47 Go std packages, 40 third-party modules): third-party functions and methods bound 98.4 to 98.5% after the channel step, std 90.5%; before decision 0412 (the binder with bugs 18 to 20 fixed, binding format 8) it bound std 78.8% and third party 76.9% of the same set.

Bindings regenerate automatically on the first build with 0.35.0.

## Standard library

- **std/x509** (new): parse and verify certificates as Go's crypto/x509 (names, validity, keys, SANs, constraints, usages, every extension; `verify` with Go's error texts; `verify_hostname`, `system_roots`), and create certificates, requests and CRL parsing (`create_certificate`, `self_signed` for development, `create_request`); Ed25519 and RSA certificates and requests are byte for byte Go's. Against Go: `parse_pem` of a three certificate chain 1.183 of Go's time, `verify` 1.002. std/tls gains `peer_certificates()`.
- **std/crypto:** authenticated encryption (`Aead` AES-GCM and ChaCha20-Poly1305, `seal_random`, `open_random`, explicit-nonce `seal` and `open`) and HKDF over any `Hash`, checked against Go's tests and Wycheproof; Ed25519 key generation, signing and verification on Go's code: signing from an expanded key 0.65 of Go's time, from the seed 1.185 (was 1.812); `ed25519_sign` also takes Go's 64 byte private key; PKCS #8 `marshal_private_key`.
- **std/template:** Go's html/template as the html mode (decision 0408): `parse_html` escapes every action for its HTML, attribute, URL, JavaScript or CSS context; `template.html`, `css`, `js`, `jsstr`, `url`, `attr`, `srcset` mark trusted content; custom functions through `parse(funcs:)`. New std/html: `escape_string`, `unescape_string`.
- **std/dns:** MX, TXT, SRV and reverse (PTR) lookups (decision 0417), with `Resolver{server}` to ask one server, native on Linux and macOS and, with Xo's own client, on Windows (decision 0427). Native lookups cache resolv.conf and hosts as Go does: an MX lookup 0.637 of its former instructions, 1.004x Go's.
- **std/rate and std/backoff** (new): golang.org/x/time/rate's token bucket and cenkalti/backoff's exponential backoff with `retry`, both on the Clock they are given, so tests run on the virtual clock.
- **std/crc32 and std/fnv** (new): Go's hash/crc32 (IEEE and Castagnoli) and hash/fnv. CRC-32 runs at Go's speed: on x86-64 IEEE folds with PCLMULQDQ, 0.976x Go (was 8.084x), Castagnoli 0.846x Go (was 1.743x); on arm64 Castagnoli uses CRC32CX.
- **Files:** `walk_dir(fs, dir, visit)` with `WalkStep` (Continue, SkipDir, Stop), Go's filepath.WalkDir over any Fs; `write_atomic(fs, path, data)`; `create_dir_all_mode`.
- **Also:** `toml.encode(v)`; std/cli `float_flag`; log.with (decision 0413); time `truncate`, `round` and a task-free Ticker (decision 0414).

## Compiler and runtime

- **The compiler uses less memory** building itself: the back-end cache's pack segments hold one block per entry and are written as each part finishes (decision 0418): the cold build's footprint with the cache on 10428 to 8371 MB, and the second build's CPU 21.4 to 9.7 s. The native back end's parts own their SSA bodies and drop them as each is emitted (decision 0424): heap peak 10764 to 9837 MB, footprint 7667 to 7287 MB; its output is the same.
- **Profile-guided code layout, stage 1** (decision 0403): `xo prof FILE --layout=xo.layout` turns a CPU profile into a layout file, and `xo build` orders the program's functions by it when the module root has `xo.layout` (`--layout=FILE`, `--layout=off`). Nothing changes for a program without one.

## Fixes

- On Linux the build cache hits again: an unchanged `xo build`, `xo run` or `xo test` no longer builds again (the build recorded `/proc/meminfo`, whose contents change on every read, as an input; every release since 0.28.0 had it).
- **Silent miscompile:** two program modules whose paths end in the same name (`app/a/util`, `app/b/util`) with a same-named function called one body for both on the native and wasm backends (LLVM failed to build). Modules are now named by their full path.
- **`use go`, from the Windows tester** (bugs 18 to 20): a Go function that writes into a `[]byte` argument (Reader.read) lost the data; a function with a parameter of an unexported type broke its whole package's binding; bindings made one at a time missed indirect requires.
- **WebAssembly:** a program using `scope`, `spawn` or `Chan` failed to build with `--backend=wasm` since 0.27.0 (fixed, with a guard against counting such a failure as unsupported); converting a UInt64 to Float32 failed to assemble since 0.32.0.
- **Linux `Chan[Int]` use-after-free:** a word channel's handle could be released before the channel call, found by the race tests on Linux.
- **`url.scheme` is now `"https"`** for requests a TLS server receives, on every backend and over HTTP/1.1 and HTTP/2 (it was empty before; Go leaves it empty).
- **linux/arm64 through a stock `cc`** (GNU as, or clang with its default processor) failed on `crc32x` in 0.34.0.
- **Native windows/amd64:** a fault (an overflow, an index out of range) reaches `task.isolate` and prints a full traceback instead of exiting 70; `Env.hostname`, `Proc.ppid`, UDP truncation, directory symlinks and DNS lookups work; `fsync` of a read only handle succeeds as it does on Linux and macOS; backslash and UNC paths in flags and path variables are read correctly; the PDB GUID comes from the objects' content, so identical builds are identical.

## Xo against Go

The release comparison runs the same programs in Go and in Xo on the release's own build (the v0.35.0 darwin/arm64 archive, Go 1.26.1, darwin/arm64 on an Apple M4 Pro, `xo bench --ab`, 10 interleaved rounds, quiet machine). Ratios are Xo's wall time over Go's; under 1.0 means Xo took less.

- **Compute:** interpreter 0.321, strings 0.460, sort 0.805, collatz 0.898 (was 0.965), sieve 0.946, fib 0.965; n-body 1.059, still slightly slower than Go.
- **Collections:** branch 0.025, iter 0.274, putget 0.595, get 0.618, update 0.616, copymut 0.632 (was 0.675), push 0.731.
- **Concurrency:** mutex 0.279, spawn 0.426, fanout 0.687, ping-pong 0.873, rwmutex 0.901; parallel map 0.988 (was 1.010), now level with Go.
- **Against 0.34.0:** 18 of the 20 workloads are faster than Go; n-body is slower and the parallel map is within noise. The interpreter's ratio moved from 0.291 to 0.321, but building it with the 0.34.0 and 0.35.0 releases and timing the two directly gives 1.028 (0.953 to 1.096), within noise.
- **Builds:** an edit rebuilds in 60 to 70 ms (the collections program 130) against `go build`'s 100 to 110, and a cold build takes 880 to 1100 ms against Go's 1430 to 1520. An unchanged rebuild is served by the run cache in about 10 ms.

## Platform notes

- macOS arm64 is the measured platform unless a line says otherwise; the linux/amd64 and Windows timings are from the owner's offload hosts.
- std's half on the edit link is on for darwin/arm64 and Linux (ELF); windows/amd64 has the section order only. `--release`, `--race`, a `cc` link and programs that `use c` build the whole program as before.
- The debug map (smaller binaries, std's DWARF in the cache) is macOS only.
- Native Windows DNS asks the adapters' DNS servers directly, as Go's pure Go resolver does, so Windows' NRPT and DNS over HTTPS settings are not consulted.

## Known issues

- `--race` with `--backend=llvm` on Linux can report a spurious data race inside the runtime's task free for a program that sends on a channel from a spawned task. The default native backend's `--race` is not affected.