<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/"><channel><title>Fid Changelog</title><description>Every Fid update as it lands, from the seed compiler to the v1.0 syntax.</description><link>https://fid-lang.org</link><item><title>Native Linux executables, one ownership rule, a faster compiler</title><link>https://fid-lang.org/changelog/nov-7-15-native-linux-ownership</link><guid isPermaLink="true">https://fid-lang.org/changelog/nov-7-15-native-linux-ownership</guid><description>fid emit writes static Linux executables for x86-64, ARM64 and RISC-V, assignment of a Vec, HashMap or str gives an independent value, values are freed at the end of their scope, native async works again, the compiler compiles itself in about 40 s, and bare-metal kernels boot under QEMU. v0.8.0-unstable is on the releases page.</description><pubDate>Sun, 15 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Nine days of work on &lt;code&gt;fid&lt;/code&gt;, the self-hosted compiler. The v0.8.0-unstable installer was built on Nov 10 and holds the work up to that day; everything after it is on the main branch. The stable v1.0.0 release is still planned for December. The full suite was last run on Nov 2 with the frozen Rust compiler and has not been rerun with &lt;code&gt;fid&lt;/code&gt;; each change below was checked with its own tests.&lt;/p&gt;
&lt;h2 id=&quot;native-backends&quot;&gt;Native backends&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Linux without a C compiler&lt;/strong&gt;: &lt;code&gt;fid emit --target x86_64-linux&lt;/code&gt;, &lt;code&gt;aarch64-linux&lt;/code&gt; or &lt;code&gt;riscv64-linux&lt;/code&gt; writes a static ELF executable. One machine layer serves the three targets, with its own register allocator and a runtime built on system calls (threads, tasks, channels, sockets, processes). On Nov 9, 272, 273 and 271 of 317 suite programs matched the interpreter (ARM64 and RISC-V under QEMU).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Windows&lt;/strong&gt;: the native backend has a linear-scan register allocator for integer and &lt;code&gt;xmm&lt;/code&gt; registers, tasks switch on their own stacks, and sockets wait through IOCP. &lt;code&gt;fid emit --nat&lt;/code&gt; puts Windows on the same machine layer as Linux (opt-in; 301 of 338 suite programs).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Native &lt;code&gt;async&lt;/code&gt;/&lt;code&gt;await&lt;/code&gt; works&lt;/strong&gt;: it broke in builds of Nov 9 afternoon and was fixed the same evening.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Bare metal&lt;/strong&gt; (Nov 15): &lt;code&gt;fid emit --bare&lt;/code&gt; and &lt;code&gt;--boot&lt;/code&gt; write an x86-64 Multiboot kernel that boots under QEMU; 10 of 10 bare tests pass.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;WebAssembly&lt;/strong&gt; (Nov 15): &lt;code&gt;fid wasm&lt;/code&gt; modules validate and run under WASI; 316 of 344 suite programs match &lt;code&gt;fid run&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;macOS&lt;/strong&gt; (Nov 15): native Mach-O executables are written and checked for structure. They have not been run on a Mac.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fid ccompile --target&lt;/code&gt; cross-compiles through C with &lt;code&gt;zig cc&lt;/code&gt; for &lt;code&gt;aarch64-linux&lt;/code&gt;, &lt;code&gt;riscv64-linux&lt;/code&gt;, &lt;code&gt;x86_64-macos&lt;/code&gt;, &lt;code&gt;aarch64-macos&lt;/code&gt; and &lt;code&gt;wasm32-wasi&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;memory-and-values&quot;&gt;Memory and values&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;One ownership rule&lt;/strong&gt; (proposal 0004): a variable owns its value and the value is dropped at the end of its scope; keeping a value takes an owner; parameters are borrowed. Strings, &lt;code&gt;Vec&lt;/code&gt; buffers and Boxes are reference-counted.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Value semantics&lt;/strong&gt;: &lt;code&gt;var b = a&lt;/code&gt; on a &lt;code&gt;Vec&lt;/code&gt;, &lt;code&gt;HashMap&lt;/code&gt; or &lt;code&gt;str&lt;/code&gt; gives an independent value, shared until the first write. Since Nov 15, copying a struct also separates its &lt;code&gt;Vec&lt;/code&gt; fields.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;&amp;#x26;v[i]&lt;/code&gt; and &lt;code&gt;&amp;#x26;mut v[i]&lt;/code&gt; are the element’s address, so writes through them reach the container.&lt;/li&gt;
&lt;li&gt;A leak gate (&lt;code&gt;scripts/leak-check.sh&lt;/code&gt;) checks that test programs free every block.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;the-language&quot;&gt;The language&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Literals of generic structs&lt;/strong&gt; of your own work (Nov 15): &lt;code&gt;Pair { first: 1, second: &quot;a&quot; }&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Match exhaustiveness&lt;/strong&gt; covers generic enums such as &lt;code&gt;Option&amp;#x3C;T&gt;&lt;/code&gt; and no longer counts a guarded arm as covering anything.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;--borrowck=warn&lt;/code&gt; prints its warnings, and the borrow checker follows casts and nested field writes.&lt;/li&gt;
&lt;li&gt;A match guard on a &lt;code&gt;@secret&lt;/code&gt; value taints its arm, and file and socket writes are sinks.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;5e3&lt;/code&gt; and &lt;code&gt;2E-3&lt;/code&gt; lex as floats.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;the-optimizer-and-its-checks&quot;&gt;The optimizer and its checks&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;A rule-based mid-end with an e-graph, constant propagation, loop-invariant code motion and tail recursion into loops, plus an IR verifier that can run after every pass.&lt;/li&gt;
&lt;li&gt;The 108 integer rewrite rules are proved with z3, and the instruction encoders are checked against clang’s assembler (1,181 forms, no mismatch).&lt;/li&gt;
&lt;li&gt;&lt;code&gt;tests/conformance/&lt;/code&gt; adds 104 programs, each checking one rule of the language reference.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;speed&quot;&gt;Speed&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The compiler’s C is split into units and built at &lt;code&gt;-O2&lt;/code&gt;. Compiling itself to C takes about 40 s (Nov 15), down from about 133 s on Nov 6.&lt;/li&gt;
&lt;li&gt;The fixpoint was verified again on Nov 8 (stage 2 == stage 3, 67 MB of C). Later changes were checked on one-stage builds.&lt;/li&gt;
&lt;li&gt;A CI workflow builds a change’s compiler and its base commit’s on one runner and compares the benchmarks.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;standard-library-and-tools&quot;&gt;Standard library and tools&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;163 modules. New: brotli and zstd decoders, &lt;code&gt;decimal&lt;/code&gt;, &lt;code&gt;protobuf&lt;/code&gt;, &lt;code&gt;tz&lt;/code&gt; (the IANA database), &lt;code&gt;wss&lt;/code&gt;, Unicode normalization (NFC, NFD, NFKC, NFKD), a set of OS-development modules (&lt;code&gt;elf&lt;/code&gt;, &lt;code&gt;acpi&lt;/code&gt;, &lt;code&gt;pci&lt;/code&gt;, &lt;code&gt;virtio&lt;/code&gt;, &lt;code&gt;multiboot&lt;/code&gt;, &lt;code&gt;fdt&lt;/code&gt;, &lt;code&gt;uart&lt;/code&gt;, &lt;code&gt;pmm&lt;/code&gt;, &lt;code&gt;slab&lt;/code&gt;), &lt;code&gt;safetensors&lt;/code&gt;, &lt;code&gt;bpe&lt;/code&gt; and &lt;code&gt;infer&lt;/code&gt; for model inference, and &lt;code&gt;gltf&lt;/code&gt; and &lt;code&gt;tiled&lt;/code&gt; loaders.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;fid lint --perf&lt;/code&gt; warns about loop hazards, and &lt;code&gt;fid explain file.fd&lt;/code&gt; lists which run-time checks the compiler removed or kept, and why (&lt;code&gt;--alloc&lt;/code&gt;: the allocation sites and why each is on the heap).&lt;/li&gt;
&lt;li&gt;The repository gained a book, a cookbook and guides for readers coming from Rust, Go, Zig and C.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;still-open&quot;&gt;Still open&lt;/h2&gt;
&lt;p&gt;The full suite has not been run with &lt;code&gt;fid&lt;/code&gt; as the compiler under test. Native code is slower than code built through C. A &lt;code&gt;Vec&lt;/code&gt; passed to a spawned call is shared with the caller, and writes from both threads are not detected. macOS output has not been run on a Mac, SPIR-V output does not validate, and &lt;code&gt;build --native&lt;/code&gt; (the old PIR path) crashes. The current list is on the &lt;a href=&quot;/docs/feature-status&quot;&gt;Feature Status&lt;/a&gt; page.&lt;/p&gt;</content:encoded></item><item><title>Generics, borrowed strings, safety rules with evidence</title><link>https://fid-lang.org/changelog/nov-4-6-language-depth</link><guid isPermaLink="true">https://fid-lang.org/changelog/nov-4-6-language-depth</guid><description>Generics infer or reject, if and match are values, @cfg filters items, the compiler frees locals it can prove finished, the borrow checker catches iterator invalidation, spawn checks @send, owned and borrowed strings make a scoped HTTP server safe, and 17 safety rules each have negative tests and fid qualify evidence. Not in a release yet.</description><pubDate>Fri, 06 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Three days of work on &lt;code&gt;fid&lt;/code&gt;, the self-hosted compiler, on the main branch. None of it is in a release: v1.0.0 stable is still planned for December, and &lt;code&gt;fid version&lt;/code&gt; still prints &lt;code&gt;0.1.0&lt;/code&gt;. Each change below was checked with its own tests on the interpreter, the C backend and the native Windows backend. The full suite was last run on Nov 2 and has not been rerun with this compiler.&lt;/p&gt;
&lt;h2 id=&quot;the-language&quot;&gt;The language&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Generics&lt;/strong&gt; (proposal 0002): type arguments are inferred at each call or the call is an error naming the parameter; bounds &lt;code&gt;T: A + B&lt;/code&gt; are checked; a turbofish &lt;code&gt;f::&amp;#x3C;T&gt;()&lt;/code&gt; must give as many type arguments as the function has. Generic enums and generic &lt;code&gt;impl&lt;/code&gt; blocks are typed per receiver. Literals of generic structs of your own are still rejected.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;if&lt;/code&gt; and &lt;code&gt;match&lt;/code&gt; are values&lt;/strong&gt;, also as a function’s last statement.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@cfg&lt;/code&gt;&lt;/strong&gt;: &lt;code&gt;windows&lt;/code&gt;, &lt;code&gt;linux&lt;/code&gt;, &lt;code&gt;macos&lt;/code&gt;, &lt;code&gt;platform = &quot;...&quot;&lt;/code&gt;, &lt;code&gt;os = &quot;...&quot;&lt;/code&gt;, arch, &lt;code&gt;debug&lt;/code&gt; and &lt;code&gt;release&lt;/code&gt; keep or drop functions and structs. The platform is the host’s.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Integer &lt;code&gt;HashMap&lt;/code&gt; keys&lt;/strong&gt; work (they crashed before); 0 and -1 are ordinary keys.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Higher-order effects&lt;/strong&gt;: a function that takes a function value gets the effects of the function passed at each call, so &lt;code&gt;apply(pure_fn, x)&lt;/code&gt; can be called from a &lt;code&gt;!{}&lt;/code&gt; function.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The language reference&lt;/strong&gt; (&lt;code&gt;docs/reference/reference.md&lt;/code&gt; in the repository) documents what &lt;code&gt;fid&lt;/code&gt; accepts, with the compiler function behind each rule.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;memory-and-borrowing&quot;&gt;Memory and borrowing&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The compiler now &lt;strong&gt;frees locals it can prove are finished&lt;/strong&gt;: &lt;code&gt;Vec&lt;/code&gt; and &lt;code&gt;HashMap&lt;/code&gt; locals, a &lt;code&gt;Vec&amp;#x3C;str&gt;&lt;/code&gt; or &lt;code&gt;Vec&amp;#x3C;Vec&amp;#x3C;T&gt;&gt;&lt;/code&gt; with the elements it owns, collections declared in a &lt;code&gt;region&lt;/code&gt; at its end, and string temporaries. There is still no GC; anything else lives until exit.&lt;/li&gt;
&lt;li&gt;The borrow checker rejects &lt;strong&gt;changing a &lt;code&gt;Vec&lt;/code&gt; while a &lt;code&gt;for&lt;/code&gt; loop walks it&lt;/strong&gt;, and &lt;strong&gt;assigning a field of a borrowed struct&lt;/strong&gt;. Trait impl bodies and &lt;code&gt;&amp;#x26;v[i]&lt;/code&gt; are checked too. File, socket, process and clock runtime calls count as &lt;code&gt;IO&lt;/code&gt; or &lt;code&gt;Net&lt;/code&gt; effects.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Owned and borrowed strings&lt;/strong&gt;: &lt;code&gt;str&lt;/code&gt; is owned, &lt;code&gt;&amp;#x26;str&lt;/code&gt; borrowed. A &lt;code&gt;str&lt;/code&gt; field of a &lt;code&gt;@scoped&lt;/code&gt; struct reads as &lt;code&gt;&amp;#x26;str&lt;/code&gt; and cannot be returned as &lt;code&gt;str&lt;/code&gt; or stored; &lt;code&gt;str_clone&lt;/code&gt; makes an owned copy. &lt;code&gt;http_serve_scoped&lt;/code&gt; uses this to free each request after its response, and is no longer &lt;code&gt;@unsafe&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;concurrency&quot;&gt;Concurrency&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Every argument of a spawned call must be &lt;strong&gt;&lt;code&gt;@send&lt;/code&gt;&lt;/strong&gt;; a struct of &lt;code&gt;@send&lt;/code&gt; fields is &lt;code&gt;@send&lt;/code&gt;; references and raw pointers are not.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;parallel { }&lt;/code&gt; branches run on threads&lt;/strong&gt;: &lt;code&gt;x = f(...)&lt;/code&gt; branches, and branches that read only word-sized locals.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;async fn&lt;/code&gt; with &lt;code&gt;f64&lt;/code&gt; or struct arguments&lt;/strong&gt; runs as a task in the interpreter and through C. Native async programs still crash.&lt;/li&gt;
&lt;li&gt;Per-thread free lists in the native runtime and per-thread arenas in the C runtime (no multi-thread stress test yet).&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;safety-rules&quot;&gt;Safety rules&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;@no-alloc&lt;/code&gt; sees method calls (&lt;code&gt;.push()&lt;/code&gt;), &lt;code&gt;Vec::new()&lt;/code&gt; and string &lt;code&gt;+&lt;/code&gt;; &lt;code&gt;@no-indirect&lt;/code&gt; rejects calls through function parameters; &lt;code&gt;@firmware&lt;/code&gt; rejects OS runtime calls; &lt;code&gt;@gas&lt;/code&gt; counts literal loop trip counts; &lt;code&gt;@tainted&lt;/code&gt; works on parameters.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;17 rules, each with a negative test&lt;/strong&gt; (&lt;code&gt;docs/reference/safety-rules.md&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;fid qualify file.fd -o out.json&lt;/code&gt;&lt;/strong&gt; writes the evidence: compiler and source hashes, the check result, the annotated functions, and each rule with its requirement and tests. It always reports &lt;code&gt;NOT_QUALIFIED&lt;/code&gt;. It is evidence for review, not a certificate, and Fid is not suitable for medical, automotive or avionics use.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;speed-and-tooling&quot;&gt;Speed and tooling&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fid emit&lt;/code&gt; runs a small IR optimizer: inlining of small single-block functions, constant folding, dead code removal. Native code still has no full register allocator.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;core.fd&lt;/code&gt; is type-checked once per compiler and core version; the build cache evicts past 64 files or 1 GB.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;bench/run.sh&lt;/code&gt; and &lt;code&gt;bench/check.sh&lt;/code&gt; flag slowdowns against a baseline (not in CI).&lt;/li&gt;
&lt;li&gt;Self-compile to C takes about 133 s (type check 59 s); the stage 2 and stage 3 C are byte-identical, 49 MB.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;written-not-run-yet&quot;&gt;Written, not run yet&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;fid emit --checked-alloc&lt;/code&gt; (guard pages for native builds), &lt;code&gt;scripts/sanitize.sh&lt;/code&gt; (ASan/UBSan through C), and a nightly fuzzing script.&lt;/p&gt;
&lt;h2 id=&quot;still-open&quot;&gt;Still open&lt;/h2&gt;
&lt;p&gt;Value semantics: copy-on-write for &lt;code&gt;Vec&lt;/code&gt; and &lt;code&gt;HashMap&lt;/code&gt; is written but off, because the compiler runs out of memory compiling itself with it, so &lt;code&gt;var b = a&lt;/code&gt; on a &lt;code&gt;Vec&lt;/code&gt; still aliases. Also open: native async, a full register allocator, macOS, native ELF, ARM64/RISC-V/WebAssembly backends, and bare metal (&lt;code&gt;emit --bare&lt;/code&gt; panics).&lt;/p&gt;</content:encoded></item><item><title>One integer meaning, sound builds, a real allocator</title><link>https://fid-lang.org/changelog/session-36-integers-allocator</link><guid isPermaLink="true">https://fid-lang.org/changelog/session-36-integers-allocator</guid><description>Integers are now checked at their declared width on every backend, p_free panics on double-free and invalid frees, a size-class allocator plus an escape pass took the dropped-Vec benchmark from 544 MB to 6 MB, and self-hosted type checking went from 205 s to 15 s.</description><pubDate>Sun, 01 Nov 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Session 36 was a semantics-and-soundness session: fewer ways for the three backends to disagree, and a real memory story underneath them.&lt;/p&gt;
&lt;h2 id=&quot;integers-mean-one-thing-now&quot;&gt;Integers mean one thing now&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;add&lt;/code&gt;/&lt;code&gt;sub&lt;/code&gt;/&lt;code&gt;mul&lt;/code&gt;/&lt;code&gt;neg&lt;/code&gt; are &lt;strong&gt;checked at the declared width&lt;/strong&gt; on the interpreter, C, and native paths: &lt;code&gt;i8&lt;/code&gt; overflows at &lt;code&gt;i8&lt;/code&gt;, not at &lt;code&gt;i64&lt;/code&gt;. &lt;code&gt;@wrapping&lt;/code&gt; wraps at the declared width, division by zero always panics, and &lt;code&gt;u64&lt;/code&gt; is genuinely unsigned. (Lowering used to carry &lt;code&gt;i64&lt;/code&gt; for every integer op, which was the root cause of most backend disagreements.)&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;memory-actually-managed&quot;&gt;Memory, actually managed&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;p_free&lt;/code&gt; is honest&lt;/strong&gt;: double-free and freeing a pointer that is not a live heap block panic on all backends. It already caught a real leak: &lt;code&gt;rc.fd&lt;/code&gt; counters allocated through plain &lt;code&gt;malloc&lt;/code&gt; were never freed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Size-class allocator&lt;/strong&gt; behind &lt;code&gt;malloc&lt;/code&gt;/&lt;code&gt;free&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Automatic &lt;code&gt;Vec&lt;/code&gt; reclamation&lt;/strong&gt;: an IR escape pass frees local &lt;code&gt;Vec&lt;/code&gt;s that provably never escape: the dropped-Vec benchmark went from 544 MB peak to 6 MB.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;faster-self-hosting&quot;&gt;Faster self-hosting&lt;/h2&gt;
&lt;p&gt;Self-hosted type checking of the compiler went from about 205 s to 15 s, with &lt;code&gt;Vec_get&lt;/code&gt;/&lt;code&gt;Vec_len&lt;/code&gt; inlined natively.&lt;/p&gt;
&lt;h2 id=&quot;bugs-that-were-invisible&quot;&gt;Bugs that were invisible&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;p_system&lt;/code&gt; crashed every native program on return; a &lt;code&gt;pert_str_hash&lt;/code&gt; edge case could lose &lt;code&gt;HashMap&lt;/code&gt; keys near page ends; hex literals above &lt;code&gt;i64::MAX&lt;/code&gt; read as 0 on &lt;code&gt;fidesc&lt;/code&gt;; native panics now actually print (via a vectored exception handler for stack overflow and invalid access). The Rust suite sits at interp 286/286, C 285/285, PE 287/287, with 66/66 expected-fail tests correctly rejected, and every stdlib module now compiles standalone in CI (&lt;code&gt;scripts/check-stdlib.sh&lt;/code&gt;).&lt;/p&gt;</content:encoded></item><item><title>The native emitter reproduces itself bit-for-bit</title><link>https://fid-lang.org/changelog/native-emit-fixpoint</link><guid isPermaLink="true">https://fid-lang.org/changelog/native-emit-fixpoint</guid><description>fid emit compiles the entire 104K-line compiler straight to an .exe (no assembler, no linker, no C compiler), and the output is byte-identical to the emitter that produced it. It is also faster than the C build.</description><pubDate>Fri, 30 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The deepest self-hosting check there is: a compiler that emits machine code, applied to itself, producing the same machine code. Session 35 closed that loop.&lt;/p&gt;
&lt;h2 id=&quot;the-fixpoint-natively&quot;&gt;The fixpoint, natively&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;fid-n5.exe emit compiler/main.fd&lt;/code&gt; → &lt;code&gt;fid-n6.exe&lt;/code&gt;, &lt;strong&gt;byte-identical&lt;/strong&gt; (12,304,896 bytes). The natively-emitted compiler reproduces itself bit-for-bit: no C toolchain anywhere in the loop.&lt;/li&gt;
&lt;li&gt;Cross-emitter parity too: the native-emit binary and the C-compiled binary are byte-for-byte identical on the same source.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Faster than the C path&lt;/strong&gt;: &lt;code&gt;dump-c&lt;/code&gt; on the full compiler in 3m21s vs 4m21s for the C-built compiler. &lt;code&gt;fid emit&lt;/code&gt; on a typical test file runs about 50 ms of actual codegen.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;speed-work-in-the-pe-emitter&quot;&gt;Speed work in the PE emitter&lt;/h2&gt;
&lt;p&gt;Bulk &lt;code&gt;strlen&lt;/code&gt;/&lt;code&gt;memcpy&lt;/code&gt; string stubs (was byte loops), &lt;code&gt;rep movsq&lt;/code&gt; struct copies, word-at-a-time hashing, a store→load forwarding peephole (−1,468 loads in a small exe), &lt;code&gt;cmp&lt;/code&gt;+&lt;code&gt;jcc&lt;/code&gt; fusion, slot reuse that shrank stack frames from ~140 KB to ~1.28 KB max, and inlining of &lt;code&gt;p_vec_len&lt;/code&gt;/&lt;code&gt;p_map_len&lt;/code&gt;/&lt;code&gt;*_is_empty&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&quot;correctness-catches&quot;&gt;Correctness catches&lt;/h2&gt;
&lt;p&gt;Windows &lt;strong&gt;guard-page stack probes&lt;/strong&gt; for frames over 4 KB (the missing piece behind deep-recursion crashes), &lt;code&gt;p_string_starts_with&lt;/code&gt; actually compares now (it was a stub returning true), and emit is deterministic: free-slot order no longer depends on &lt;code&gt;HashMap&lt;/code&gt; iteration.&lt;/p&gt;</content:encoded></item><item><title>The self-hosted compiler is now the release compiler</title><link>https://fid-lang.org/changelog/self-hosted-release-compiler</link><guid isPermaLink="true">https://fid-lang.org/changelog/self-hosted-release-compiler</guid><description>fid.exe (the compiler written in Fid) is what the installer ships. It matches the Rust compiler on all 302 test programs through run and on 242/243 through ccompile, the release bootstrap checks the fixpoint on every build, and a Fides runtime for the PE backend runs every test natively on Windows.</description><pubDate>Tue, 27 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Sessions 31-34 crossed the line that turns self-hosting from a party trick into the product: &lt;strong&gt;the compiler you download is the compiler written in Fid.&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;what-shipped&quot;&gt;What shipped&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;fid.exe&lt;/code&gt; is the release binary.&lt;/strong&gt; The Windows installer now ships the self-hosted compiler (&lt;code&gt;release/fid.exe&lt;/code&gt;, built by &lt;code&gt;RELEASE=1 ./scripts/bootstrap.sh&lt;/code&gt;) with the Rust bootstrap compiler beside it as &lt;code&gt;fidesc.exe&lt;/code&gt;. v1.0.0’s &lt;code&gt;fides.exe&lt;/code&gt; name is retired.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Release bootstrap with fixpoint check&lt;/strong&gt;: three stages, stage 2 == stage 3 verified byte-for-byte (~38 MB of C) on every release build, then the compiler is installed and smoke-tested from an installed layout.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Test parity&lt;/strong&gt;: &lt;code&gt;fid run&lt;/code&gt; matches &lt;code&gt;fidesc&lt;/code&gt; on all 302 test programs and all 10 examples; &lt;code&gt;fid ccompile&lt;/code&gt; on 242/243 (&lt;code&gt;test_sqlite&lt;/code&gt; needs libsqlite3; the Rust compiler fails it the same way); all expected-fail tests rejected.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;A Fides runtime for the PE backend&lt;/strong&gt;: &lt;code&gt;stdlib/pe_runtime/&lt;/code&gt; (the &lt;code&gt;p_X&lt;/code&gt; → &lt;code&gt;pert_X&lt;/code&gt;/&lt;code&gt;pe_*&lt;/code&gt; builtins merged into every &lt;code&gt;emit&lt;/code&gt;) means native Windows executables now run the entire test suite (threads, channels, &lt;code&gt;select&lt;/code&gt;, async, tensors, JSON, files) with no C compiler anywhere in the loop.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reproducible and incremental builds&lt;/strong&gt;: an artifact store keyed on content hashes kills stale-binary bugs; &lt;code&gt;fid ccompile --inc&lt;/code&gt; builds one translation unit per module and caches the objects.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;fixes-that-made-parity-possible&quot;&gt;Fixes that made parity possible&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;@conserve&lt;/code&gt; now actually rejects non-conserving calls (it used to only check effects), second &lt;code&gt;impl&lt;/code&gt; blocks in imported modules are kept, &lt;code&gt;extern &quot;C&quot; link &quot;lib&quot;&lt;/code&gt; libraries are linked on the C path, and tests that printed timings or random values were made deterministic so the suites can be compared byte-for-byte.&lt;/p&gt;</content:encoded></item><item><title>Soundness passes: escape analysis, sound security annotations, verified constant-time</title><link>https://fid-lang.org/changelog/hardening-sessions-27-30</link><guid isPermaLink="true">https://fid-lang.org/changelog/hardening-sessions-27-30</guid><description>Four hardening sessions in one sweep: references became second-class citizens (they can no longer dangle), the taint/zeroize/secret checks were made sound, a post-codegen verifier scans final x86-64 assembly for constant-time violations, and the branches consolidated.</description><pubDate>Sun, 25 Oct 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Between sessions 27 and 30 the compiler stopped trusting its own good intentions and started proving things: about user code and about itself.&lt;/p&gt;
&lt;h2 id=&quot;references-can-no-longer-dangle&quot;&gt;References can no longer dangle&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Second-class references&lt;/strong&gt; (&lt;code&gt;src/escape.rs&lt;/code&gt;, &lt;code&gt;compiler/escape.fd&lt;/code&gt;): a &lt;code&gt;&amp;#x26;T&lt;/code&gt; / &lt;code&gt;&amp;#x26;mut T&lt;/code&gt; can no longer be stored in a struct, returned from a function’s locals, sent to a task, or captured by an escaping closure. The escape check runs in both compilers, so a reference that would outlive its referent is a compile error everywhere, not just on one backend.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;Vec&amp;#x3C;f64&gt;&lt;/code&gt; reads and &lt;code&gt;f64&lt;/code&gt; returns&lt;/strong&gt; fixed on all three backends on the way, and the fixpoint was re-verified after the change.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;security-annotations-made-sound&quot;&gt;Security annotations made sound&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@tainted&lt;/code&gt;&lt;/strong&gt; became real data-flow tracking: taint propagates through expressions until a sanitizer clears it or it hits a sink (SQL, shell, HTML, path), which is a compile error.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@zeroize&lt;/code&gt;&lt;/strong&gt; now wipes heap data too, not just stack slots: PE output verified byte-for-byte on the affected tests.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Post-codegen constant-time verification&lt;/strong&gt;: after the peephole stage, &lt;code&gt;verify_constant_time_asm&lt;/code&gt; scans the &lt;em&gt;final&lt;/em&gt; x86-64 assembly of a &lt;code&gt;@constant_time&lt;/code&gt; function for conditional/indirect jumps, memory &lt;code&gt;cmov&lt;/code&gt;, indexed memory ops, variable-latency ops, and calls into non-CT functions. Violations are build errors: the check inspects what the CPU will actually run, not what the IR hoped for. (ELF path today; PE/ARM64/RISC-V coverage is planned.)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;cast_arg&lt;/code&gt; ABI repair&lt;/strong&gt; in both C codegens heals &lt;code&gt;&amp;#x26;mut Vec&lt;/code&gt; → &lt;code&gt;Vec&lt;/code&gt; forwards, and &lt;code&gt;cl.exe&lt;/code&gt; linking was fixed on Windows (&lt;code&gt;cmd /C&lt;/code&gt; quote-stripping).&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;branch-consolidation&quot;&gt;Branch consolidation&lt;/h2&gt;
&lt;p&gt;&lt;code&gt;release-infra&lt;/code&gt; merged into &lt;code&gt;main&lt;/code&gt;; 92 &lt;code&gt;&amp;#x26;mut&lt;/code&gt; call sites removed; &lt;code&gt;str_equal&lt;/code&gt; replaced by plain &lt;code&gt;==&lt;/code&gt;; the bootstrap fixpoint re-verified byte-for-byte afterward.&lt;/p&gt;</content:encoded></item><item><title>Resumable effect handlers, structured concurrency, graph-coloring regalloc</title><link>https://fid-lang.org/changelog/resumable-effects</link><guid isPermaLink="true">https://fid-lang.org/changelog/resumable-effects</guid><description>Effect handlers gained real continuations (do + resume), spawn scope joins every task at the brace, cancel scope stops them, and async I/O is now just another effect. Plus a Chaitin-Briggs register allocator and deterministic PE output.</description><pubDate>Sun, 13 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The concurrency and effects story is complete at the language level. Everything below is in &lt;code&gt;main&lt;/code&gt; and covered by tests (&lt;code&gt;test_effect_resume&lt;/code&gt;, &lt;code&gt;test_effect_noresume&lt;/code&gt;, &lt;code&gt;test_effect_compose&lt;/code&gt;, &lt;code&gt;test_spawn_scope&lt;/code&gt;, &lt;code&gt;test_cancellation&lt;/code&gt;).&lt;/p&gt;
&lt;h2 id=&quot;effect-handlers-with-continuations&quot;&gt;Effect handlers with continuations&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;resume(cont, value)&lt;/code&gt;&lt;/strong&gt;: a handler arm can now continue the &lt;code&gt;handle&lt;/code&gt; block from the point of the &lt;code&gt;do&lt;/code&gt;, with &lt;code&gt;value&lt;/code&gt; as the result of the effect. New keyword, AST node, parser, type checker, and lowering.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Continuation capture at lowering time&lt;/strong&gt;: the statements after a &lt;code&gt;do&lt;/code&gt; are captured as a continuation closure (lambda-lifted, called through &lt;code&gt;CallPtr&lt;/code&gt;), so there is no runtime scheduler and no hidden allocation behind an effect.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No resume means no continuation&lt;/strong&gt;: a handler that returns without &lt;code&gt;resume&lt;/code&gt; drops the rest of the block, which gives cooperative cancellation for free.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Chaining&lt;/strong&gt;: multiple &lt;code&gt;do&lt;/code&gt; statements in one block each capture their own continuation; nested handlers resolve at the nearest enclosing &lt;code&gt;handle&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;structured-concurrency-and-cancellation&quot;&gt;Structured concurrency and cancellation&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;spawn scope { … }&lt;/code&gt;&lt;/strong&gt;: a scope-owned executor runs every &lt;code&gt;spawn&lt;/code&gt; inside the block and joins them all at the closing brace. Tasks cannot outlive their scope.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;cancel scope;&lt;/code&gt;&lt;/strong&gt;: cancels all pending tasks in the enclosing scope, backed by the new &lt;code&gt;p_executor_cancel&lt;/code&gt; runtime builtin.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;do Cancel.stop()&lt;/code&gt;&lt;/strong&gt;: cooperative cancellation through effect dispatch.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No function coloring, verified&lt;/strong&gt;: any function is callable from synchronous code, a spawned task, or a handler body; there is no &lt;code&gt;async fn&lt;/code&gt; / &lt;code&gt;fn&lt;/code&gt; split to maintain.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;async-io-as-effects&quot;&gt;Async I/O as effects&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;do IO.read&lt;/code&gt; / &lt;code&gt;do IO.write&lt;/code&gt; and &lt;code&gt;do Net.accept&lt;/code&gt; dispatch to handlers and resume with the result. A request handler reads as straight-line code even though every I/O point is a suspension.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;compiler-and-backends&quot;&gt;Compiler and backends&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Graph-coloring register allocator&lt;/strong&gt; (Chaitin-Briggs) added alongside linear scan, with function alignment for the native backends.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Deterministic PE code generation&lt;/strong&gt;: the Windows emitter now produces identical bytes for identical input, build after build.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cached parsing&lt;/strong&gt;: repeated compiles of unchanged modules skip the parser.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Struct globals in the C backend&lt;/strong&gt;: initialized correctly as inline values.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;standard-library&quot;&gt;Standard library&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;104 modules. New since 1.0: &lt;code&gt;arena&lt;/code&gt; (bump allocator with O(1) bulk free), &lt;code&gt;template&lt;/code&gt; (typed template rendering), &lt;code&gt;plot&lt;/code&gt; (SVG line/bar/scatter plots), &lt;code&gt;data&lt;/code&gt; (CSV loading and schema inference), and &lt;code&gt;game&lt;/code&gt; (an ECS-plus-frame-arena engine framework in which Fid is its own scripting language).&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Bootstrap fixpoint verified byte-for-byte</title><link>https://fid-lang.org/changelog/fixpoint-verified</link><guid isPermaLink="true">https://fid-lang.org/changelog/fixpoint-verified</guid><description>Five bootstrap generations, and the fourth and fifth produce identical C output: fides-c4.c == fides-c5.c, 29,763,762 bytes. The self-hosted compiler now fully compiles itself. Seven Rust-to-Fid gaps closed on the way.</description><pubDate>Sat, 12 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The milestone every self-hosted compiler aims for: the compiler compiles itself, the result compiles itself again, and the output stops changing.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;fides-c3.exe → fides-c.exe (gen 1) → fides-c2.exe (gen 2)
→ fides-c3_new.exe (gen 3) → fides-c4.exe (gen 4) → fides-c5.exe (gen 5)

cmp fides-c4.c fides-c5.c → identical (29,763,762 bytes)
&lt;/code&gt;&lt;/pre&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;The fixpoint converges at generation 4/5.&lt;/strong&gt; The self-hosted compiler produces byte-identical C when it compiles itself, which is the strongest stability check a compiler can pass on its own code.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Self-compilation runs clean end to end.&lt;/strong&gt; Three issues that stood between 1.0 and the fixpoint were closed: library-import detection is now line-aware, struct and enum globals are emitted as inline values in the C backend, and &lt;code&gt;stdlib/time.fd&lt;/code&gt; parses again.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Seven Rust-to-Fid gaps closed&lt;/strong&gt;: bounds-aware &lt;code&gt;str_substring&lt;/code&gt; in &lt;code&gt;pir.fd&lt;/code&gt;, a real &lt;code&gt;--lto&lt;/code&gt; mode in &lt;code&gt;opt.fd&lt;/code&gt;, &lt;code&gt;DynCall&lt;/code&gt; and &lt;code&gt;TryUnwrap&lt;/code&gt; code generation in &lt;code&gt;codegen_c.fd&lt;/code&gt;, inline struct globals, the standalone Linux x86-64 code generator ported to &lt;code&gt;compiler/x86.fd&lt;/code&gt;, 19 additional CLI commands in &lt;code&gt;main.fd&lt;/code&gt; (debug, autopsy, gpu, link, parse-header, profile, qualify, repl, replay, sbom, spdx, …), and autograd plus PRNG support in &lt;code&gt;interp.fd&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;New IR instruction&lt;/strong&gt;: &lt;code&gt;StructCopy(dst, src, ty)&lt;/code&gt; for struct-by-value copies.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Updated stats&lt;/strong&gt;: 52 compiler modules, 100,934 LOC of Fid; 104 standard library modules; 304 test programs.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>v1.0.0: First stable release</title><link>https://fid-lang.org/changelog/v1-0-0</link><guid isPermaLink="true">https://fid-lang.org/changelog/v1-0-0</guid><description>Fid 1.0 is out. The compiler is self-hosted (50 modules, 93,605 LOC), 3 bootstrap generations are verified, a 2.5 MB Windows installer ships on GitHub Releases, and 265/265 unit tests pass with zero skipped.</description><pubDate>Wed, 09 Sep 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The first stable release of the Fid programming language. The self-hosted compiler, Windows installer, and standard library are all production-ready for normal Fid programs.&lt;/p&gt;
&lt;h2 id=&quot;download&quot;&gt;Download&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Windows installer:&lt;/strong&gt; &lt;code&gt;Fides-Setup-1.0.0.exe&lt;/code&gt; (2.5 MB) from &lt;a href=&quot;https://github.com/pledgeandgrow/fid/releases/tag/v1.0.0&quot;&gt;GitHub Releases: v1.0.0&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;From source:&lt;/strong&gt; &lt;code&gt;cargo build --release&lt;/code&gt;, then use &lt;code&gt;./target/release/fidesc&lt;/code&gt; or build the self-hosted compiler.&lt;/li&gt;
&lt;li&gt;See the &lt;a href=&quot;/docs/install&quot;&gt;Installation guide&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;self-hosted-compiler&quot;&gt;Self-hosted compiler&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;3 bootstrap generations verified&lt;/strong&gt; (Rust → c1 → c2 → c3, all work): the self-hosted compiler (50 modules, 93,605 LOC in &lt;code&gt;compiler/*.fd&lt;/code&gt;) type-checks and borrow-checks the full compiler. The byte-identical fixpoint (&lt;code&gt;fides-c2.c == fides-c3.c&lt;/code&gt;) was claimed in Session 15 but could not be independently verified in the Session 22 audit. C codegen of the full compiler hits a memory segfault; normal programs are unaffected.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;38/38 self-host tests pass&lt;/strong&gt; on all three backends (Interpreter, C Codegen, PE Emitter): 0 regressions.&lt;/li&gt;
&lt;li&gt;The Rust compiler (&lt;code&gt;src/*.rs&lt;/code&gt;) remains as the bootstrap reference and is only needed when changing compiler internals.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;windows-installer&quot;&gt;Windows installer&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;NSIS installer&lt;/strong&gt; (&lt;code&gt;Fides-Setup-1.0.0.exe&lt;/code&gt;, 2.5 MB): tested and working on Windows.&lt;/li&gt;
&lt;li&gt;Installs the compiler (&lt;code&gt;fides.exe&lt;/code&gt;), the full standard library (99 modules), the C runtime, documentation, and examples.&lt;/li&gt;
&lt;li&gt;PATH integration (system-wide), &lt;code&gt;.fd&lt;/code&gt; file association, and Start Menu shortcuts.&lt;/li&gt;
&lt;li&gt;Uninstaller via Add/Remove Programs.&lt;/li&gt;
&lt;li&gt;A GitHub Actions workflow builds the installer automatically on tagged releases.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;standard-library&quot;&gt;Standard library&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;99 language-level modules (OS modules moved to the separate &lt;code&gt;fides-os&lt;/code&gt; project).&lt;/li&gt;
&lt;li&gt;26 game/media modules added in Session 21 (SDL, OpenGL, physics, audio, networking, and more).&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;test-baseline&quot;&gt;Test baseline&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;265/265 unit tests pass, 0 skipped, 0 known-fail.&lt;/li&gt;
&lt;li&gt;Interpreter: 164/165 normal tests. C Codegen: 164/165 matched. PE Emitter: 165/165 valid.&lt;/li&gt;
&lt;li&gt;Cross-compilation to x86-64, ARM64, RISC-V, and Windows, all producing valid executables with zero external tools.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;recent-language-features-session-23&quot;&gt;Recent language features (Session 23)&lt;/h2&gt;
&lt;p&gt;Six high-priority language features landed just before release:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@zeroize&lt;/code&gt; (F88)&lt;/strong&gt;: compiler-inserted &lt;code&gt;memset(0)&lt;/code&gt; at scope exit for secrets.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@secret&lt;/code&gt; (F74)&lt;/strong&gt;: information-flow control: secrets cannot reach output sinks.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@interrupt(N)&lt;/code&gt; (F29)&lt;/strong&gt;: interrupt handler annotation with automatic IDT setup.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@firmware&lt;/code&gt; (F30)&lt;/strong&gt;: rejects OS-dependent calls in bare-metal code.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;parallel { | }&lt;/code&gt; (F13)&lt;/strong&gt;: fork-join syntax via a contextual keyword.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@simd&lt;/code&gt; (F23)&lt;/strong&gt;: aggressive loop vectorization (wider vectors, relaxed cost).&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Test baseline improved: +2 interpreter, +1 C codegen, 0 regressions.&lt;/p&gt;</content:encoded></item><item><title>Update 19: Self-hosting underway</title><link>https://fid-lang.org/changelog/batch-19</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-19</guid><description>All ten rewritten compiler modules now compile: 18,329 lines of Fid, including a 4,989-line parser building to a 384KB native executable with zero external tools.</description><pubDate>Sat, 29 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The compiler is being rewritten in the language it compiles, and the milestone numbers are real.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;10 of 10 rewritten modules compile.&lt;/strong&gt; Token, diagnostics, JSON, formatter, AST, lexer, parser, IR, typechecker, and lowerer: 22,526 lines of Rust have become 18,329 lines of Fid.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The parser&lt;/strong&gt; (&lt;code&gt;parser.fd&lt;/code&gt;, 4,989 lines, 91 functions) compiles to a &lt;strong&gt;384KB native executable&lt;/strong&gt; via &lt;code&gt;fidesc build&lt;/code&gt;: no assembler, no linker, no C compiler.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The lexer and formatter are verified&lt;/strong&gt;: both produce output identical to their Rust counterparts across all 240 test files.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The IR module is done&lt;/strong&gt;: 25 tests passing on the interpreter, C codegen, and PE emitter.&lt;/li&gt;
&lt;li&gt;The typechecker (4,813 lines) and lowerer build to native binaries; differential testing against the Rust originals is the next step.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Still ahead: the monomorphizer and borrow checker rewrites, then the back end, then the bootstrap moment: Fid compiling Fid compiling Fid, with a &lt;code&gt;diff&lt;/code&gt; proving the fixed point. Dogfooding at this scale is already paying off: every compiler bug the rewrite surfaces (cross-module import resolution, enum-in-struct-in-Vec codegen) goes straight onto the fix list.&lt;/p&gt;</content:encoded></item><item><title>Update 18: A clean bill of health</title><link>https://fid-lang.org/changelog/batch-18</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-18</guid><description>The skip list went from 42 to 0, known-fails from 10 to 0. 165/165 tests on the PE emitter, 265/265 unit tests, and a real debugging toolkit for the compiler itself.</description><pubDate>Fri, 28 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Before starting the self-host rewrite, the project audited itself, and fixed everything the audit found.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Skip list: 42 → 0.&lt;/strong&gt; A systematic audit found 37 “skipped” tests that had long since started passing on all three backends. The rest were fixed for real: KV-cache and quantization builtins in C codegen, float formatting parity, and an optimizer bug where dead-call elimination silently removed &lt;code&gt;Vec_push&lt;/code&gt; and other side-effecting runtime calls.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Known-fail list: 10 → 0.&lt;/strong&gt; The last six (nested Vec iteration, thread-spawn state sharing, string content comparison, and float formatting) were month-old bugs, each root-caused and fixed.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The baseline now:&lt;/strong&gt; 164/165 normal tests on the interpreter and C codegen (the one failure is an unrelated user-added test), 165/165 on the PE emitter, 265/265 unit tests, 36/36 expected-fail tests correctly failing.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Debugging infrastructure&lt;/strong&gt;: &lt;code&gt;dump-tokens&lt;/code&gt;/&lt;code&gt;dump-ast&lt;/code&gt;/&lt;code&gt;dump-ir&lt;/code&gt;/&lt;code&gt;dump-pir&lt;/code&gt;/&lt;code&gt;dump-c&lt;/code&gt; commands, a &lt;code&gt;diff-test&lt;/code&gt; command that compares every compiler stage against golden files, &lt;code&gt;--trace&lt;/code&gt; per-stage timing, a configurable &lt;code&gt;--max-recursion&lt;/code&gt; limit, and an iterative parser fallback that survives 1000-level nested expressions.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Stdlib for compiler-writers&lt;/strong&gt;: &lt;code&gt;assert_msg&lt;/code&gt;/&lt;code&gt;assert_eq_msg&lt;/code&gt; with f-string formatting, binary file I/O, and a full set of string utilities.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Syntax v1.0: Standard keywords</title><link>https://fid-lang.org/changelog/syntax-v1</link><guid isPermaLink="true">https://fid-lang.org/changelog/syntax-v1</guid><description>The final Fid syntax: pf/pv/pc/ret/ty are replaced by fn, val, var, const, return, and type, with cap and use kept as Fid identity.</description><pubDate>Wed, 26 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The final Fid syntax, adopted ahead of self-hosting. The original signature keywords are replaced with standard, universally understood ones.&lt;/p&gt;
&lt;h2 id=&quot;the-changes&quot;&gt;The changes&lt;/h2&gt;





































&lt;table&gt;&lt;thead&gt;&lt;tr&gt;&lt;th&gt;Old&lt;/th&gt;&lt;th&gt;New&lt;/th&gt;&lt;/tr&gt;&lt;/thead&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;pf&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;fn&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;pv&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;val&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;pv mut&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;var&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;pc&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;const&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;ret&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;return&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;ty&lt;/code&gt;&lt;/td&gt;&lt;td&gt;&lt;code&gt;type&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;code&gt;pm&lt;/code&gt;&lt;/td&gt;&lt;td&gt;removed; use &lt;code&gt;var x: T;&lt;/code&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;code&gt;cap&lt;/code&gt; (capabilities/traits) and &lt;code&gt;use ... with { ... }&lt;/code&gt; (capability grants) are kept. They are short, distinct, and part of Fid’s identity.&lt;/p&gt;
&lt;h2 id=&quot;why&quot;&gt;Why&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Familiar over unique&lt;/strong&gt;: every new user previously had to learn six unfamiliar keywords before writing a line of code.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;AI-native&lt;/strong&gt;: models are trained on billions of lines using &lt;code&gt;fn&lt;/code&gt;- and &lt;code&gt;return&lt;/code&gt;-style keywords; the original spellings fought that familiarity for zero benefit.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Self-hosting&lt;/strong&gt;: the compiler will be written in Fid itself. Standard keywords make its source readable to every contributor.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Zero cost&lt;/strong&gt;: keyword spelling has no effect on compile speed, binary size, or runtime performance.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The &lt;code&gt;val&lt;/code&gt;/&lt;code&gt;var&lt;/code&gt; pair (from Kotlin/Scala/Swift) gives a clean three-keyword binding model with &lt;code&gt;const&lt;/code&gt; for compile-time values, and &lt;code&gt;var&lt;/code&gt; without an initializer replaces the old &lt;code&gt;pm&lt;/code&gt; keyword, backed by the same definite-assignment analysis.&lt;/p&gt;
&lt;p&gt;Migration is mechanical: a single ordered find-and-replace converts a whole codebase. See the &lt;a href=&quot;/docs/migration&quot;&gt;migration guide&lt;/a&gt; for the script and edge cases.&lt;/p&gt;</content:encoded></item><item><title>Update 17: AI &amp; LLM serving</title><link>https://fid-lang.org/changelog/batch-17</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-17</guid><description>Tape-based autodiff, layer/model keywords, GPU kernels, INT8 quantization, KV-cache regions with budgets, checkpointing, and LoRA hot-swap.</description><pubDate>Sat, 22 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The AI story deepened from tensors-in-the-stdlib to language-level ML semantics.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;layer&lt;/code&gt; / &lt;code&gt;model&lt;/code&gt; keywords&lt;/strong&gt;: desugar to plain structs and impls, so a network definition reads like the math: &lt;code&gt;x |&gt; self.l1.forward |&gt; relu |&gt; self.l2.forward&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Pipeline operator &lt;code&gt;|&gt;&lt;/code&gt;&lt;/strong&gt;: &lt;code&gt;x |&gt; f |&gt; g&lt;/code&gt; is &lt;code&gt;g(f(x))&lt;/code&gt;, resolved at parse time.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Compile-time shape safety&lt;/strong&gt;: &lt;code&gt;Tensor&amp;#x3C;f32, [784, 128]&gt;&lt;/code&gt; with symbolic batch dimensions; &lt;code&gt;matmul&lt;/code&gt;, &lt;code&gt;conv2d&lt;/code&gt;, &lt;code&gt;concat&lt;/code&gt;, and friends are shape-checked before the program runs.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Tape-based autodiff&lt;/strong&gt;: &lt;code&gt;grad(w) { ... backward(loss); }&lt;/code&gt; records and replays a gradient tape (interpreter runtime; IR support across backends).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;GPU kernels&lt;/strong&gt;: &lt;code&gt;@kernel&lt;/code&gt; functions with &lt;code&gt;thread_id()&lt;/code&gt; / workgroup builtins compile to SPIR-V, with a CPU fallback so kernels are testable in the interpreter.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Quantization&lt;/strong&gt;: the &lt;code&gt;~&gt; q8&lt;/code&gt; cast operator, symmetric INT8 parameters, &lt;code&gt;qmatmul&lt;/code&gt;, and dequantization.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;LLM serving primitives&lt;/strong&gt;: KV-cache regions with mandatory memory budgets and sliding-window eviction, gradient checkpointing, differential-privacy budget tracking, simulated tensor parallelism, and LoRA adapter hot-swap that survives hot reload via &lt;code&gt;persist&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Honesty note: checkpointing, DP, and tensor parallelism are partial (interpreter-level or single-rank simulation today); see &lt;a href=&quot;/docs/feature-status&quot;&gt;Feature Status&lt;/a&gt;.&lt;/p&gt;</content:encoded></item><item><title>Update 16: The tooling ecosystem</title><link>https://fid-lang.org/changelog/batch-16</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-16</guid><description>A package manager (pacte), doc generator (scribe), coverage tool (veil), formatter, linter, benchmarker, debuggers, and a 23-pass optimizer with incremental compilation.</description><pubDate>Thu, 20 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The toolchain grew from a compiler into an ecosystem: still one codebase, now four binaries.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;pacte&lt;/code&gt;&lt;/strong&gt;: the package manager. &lt;code&gt;init&lt;/code&gt;, &lt;code&gt;add&lt;/code&gt; (path and git dependencies), &lt;code&gt;install&lt;/code&gt;, &lt;code&gt;lock&lt;/code&gt;, &lt;code&gt;update&lt;/code&gt;, and more, with a &lt;code&gt;pacte.toml&lt;/code&gt; manifest, a &lt;code&gt;pacte.lock&lt;/code&gt; lock file, and a built-in TOML parser. Zero external dependencies; a registry is planned.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;scribe&lt;/code&gt;&lt;/strong&gt;: the documentation generator. Extracts &lt;code&gt;///&lt;/code&gt; doc comments from &lt;code&gt;.fd&lt;/code&gt; files and produces styled HTML or Markdown with navigation, signatures, and parameter tables.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;veil&lt;/code&gt;&lt;/strong&gt;: the coverage tool. Tracks function, line, and instruction coverage and reports as annotated text or HTML.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;fidesc fmt&lt;/code&gt; / &lt;code&gt;lint&lt;/code&gt; / &lt;code&gt;bench&lt;/code&gt; / &lt;code&gt;profile&lt;/code&gt;&lt;/strong&gt;: formatter, linter (unused functions and imports), benchmark runner with timing statistics, and a per-function profiler.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;fidesc debug&lt;/code&gt; / &lt;code&gt;autopsy&lt;/code&gt; / &lt;code&gt;replay&lt;/code&gt;&lt;/strong&gt;: an interactive debugger (breakpoints, stepping, locals), a native ptrace-based debugger, and execution-trace replay.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Optimizer maturity&lt;/strong&gt;: 23 passes (const-fold, CSE, GVN, SROA, inlining, TCO, loop vectorization, region pooling, effect-aware reordering, and more), enabled by default in &lt;code&gt;build&lt;/code&gt; with &lt;code&gt;--lto&lt;/code&gt; for cross-module inlining. 19 of the passes run in parallel across CPU cores.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Incremental compilation&lt;/strong&gt;: optimized modules are cached by source hash, shared across the LSP server, watch mode, and the test harness.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 15: Cross-compilation, zero tools</title><link>https://fid-lang.org/changelog/batch-15</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-15</guid><description>One build command now targets ARM64 Linux, RISC-V Linux, and Windows from any host, with instruction encoders, runtimes, and linker all built in.</description><pubDate>Tue, 18 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The zero-external-tools philosophy now spans architectures. &lt;code&gt;fidesc build --target &amp;#x3C;t&gt;&lt;/code&gt; cross-compiles with no assembler, no linker, and no C compiler installed:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;ARM64 Linux&lt;/strong&gt; (&lt;code&gt;--target arm64-linux&lt;/code&gt;): a built-in AArch64 instruction encoder plus a libc-free runtime speaking raw SVC syscalls. A hello world is a 27KB ELF64.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;RISC-V Linux&lt;/strong&gt; (&lt;code&gt;--target riscv64-linux&lt;/code&gt;): a built-in RV64 encoder (all six instruction formats plus pseudo-instructions) and a raw ECALL syscall runtime. 29KB.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Windows&lt;/strong&gt; (&lt;code&gt;--target x86-64-windows&lt;/code&gt;): the direct PE emitter wired into the unified build command. 98KB.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Target-aware integrated linker&lt;/strong&gt;: handles ARM64 relocations (BL, B.cond, ADRP/ADD:lo12) and RISC-V relocations (JAL, branches) in-process.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Object files in three formats&lt;/strong&gt;: &lt;code&gt;fidesc codegen&lt;/code&gt; emits relocatable ELF64, Mach-O, and COFF objects for integration with existing toolchains.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;47 new cross-compilation encoder and runtime unit tests, zero regressions.&lt;/p&gt;</content:encoded></item><item><title>Update 14: Security hardening</title><link>https://fid-lang.org/changelog/batch-14</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-14</guid><description>Binary hardening on by default, @constant_time against timing side channels, @tainted against injection, and stack traces on panic.</description><pubDate>Sun, 16 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Security went from a capability model to a full hardening posture.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Binary hardening by default&lt;/strong&gt;: every C-codegen binary ships with stack canaries (&lt;code&gt;-fstack-protector-strong&lt;/code&gt;), PIE/ASLR, full RELRO, and a non-executable stack. No opt-in required.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@constant_time&lt;/code&gt;&lt;/strong&gt;: a compile-time defense against timing side channels (Spectre-class and cache-timing attacks). Inside a &lt;code&gt;@constant_time&lt;/code&gt; function the compiler rejects early returns, IO/network/spawn effects, memory allocation, and calls to non-constant-time functions, transitively.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@tainted&lt;/code&gt;&lt;/strong&gt;: parameters marked as untrusted user input cannot flow into dangerous sinks: SQL queries, shell commands, HTML output, or file paths.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Stack traces on panic&lt;/strong&gt;: panics now print the chain of function calls that led there, in both the interpreter and native output.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;“Did you mean?” diagnostics&lt;/strong&gt;: the typechecker suggests corrections for misspelled variables, functions, methods, and struct fields.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 13: The borrow checker</title><link>https://fid-lang.org/changelog/batch-13</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-13</guid><description>Compile-time aliasing analysis with field-wise borrows, two-phase borrows, and non-lexical lifetimes: Rust-grade guarantees without lifetime annotations.</description><pubDate>Fri, 14 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;Region inference already prevented use-after-free. This update adds the other half of memory soundness: aliasing discipline, enforced at compile time, deliberately without lifetime parameters, variance, or &lt;code&gt;Send&lt;/code&gt;/&lt;code&gt;Sync&lt;/code&gt; traits.&lt;/p&gt;
&lt;p&gt;Three rules, checked in a dedicated pass after typechecking:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;One &lt;code&gt;&amp;#x26;mut&lt;/code&gt; borrow at a time.&lt;/li&gt;
&lt;li&gt;Any number of &lt;code&gt;&amp;#x26;&lt;/code&gt; borrows, but not while a &lt;code&gt;&amp;#x26;mut&lt;/code&gt; exists.&lt;/li&gt;
&lt;li&gt;No mutation of a value while it is borrowed.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;What makes it pleasant rather than painful:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Field-wise borrows&lt;/strong&gt;: &lt;code&gt;&amp;#x26;s.x&lt;/code&gt; and &lt;code&gt;&amp;#x26;mut s.y&lt;/code&gt; coexist; borrowing one field does not lock the whole struct.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Two-phase borrows&lt;/strong&gt;: call arguments reserve first and activate later, so the common &lt;code&gt;v.push(v.len())&lt;/code&gt; pattern just works.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Non-lexical lifetimes (NLL)&lt;/strong&gt;: a borrow ends at its last use, not at the end of the scope, so &lt;code&gt;val r = &amp;#x26;v; print(*r); v = 20;&lt;/code&gt; compiles.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;No annotations&lt;/strong&gt;: there are no &lt;code&gt;&apos;a&lt;/code&gt; parameters anywhere in the language. Regions stay inferred.&lt;/li&gt;
&lt;li&gt;Controlled by &lt;code&gt;--borrowck=off|warn|on&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Also in this update: &lt;code&gt;val&lt;/code&gt; immutability is now a hard type error on reassignment and on struct-field mutation, and &lt;code&gt;@send&lt;/code&gt;/&lt;code&gt;@sync&lt;/code&gt; checks landed for thread-safety annotations.&lt;/p&gt;</content:encoded></item><item><title>Update 12: Safety for the real world</title><link>https://fid-lang.org/changelog/batch-12</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-12</guid><description>Compile-time financial conservation, linear types, transactions, gas budgets, crash-free proofs, contracts, and typed strings: the safety annotation cluster lands.</description><pubDate>Mon, 10 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;One push turned Fid’s safety story from “memory safe” into “domain safe”. These are compile-time guarantees aimed at the bugs that cost the real world billions.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@linear&lt;/code&gt; types&lt;/strong&gt;: move semantics with no duplication. A money value cannot be processed twice; consuming a linear variable inside a loop is a compile error.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@conserve&lt;/code&gt;&lt;/strong&gt;: a compile-time financial conservation proof: money in must equal money out. Double-credit and lost-money bugs fail to compile.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;txn { }&lt;/code&gt; blocks&lt;/strong&gt;: atomic transactions with rollback on failure.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@gas(N)&lt;/code&gt;&lt;/strong&gt;: compile-time gas budgets for bounded-cost functions.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@crashfree&lt;/code&gt;&lt;/strong&gt;: a compile-time proof that a function cannot panic.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@audit&lt;/code&gt;&lt;/strong&gt;: automatic function audit logging with parameter values.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;@medical&lt;/code&gt;&lt;/strong&gt;: IEC 62304-style restrictions: no dynamic allocation, no recursion, no unbounded loops, no unwrap, must be &lt;code&gt;@audit&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;given&lt;/code&gt; / &lt;code&gt;ensure&lt;/code&gt; contracts&lt;/strong&gt;: Design-by-Contract preconditions verified at call sites.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Typed strings&lt;/strong&gt;: &lt;code&gt;SQLString&lt;/code&gt;, &lt;code&gt;ShellString&lt;/code&gt;, &lt;code&gt;HTMLString&lt;/code&gt;, &lt;code&gt;JSONString&lt;/code&gt;, &lt;code&gt;PathString&lt;/code&gt;. Concatenating user input into a query is a type error, not a code-review hope.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Init guarantee&lt;/strong&gt;: &lt;code&gt;var x: T;&lt;/code&gt; without an initializer plus definite-assignment analysis: reading before assignment is a compile error.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Checked arithmetic everywhere&lt;/strong&gt;: integer overflow panics (always on, not just in debug), with &lt;code&gt;@wrapping&lt;/code&gt; as the explicit escape hatch. Bounds checks are always on, skippable only inside &lt;code&gt;unsafe { }&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Stdlib support&lt;/strong&gt;: &lt;code&gt;money&lt;/code&gt; (fixed-point currency), &lt;code&gt;banking&lt;/code&gt; (accounts, transfers, double-credit detection), &lt;code&gt;time&lt;/code&gt; (LogicalTime: timezone-free, clock-free deterministic date math), and &lt;code&gt;memo&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 11: Enhanced built-in types</title><link>https://fid-lang.org/changelog/batch-11</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-11</guid><description>49 new built-in methods across String, Vec, and HashMap, with full interpreter runtimes and native implementations for the core set.</description><pubDate>Thu, 06 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The built-in collection types grew up in one push.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;49 new built-in methods&lt;/strong&gt; across &lt;code&gt;String&lt;/code&gt;, &lt;code&gt;Vec&lt;/code&gt;, and &lt;code&gt;HashMap&lt;/code&gt;: &lt;code&gt;contains&lt;/code&gt;, &lt;code&gt;starts_with&lt;/code&gt;, &lt;code&gt;trim&lt;/code&gt;, &lt;code&gt;split&lt;/code&gt;, &lt;code&gt;replace&lt;/code&gt;, &lt;code&gt;to_uppercase&lt;/code&gt;, &lt;code&gt;parse_int&lt;/code&gt;, &lt;code&gt;insert&lt;/code&gt;, &lt;code&gt;remove&lt;/code&gt;, &lt;code&gt;sort&lt;/code&gt;, &lt;code&gt;reverse&lt;/code&gt;, &lt;code&gt;get_or&lt;/code&gt;, and more.&lt;/li&gt;
&lt;li&gt;Full runtime implementations in the interpreter; type checking and IR lowering for every method.&lt;/li&gt;
&lt;li&gt;Native x86-64 implementations in the PE emitter for the core set (&lt;code&gt;len&lt;/code&gt;, &lt;code&gt;is_empty&lt;/code&gt;, &lt;code&gt;clear&lt;/code&gt;, &lt;code&gt;first&lt;/code&gt;, &lt;code&gt;last&lt;/code&gt;, &lt;code&gt;contains&lt;/code&gt;, &lt;code&gt;parse_int&lt;/code&gt;, …), with stubs registered for the rest.&lt;/li&gt;
&lt;li&gt;A comprehensive collections test suite covering all 49 operations, with every test passing in the interpreter.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 10: The direct PE emitter</title><link>https://fid-lang.org/changelog/batch-10</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-10</guid><description>Fid now produces native Windows executables with zero external tools: no assembler, no linker, no C compiler.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The flagship backend landed: &lt;code&gt;emit&lt;/code&gt; goes from source to a finished &lt;code&gt;.exe&lt;/code&gt; &lt;strong&gt;with zero external tools&lt;/strong&gt;.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Full x86-64 instruction encoder: REX prefixes, ModR/M + SIB bytes, displacement and immediate encoding, all 16 registers.&lt;/li&gt;
&lt;li&gt;Complete PE file construction: DOS/PE headers, &lt;code&gt;.text&lt;/code&gt; + &lt;code&gt;.rdata&lt;/code&gt; sections, import directory, and an Import Address Table pulling &lt;code&gt;GetStdHandle&lt;/code&gt;, &lt;code&gt;WriteFile&lt;/code&gt;, and &lt;code&gt;ExitProcess&lt;/code&gt; from &lt;code&gt;kernel32.dll&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Print, panic, and allocation runtime generated inline as machine code, with no libc anywhere in the binary.&lt;/li&gt;
&lt;li&gt;Deferred label relocation for jumps and calls; Windows x64 ABI-compliant stack frames.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;bugs-worth-remembering&quot;&gt;Bugs worth remembering&lt;/h2&gt;
&lt;p&gt;Three subtle codegen bugs were found and fixed along the way:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Swapped REX.R/REX.B bits&lt;/strong&gt; in register-to-register moves, so any &lt;code&gt;mov&lt;/code&gt; involving R8-R15 selected the wrong register, causing access violations.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;A 64-bit store clobbering adjacent stack data&lt;/strong&gt;: zeroing a 4-byte variable wrote 8 bytes, silently corrupting the neighboring newline and digit bytes.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;An off-by-one in integer print length&lt;/strong&gt; that dropped the trailing newline.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Output now matches the interpreter and MASM backends byte-for-byte, and exit codes propagate correctly.&lt;/p&gt;</content:encoded></item><item><title>Update 9: Monomorphization &amp; module imports</title><link>https://fid-lang.org/changelog/batch-9</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-9</guid><description>Generics become zero-cost via per-call-site specialization, and use imports resolve real files from disk.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Generics are now zero-cost&lt;/strong&gt;: every generic call site gets a specialized non-generic copy (&lt;code&gt;identity__i64&lt;/code&gt;), including generic methods on structs.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;use foo::bar&lt;/code&gt; resolves real files from disk (&lt;code&gt;&amp;#x3C;path&gt;.fd&lt;/code&gt; or &lt;code&gt;&amp;#x3C;path&gt;/mod.fd&lt;/code&gt;), with module merging and visibility enforcement.&lt;/li&gt;
&lt;li&gt;Import errors come with “did you mean…” suggestions (Levenshtein distance).&lt;/li&gt;
&lt;li&gt;The core standard library is auto-included in every program, and user definitions always win on conflict.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 8: C codegen backend</title><link>https://fid-lang.org/changelog/batch-8</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-8</guid><description>A portable backend: SSA IR to C99 source, compilable with MSVC, GCC, or Clang, with automatic MSVC discovery on Windows.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;New portable backend: SSA IR → C99 source, compilable with MSVC, GCC, or Clang.&lt;/li&gt;
&lt;li&gt;Automatic MSVC discovery and environment setup on Windows (&lt;code&gt;find_cl&lt;/code&gt;, &lt;code&gt;vcvarsall.bat&lt;/code&gt;).&lt;/li&gt;
&lt;li&gt;Polymorphic &lt;code&gt;print&lt;/code&gt; dispatch, struct typedefs, and basic-block &lt;code&gt;goto&lt;/code&gt; control flow.&lt;/li&gt;
&lt;li&gt;Careful renaming to dodge C macro conflicts: &lt;code&gt;main&lt;/code&gt; → &lt;code&gt;main_entry&lt;/code&gt;, plus &lt;code&gt;#undef&lt;/code&gt; guards for MSVC’s &lt;code&gt;max&lt;/code&gt;/&lt;code&gt;min&lt;/code&gt;/&lt;code&gt;abs&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The C backend doubles as a verification tool: output parity across the interpreter, C, and native backends catches codegen bugs early.&lt;/p&gt;</content:encoded></item><item><title>Update 7: Lowering the language</title><link>https://fid-lang.org/changelog/batch-7</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-7</guid><description>The interpreter learned most of the language in one push: arrays, match expressions, methods, tuples, enums, closures, and defer.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;One large push took most of the surface language from “parses” to “runs”:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Arrays&lt;/strong&gt;: literals, indexing, element assignment, compound assignment, and &lt;code&gt;for&lt;/code&gt; loops over arrays.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;match&lt;/code&gt; as an expression&lt;/strong&gt;, with string, range, and enum-variant patterns.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Struct methods&lt;/strong&gt; with SRET returns, &lt;strong&gt;tuples&lt;/strong&gt;, &lt;strong&gt;enums with payloads&lt;/strong&gt;, the &lt;strong&gt;&lt;code&gt;?&lt;/code&gt; operator&lt;/strong&gt;, &lt;strong&gt;closures&lt;/strong&gt; via lambda lifting, and &lt;strong&gt;&lt;code&gt;defer&lt;/code&gt;&lt;/strong&gt; blocks that run before every return.&lt;/li&gt;
&lt;li&gt;Typed allocas throughout the lowerer, so loads now carry correct types instead of defaulting to &lt;code&gt;i64&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 6: SSA IR, x86-64 backend &amp; interpreter</title><link>https://fid-lang.org/changelog/batch-6</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-6</guid><description>The compiler grew its middle and back ends: a typed SSA IR, full AST lowering, an interpreter, and a MASM x86-64 backend.</description><pubDate>Tue, 04 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The compiler’s architecture took shape:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;A typed &lt;strong&gt;SSA intermediate representation&lt;/strong&gt;: basic blocks, explicit terminators, an effect-set per function.&lt;/li&gt;
&lt;li&gt;Full &lt;strong&gt;AST → IR lowering&lt;/strong&gt;: control flow, function calls, f-string concatenation, mutable variables via alloca.&lt;/li&gt;
&lt;li&gt;An &lt;strong&gt;IR interpreter&lt;/strong&gt; (&lt;code&gt;run&lt;/code&gt;) for instant iteration with no external tools.&lt;/li&gt;
&lt;li&gt;A &lt;strong&gt;MASM x86-64 backend&lt;/strong&gt; (&lt;code&gt;build&lt;/code&gt;) with the Windows x64 calling convention, inline print/panic runtime, and no C runtime dependency.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Seven gnarly bugs were fixed in the process, including recursive calls crashing from unpreserved non-volatile registers, and f-strings printing memory addresses instead of string contents.&lt;/p&gt;</content:encoded></item><item><title>Update 5: Generics, closures &amp; error handling</title><link>https://fid-lang.org/changelog/batch-5</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-5</guid><description>Generic types and functions, the ? operator, closures in both forms, and tuples, plus the parser bug that had been blocking generics.</description><pubDate>Mon, 03 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;Generic types (&lt;code&gt;Option&amp;#x3C;T&gt;&lt;/code&gt;, &lt;code&gt;Result&amp;#x3C;T, E&gt;&lt;/code&gt;) and generic functions.&lt;/li&gt;
&lt;li&gt;The &lt;code&gt;?&lt;/code&gt; operator for error propagation.&lt;/li&gt;
&lt;li&gt;Closures in block and expression form.&lt;/li&gt;
&lt;li&gt;Tuple types and literals.&lt;/li&gt;
&lt;li&gt;Fixed a parser double-advance bug that had been breaking generic function parsing: the parser was consuming one token too many after type names.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 4: Enums, references &amp; modules</title><link>https://fid-lang.org/changelog/batch-4</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-4</guid><description>Enums with payload data and variant patterns, reference types, string concatenation, imports, and attributes.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;Enums with payload data, variant construction (&lt;code&gt;Shape::Circle(3.14)&lt;/code&gt;), and variant pattern matching.&lt;/li&gt;
&lt;li&gt;Reference types (&lt;code&gt;&amp;#x26;T&lt;/code&gt;, &lt;code&gt;&amp;#x26;mut T&lt;/code&gt;) and dereferencing.&lt;/li&gt;
&lt;li&gt;String concatenation with &lt;code&gt;+&lt;/code&gt; and string patterns in &lt;code&gt;match&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;use&lt;/code&gt; imports and &lt;code&gt;#[attributes]&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 3: Arrays, match &amp; f-strings</title><link>https://fid-lang.org/changelog/batch-3</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-3</guid><description>Array types and indexing, match statements with five pattern kinds, and first-class f-string interpolation.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;Array types, literals, and indexing.&lt;/li&gt;
&lt;li&gt;&lt;code&gt;match&lt;/code&gt; statements with int, bool, binding, wildcard, and enum patterns.&lt;/li&gt;
&lt;li&gt;First-class f-string interpolation: &lt;code&gt;f&quot;Hello, {name}!&quot;&lt;/code&gt;, lexed with brace-depth tracking and embedded expressions re-parsed properly.&lt;/li&gt;
&lt;li&gt;Float literal codegen.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 2: Ranges, aliases &amp; methods</title><link>https://fid-lang.org/changelog/batch-2</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-2</guid><description>Range-based for loops, type aliases, struct methods via impl blocks, and blocks as expressions.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;ul&gt;
&lt;li&gt;&lt;code&gt;for x in 0..10&lt;/code&gt; and inclusive &lt;code&gt;0..=10&lt;/code&gt; ranges.&lt;/li&gt;
&lt;li&gt;Type aliases.&lt;/li&gt;
&lt;li&gt;Struct methods via &lt;code&gt;impl&lt;/code&gt; blocks, with method-call syntax.&lt;/li&gt;
&lt;li&gt;Blocks and &lt;code&gt;if&lt;/code&gt; as expressions.&lt;/li&gt;
&lt;li&gt;Hex, binary, and octal literals with underscore separators.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>Update 1: The language takes shape</title><link>https://fid-lang.org/changelog/batch-1</link><guid isPermaLink="true">https://fid-lang.org/changelog/batch-1</guid><description>The original keyword set, the .fd extension, operators, control flow, and the first end-to-end feature set.</description><pubDate>Sun, 02 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The language found its first shape:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The original signature keywords, later standardized to &lt;code&gt;fn&lt;/code&gt; / &lt;code&gt;val&lt;/code&gt; / &lt;code&gt;var&lt;/code&gt; / &lt;code&gt;const&lt;/code&gt; in the &lt;a href=&quot;/changelog/syntax-v1&quot;&gt;v1.0 syntax&lt;/a&gt;, plus &lt;code&gt;cap&lt;/code&gt;, &lt;code&gt;comptime&lt;/code&gt;, &lt;code&gt;defer&lt;/code&gt;, &lt;code&gt;spawn&lt;/code&gt;, and &lt;code&gt;region&lt;/code&gt; reserved for what was coming.&lt;/li&gt;
&lt;li&gt;The &lt;code&gt;.fd&lt;/code&gt; file extension.&lt;/li&gt;
&lt;li&gt;Compound assignment, bitwise operators, boolean literals, &lt;code&gt;while&lt;/code&gt; / &lt;code&gt;loop&lt;/code&gt; / &lt;code&gt;break&lt;/code&gt; / &lt;code&gt;continue&lt;/code&gt;, mutable variables, constants, and type inference.&lt;/li&gt;
&lt;li&gt;Block comments, f-string lexing, and VS Code syntax highlighting via a TextMate grammar.&lt;/li&gt;
&lt;/ul&gt;</content:encoded></item><item><title>The seed compiler</title><link>https://fid-lang.org/changelog/initial</link><guid isPermaLink="true">https://fid-lang.org/changelog/initial</guid><description>Where it all started: a hand-written lexer, a recursive descent parser, a basic type checker, and an ARM64 code generator.</description><pubDate>Sat, 01 Aug 2026 00:00:00 GMT</pubDate><content:encoded>&lt;p&gt;The very first cut of the compiler:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Hand-written lexer and recursive descent parser. No generators, on principle.&lt;/li&gt;
&lt;li&gt;Basic type checker covering integers, floats, strings, bools, structs, and functions.&lt;/li&gt;
&lt;li&gt;An ARM64 (AArch64) code generator.&lt;/li&gt;
&lt;li&gt;Structs, enums, functions, if/else expressions, arithmetic, comparisons, logical operators, and a &lt;code&gt;print()&lt;/code&gt; builtin.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Everything since has been built on this foundation: same philosophy, every layer custom.&lt;/p&gt;</content:encoded></item></channel></rss>