{"version":"https://jsonfeed.org/version/1.1","title":"Fid Changelog","home_page_url":"https://fid-lang.org/changelog","feed_url":"https://fid-lang.org/changelog/feed.json","description":"Every Fid update as it lands, from the seed compiler to the v1.0 syntax.","items":[{"id":"https://fid-lang.org/changelog/nov-7-15-native-linux-ownership","url":"https://fid-lang.org/changelog/nov-7-15-native-linux-ownership","title":"Native Linux executables, one ownership rule, a faster compiler","summary":"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.","date_published":"2026-11-15T00:00:00.000Z","content_html":"<p>Nine days of work on <code>fid</code>, 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 <code>fid</code>; each change below was checked with its own tests.</p>\n<h2 id=\"native-backends\">Native backends</h2>\n<ul>\n<li><strong>Linux without a C compiler</strong>: <code>fid emit --target x86_64-linux</code>, <code>aarch64-linux</code> or <code>riscv64-linux</code> 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).</li>\n<li><strong>Windows</strong>: the native backend has a linear-scan register allocator for integer and <code>xmm</code> registers, tasks switch on their own stacks, and sockets wait through IOCP. <code>fid emit --nat</code> puts Windows on the same machine layer as Linux (opt-in; 301 of 338 suite programs).</li>\n<li><strong>Native <code>async</code>/<code>await</code> works</strong>: it broke in builds of Nov 9 afternoon and was fixed the same evening.</li>\n<li><strong>Bare metal</strong> (Nov 15): <code>fid emit --bare</code> and <code>--boot</code> write an x86-64 Multiboot kernel that boots under QEMU; 10 of 10 bare tests pass.</li>\n<li><strong>WebAssembly</strong> (Nov 15): <code>fid wasm</code> modules validate and run under WASI; 316 of 344 suite programs match <code>fid run</code>.</li>\n<li><strong>macOS</strong> (Nov 15): native Mach-O executables are written and checked for structure. They have not been run on a Mac.</li>\n<li><code>fid ccompile --target</code> cross-compiles through C with <code>zig cc</code> for <code>aarch64-linux</code>, <code>riscv64-linux</code>, <code>x86_64-macos</code>, <code>aarch64-macos</code> and <code>wasm32-wasi</code>.</li>\n</ul>\n<h2 id=\"memory-and-values\">Memory and values</h2>\n<ul>\n<li><strong>One ownership rule</strong> (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, <code>Vec</code> buffers and Boxes are reference-counted.</li>\n<li><strong>Value semantics</strong>: <code>var b = a</code> on a <code>Vec</code>, <code>HashMap</code> or <code>str</code> gives an independent value, shared until the first write. Since Nov 15, copying a struct also separates its <code>Vec</code> fields.</li>\n<li><code>&#x26;v[i]</code> and <code>&#x26;mut v[i]</code> are the element’s address, so writes through them reach the container.</li>\n<li>A leak gate (<code>scripts/leak-check.sh</code>) checks that test programs free every block.</li>\n</ul>\n<h2 id=\"the-language\">The language</h2>\n<ul>\n<li><strong>Literals of generic structs</strong> of your own work (Nov 15): <code>Pair { first: 1, second: \"a\" }</code>.</li>\n<li><strong>Match exhaustiveness</strong> covers generic enums such as <code>Option&#x3C;T></code> and no longer counts a guarded arm as covering anything.</li>\n<li><code>--borrowck=warn</code> prints its warnings, and the borrow checker follows casts and nested field writes.</li>\n<li>A match guard on a <code>@secret</code> value taints its arm, and file and socket writes are sinks.</li>\n<li><code>5e3</code> and <code>2E-3</code> lex as floats.</li>\n</ul>\n<h2 id=\"the-optimizer-and-its-checks\">The optimizer and its checks</h2>\n<ul>\n<li>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.</li>\n<li>The 108 integer rewrite rules are proved with z3, and the instruction encoders are checked against clang’s assembler (1,181 forms, no mismatch).</li>\n<li><code>tests/conformance/</code> adds 104 programs, each checking one rule of the language reference.</li>\n</ul>\n<h2 id=\"speed\">Speed</h2>\n<ul>\n<li>The compiler’s C is split into units and built at <code>-O2</code>. Compiling itself to C takes about 40 s (Nov 15), down from about 133 s on Nov 6.</li>\n<li>The fixpoint was verified again on Nov 8 (stage 2 == stage 3, 67 MB of C). Later changes were checked on one-stage builds.</li>\n<li>A CI workflow builds a change’s compiler and its base commit’s on one runner and compares the benchmarks.</li>\n</ul>\n<h2 id=\"standard-library-and-tools\">Standard library and tools</h2>\n<ul>\n<li>163 modules. New: brotli and zstd decoders, <code>decimal</code>, <code>protobuf</code>, <code>tz</code> (the IANA database), <code>wss</code>, Unicode normalization (NFC, NFD, NFKC, NFKD), a set of OS-development modules (<code>elf</code>, <code>acpi</code>, <code>pci</code>, <code>virtio</code>, <code>multiboot</code>, <code>fdt</code>, <code>uart</code>, <code>pmm</code>, <code>slab</code>), <code>safetensors</code>, <code>bpe</code> and <code>infer</code> for model inference, and <code>gltf</code> and <code>tiled</code> loaders.</li>\n<li><code>fid lint --perf</code> warns about loop hazards, and <code>fid explain file.fd</code> lists which run-time checks the compiler removed or kept, and why (<code>--alloc</code>: the allocation sites and why each is on the heap).</li>\n<li>The repository gained a book, a cookbook and guides for readers coming from Rust, Go, Zig and C.</li>\n</ul>\n<h2 id=\"still-open\">Still open</h2>\n<p>The full suite has not been run with <code>fid</code> as the compiler under test. Native code is slower than code built through C. A <code>Vec</code> 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 <code>build --native</code> (the old PIR path) crashes. The current list is on the <a href=\"/docs/feature-status\">Feature Status</a> page.</p>"},{"id":"https://fid-lang.org/changelog/nov-4-6-language-depth","url":"https://fid-lang.org/changelog/nov-4-6-language-depth","title":"Generics, borrowed strings, safety rules with evidence","summary":"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.","date_published":"2026-11-06T00:00:00.000Z","content_html":"<p>Three days of work on <code>fid</code>, 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 <code>fid version</code> still prints <code>0.1.0</code>. 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.</p>\n<h2 id=\"the-language\">The language</h2>\n<ul>\n<li><strong>Generics</strong> (proposal 0002): type arguments are inferred at each call or the call is an error naming the parameter; bounds <code>T: A + B</code> are checked; a turbofish <code>f::&#x3C;T>()</code> must give as many type arguments as the function has. Generic enums and generic <code>impl</code> blocks are typed per receiver. Literals of generic structs of your own are still rejected.</li>\n<li><strong><code>if</code> and <code>match</code> are values</strong>, also as a function’s last statement.</li>\n<li><strong><code>@cfg</code></strong>: <code>windows</code>, <code>linux</code>, <code>macos</code>, <code>platform = \"...\"</code>, <code>os = \"...\"</code>, arch, <code>debug</code> and <code>release</code> keep or drop functions and structs. The platform is the host’s.</li>\n<li><strong>Integer <code>HashMap</code> keys</strong> work (they crashed before); 0 and -1 are ordinary keys.</li>\n<li><strong>Higher-order effects</strong>: a function that takes a function value gets the effects of the function passed at each call, so <code>apply(pure_fn, x)</code> can be called from a <code>!{}</code> function.</li>\n<li><strong>The language reference</strong> (<code>docs/reference/reference.md</code> in the repository) documents what <code>fid</code> accepts, with the compiler function behind each rule.</li>\n</ul>\n<h2 id=\"memory-and-borrowing\">Memory and borrowing</h2>\n<ul>\n<li>The compiler now <strong>frees locals it can prove are finished</strong>: <code>Vec</code> and <code>HashMap</code> locals, a <code>Vec&#x3C;str></code> or <code>Vec&#x3C;Vec&#x3C;T>></code> with the elements it owns, collections declared in a <code>region</code> at its end, and string temporaries. There is still no GC; anything else lives until exit.</li>\n<li>The borrow checker rejects <strong>changing a <code>Vec</code> while a <code>for</code> loop walks it</strong>, and <strong>assigning a field of a borrowed struct</strong>. Trait impl bodies and <code>&#x26;v[i]</code> are checked too. File, socket, process and clock runtime calls count as <code>IO</code> or <code>Net</code> effects.</li>\n<li><strong>Owned and borrowed strings</strong>: <code>str</code> is owned, <code>&#x26;str</code> borrowed. A <code>str</code> field of a <code>@scoped</code> struct reads as <code>&#x26;str</code> and cannot be returned as <code>str</code> or stored; <code>str_clone</code> makes an owned copy. <code>http_serve_scoped</code> uses this to free each request after its response, and is no longer <code>@unsafe</code>.</li>\n</ul>\n<h2 id=\"concurrency\">Concurrency</h2>\n<ul>\n<li>Every argument of a spawned call must be <strong><code>@send</code></strong>; a struct of <code>@send</code> fields is <code>@send</code>; references and raw pointers are not.</li>\n<li><strong><code>parallel { }</code> branches run on threads</strong>: <code>x = f(...)</code> branches, and branches that read only word-sized locals.</li>\n<li><strong><code>async fn</code> with <code>f64</code> or struct arguments</strong> runs as a task in the interpreter and through C. Native async programs still crash.</li>\n<li>Per-thread free lists in the native runtime and per-thread arenas in the C runtime (no multi-thread stress test yet).</li>\n</ul>\n<h2 id=\"safety-rules\">Safety rules</h2>\n<ul>\n<li><code>@no-alloc</code> sees method calls (<code>.push()</code>), <code>Vec::new()</code> and string <code>+</code>; <code>@no-indirect</code> rejects calls through function parameters; <code>@firmware</code> rejects OS runtime calls; <code>@gas</code> counts literal loop trip counts; <code>@tainted</code> works on parameters.</li>\n<li><strong>17 rules, each with a negative test</strong> (<code>docs/reference/safety-rules.md</code>).</li>\n<li><strong><code>fid qualify file.fd -o out.json</code></strong> writes the evidence: compiler and source hashes, the check result, the annotated functions, and each rule with its requirement and tests. It always reports <code>NOT_QUALIFIED</code>. It is evidence for review, not a certificate, and Fid is not suitable for medical, automotive or avionics use.</li>\n</ul>\n<h2 id=\"speed-and-tooling\">Speed and tooling</h2>\n<ul>\n<li><code>fid emit</code> runs a small IR optimizer: inlining of small single-block functions, constant folding, dead code removal. Native code still has no full register allocator.</li>\n<li><code>core.fd</code> is type-checked once per compiler and core version; the build cache evicts past 64 files or 1 GB.</li>\n<li><code>bench/run.sh</code> and <code>bench/check.sh</code> flag slowdowns against a baseline (not in CI).</li>\n<li>Self-compile to C takes about 133 s (type check 59 s); the stage 2 and stage 3 C are byte-identical, 49 MB.</li>\n</ul>\n<h2 id=\"written-not-run-yet\">Written, not run yet</h2>\n<p><code>fid emit --checked-alloc</code> (guard pages for native builds), <code>scripts/sanitize.sh</code> (ASan/UBSan through C), and a nightly fuzzing script.</p>\n<h2 id=\"still-open\">Still open</h2>\n<p>Value semantics: copy-on-write for <code>Vec</code> and <code>HashMap</code> is written but off, because the compiler runs out of memory compiling itself with it, so <code>var b = a</code> on a <code>Vec</code> still aliases. Also open: native async, a full register allocator, macOS, native ELF, ARM64/RISC-V/WebAssembly backends, and bare metal (<code>emit --bare</code> panics).</p>"},{"id":"https://fid-lang.org/changelog/session-36-integers-allocator","url":"https://fid-lang.org/changelog/session-36-integers-allocator","title":"One integer meaning, sound builds, a real allocator","summary":"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.","date_published":"2026-11-01T00:00:00.000Z","content_html":"<p>Session 36 was a semantics-and-soundness session: fewer ways for the three backends to disagree, and a real memory story underneath them.</p>\n<h2 id=\"integers-mean-one-thing-now\">Integers mean one thing now</h2>\n<ul>\n<li><code>add</code>/<code>sub</code>/<code>mul</code>/<code>neg</code> are <strong>checked at the declared width</strong> on the interpreter, C, and native paths: <code>i8</code> overflows at <code>i8</code>, not at <code>i64</code>. <code>@wrapping</code> wraps at the declared width, division by zero always panics, and <code>u64</code> is genuinely unsigned. (Lowering used to carry <code>i64</code> for every integer op, which was the root cause of most backend disagreements.)</li>\n</ul>\n<h2 id=\"memory-actually-managed\">Memory, actually managed</h2>\n<ul>\n<li><strong><code>p_free</code> is honest</strong>: double-free and freeing a pointer that is not a live heap block panic on all backends. It already caught a real leak: <code>rc.fd</code> counters allocated through plain <code>malloc</code> were never freed.</li>\n<li><strong>Size-class allocator</strong> behind <code>malloc</code>/<code>free</code>.</li>\n<li><strong>Automatic <code>Vec</code> reclamation</strong>: an IR escape pass frees local <code>Vec</code>s that provably never escape: the dropped-Vec benchmark went from 544 MB peak to 6 MB.</li>\n</ul>\n<h2 id=\"faster-self-hosting\">Faster self-hosting</h2>\n<p>Self-hosted type checking of the compiler went from about 205 s to 15 s, with <code>Vec_get</code>/<code>Vec_len</code> inlined natively.</p>\n<h2 id=\"bugs-that-were-invisible\">Bugs that were invisible</h2>\n<p><code>p_system</code> crashed every native program on return; a <code>pert_str_hash</code> edge case could lose <code>HashMap</code> keys near page ends; hex literals above <code>i64::MAX</code> read as 0 on <code>fidesc</code>; 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 (<code>scripts/check-stdlib.sh</code>).</p>"},{"id":"https://fid-lang.org/changelog/native-emit-fixpoint","url":"https://fid-lang.org/changelog/native-emit-fixpoint","title":"The native emitter reproduces itself bit-for-bit","summary":"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.","date_published":"2026-10-30T00:00:00.000Z","content_html":"<p>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.</p>\n<h2 id=\"the-fixpoint-natively\">The fixpoint, natively</h2>\n<ul>\n<li><code>fid-n5.exe emit compiler/main.fd</code> → <code>fid-n6.exe</code>, <strong>byte-identical</strong> (12,304,896 bytes). The natively-emitted compiler reproduces itself bit-for-bit: no C toolchain anywhere in the loop.</li>\n<li>Cross-emitter parity too: the native-emit binary and the C-compiled binary are byte-for-byte identical on the same source.</li>\n<li><strong>Faster than the C path</strong>: <code>dump-c</code> on the full compiler in 3m21s vs 4m21s for the C-built compiler. <code>fid emit</code> on a typical test file runs about 50 ms of actual codegen.</li>\n</ul>\n<h2 id=\"speed-work-in-the-pe-emitter\">Speed work in the PE emitter</h2>\n<p>Bulk <code>strlen</code>/<code>memcpy</code> string stubs (was byte loops), <code>rep movsq</code> struct copies, word-at-a-time hashing, a store→load forwarding peephole (−1,468 loads in a small exe), <code>cmp</code>+<code>jcc</code> fusion, slot reuse that shrank stack frames from ~140 KB to ~1.28 KB max, and inlining of <code>p_vec_len</code>/<code>p_map_len</code>/<code>*_is_empty</code>.</p>\n<h2 id=\"correctness-catches\">Correctness catches</h2>\n<p>Windows <strong>guard-page stack probes</strong> for frames over 4 KB (the missing piece behind deep-recursion crashes), <code>p_string_starts_with</code> actually compares now (it was a stub returning true), and emit is deterministic: free-slot order no longer depends on <code>HashMap</code> iteration.</p>"},{"id":"https://fid-lang.org/changelog/self-hosted-release-compiler","url":"https://fid-lang.org/changelog/self-hosted-release-compiler","title":"The self-hosted compiler is now the release compiler","summary":"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.","date_published":"2026-10-27T00:00:00.000Z","content_html":"<p>Sessions 31-34 crossed the line that turns self-hosting from a party trick into the product: <strong>the compiler you download is the compiler written in Fid.</strong></p>\n<h2 id=\"what-shipped\">What shipped</h2>\n<ul>\n<li><strong><code>fid.exe</code> is the release binary.</strong> The Windows installer now ships the self-hosted compiler (<code>release/fid.exe</code>, built by <code>RELEASE=1 ./scripts/bootstrap.sh</code>) with the Rust bootstrap compiler beside it as <code>fidesc.exe</code>. v1.0.0’s <code>fides.exe</code> name is retired.</li>\n<li><strong>Release bootstrap with fixpoint check</strong>: 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.</li>\n<li><strong>Test parity</strong>: <code>fid run</code> matches <code>fidesc</code> on all 302 test programs and all 10 examples; <code>fid ccompile</code> on 242/243 (<code>test_sqlite</code> needs libsqlite3; the Rust compiler fails it the same way); all expected-fail tests rejected.</li>\n<li><strong>A Fides runtime for the PE backend</strong>: <code>stdlib/pe_runtime/</code> (the <code>p_X</code> → <code>pert_X</code>/<code>pe_*</code> builtins merged into every <code>emit</code>) means native Windows executables now run the entire test suite (threads, channels, <code>select</code>, async, tensors, JSON, files) with no C compiler anywhere in the loop.</li>\n<li><strong>Reproducible and incremental builds</strong>: an artifact store keyed on content hashes kills stale-binary bugs; <code>fid ccompile --inc</code> builds one translation unit per module and caches the objects.</li>\n</ul>\n<h2 id=\"fixes-that-made-parity-possible\">Fixes that made parity possible</h2>\n<p><code>@conserve</code> now actually rejects non-conserving calls (it used to only check effects), second <code>impl</code> blocks in imported modules are kept, <code>extern \"C\" link \"lib\"</code> 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.</p>"},{"id":"https://fid-lang.org/changelog/hardening-sessions-27-30","url":"https://fid-lang.org/changelog/hardening-sessions-27-30","title":"Soundness passes: escape analysis, sound security annotations, verified constant-time","summary":"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.","date_published":"2026-10-25T00:00:00.000Z","content_html":"<p>Between sessions 27 and 30 the compiler stopped trusting its own good intentions and started proving things: about user code and about itself.</p>\n<h2 id=\"references-can-no-longer-dangle\">References can no longer dangle</h2>\n<ul>\n<li><strong>Second-class references</strong> (<code>src/escape.rs</code>, <code>compiler/escape.fd</code>): a <code>&#x26;T</code> / <code>&#x26;mut T</code> 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.</li>\n<li><strong><code>Vec&#x3C;f64></code> reads and <code>f64</code> returns</strong> fixed on all three backends on the way, and the fixpoint was re-verified after the change.</li>\n</ul>\n<h2 id=\"security-annotations-made-sound\">Security annotations made sound</h2>\n<ul>\n<li><strong><code>@tainted</code></strong> 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.</li>\n<li><strong><code>@zeroize</code></strong> now wipes heap data too, not just stack slots: PE output verified byte-for-byte on the affected tests.</li>\n<li><strong>Post-codegen constant-time verification</strong>: after the peephole stage, <code>verify_constant_time_asm</code> scans the <em>final</em> x86-64 assembly of a <code>@constant_time</code> function for conditional/indirect jumps, memory <code>cmov</code>, 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.)</li>\n<li><strong><code>cast_arg</code> ABI repair</strong> in both C codegens heals <code>&#x26;mut Vec</code> → <code>Vec</code> forwards, and <code>cl.exe</code> linking was fixed on Windows (<code>cmd /C</code> quote-stripping).</li>\n</ul>\n<h2 id=\"branch-consolidation\">Branch consolidation</h2>\n<p><code>release-infra</code> merged into <code>main</code>; 92 <code>&#x26;mut</code> call sites removed; <code>str_equal</code> replaced by plain <code>==</code>; the bootstrap fixpoint re-verified byte-for-byte afterward.</p>"},{"id":"https://fid-lang.org/changelog/resumable-effects","url":"https://fid-lang.org/changelog/resumable-effects","title":"Resumable effect handlers, structured concurrency, graph-coloring regalloc","summary":"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.","date_published":"2026-09-13T00:00:00.000Z","content_html":"<p>The concurrency and effects story is complete at the language level. Everything below is in <code>main</code> and covered by tests (<code>test_effect_resume</code>, <code>test_effect_noresume</code>, <code>test_effect_compose</code>, <code>test_spawn_scope</code>, <code>test_cancellation</code>).</p>\n<h2 id=\"effect-handlers-with-continuations\">Effect handlers with continuations</h2>\n<ul>\n<li><strong><code>resume(cont, value)</code></strong>: a handler arm can now continue the <code>handle</code> block from the point of the <code>do</code>, with <code>value</code> as the result of the effect. New keyword, AST node, parser, type checker, and lowering.</li>\n<li><strong>Continuation capture at lowering time</strong>: the statements after a <code>do</code> are captured as a continuation closure (lambda-lifted, called through <code>CallPtr</code>), so there is no runtime scheduler and no hidden allocation behind an effect.</li>\n<li><strong>No resume means no continuation</strong>: a handler that returns without <code>resume</code> drops the rest of the block, which gives cooperative cancellation for free.</li>\n<li><strong>Chaining</strong>: multiple <code>do</code> statements in one block each capture their own continuation; nested handlers resolve at the nearest enclosing <code>handle</code>.</li>\n</ul>\n<h2 id=\"structured-concurrency-and-cancellation\">Structured concurrency and cancellation</h2>\n<ul>\n<li><strong><code>spawn scope { … }</code></strong>: a scope-owned executor runs every <code>spawn</code> inside the block and joins them all at the closing brace. Tasks cannot outlive their scope.</li>\n<li><strong><code>cancel scope;</code></strong>: cancels all pending tasks in the enclosing scope, backed by the new <code>p_executor_cancel</code> runtime builtin.</li>\n<li><strong><code>do Cancel.stop()</code></strong>: cooperative cancellation through effect dispatch.</li>\n<li><strong>No function coloring, verified</strong>: any function is callable from synchronous code, a spawned task, or a handler body; there is no <code>async fn</code> / <code>fn</code> split to maintain.</li>\n</ul>\n<h2 id=\"async-io-as-effects\">Async I/O as effects</h2>\n<ul>\n<li><code>do IO.read</code> / <code>do IO.write</code> and <code>do Net.accept</code> 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.</li>\n</ul>\n<h2 id=\"compiler-and-backends\">Compiler and backends</h2>\n<ul>\n<li><strong>Graph-coloring register allocator</strong> (Chaitin-Briggs) added alongside linear scan, with function alignment for the native backends.</li>\n<li><strong>Deterministic PE code generation</strong>: the Windows emitter now produces identical bytes for identical input, build after build.</li>\n<li><strong>Cached parsing</strong>: repeated compiles of unchanged modules skip the parser.</li>\n<li><strong>Struct globals in the C backend</strong>: initialized correctly as inline values.</li>\n</ul>\n<h2 id=\"standard-library\">Standard library</h2>\n<ul>\n<li>104 modules. New since 1.0: <code>arena</code> (bump allocator with O(1) bulk free), <code>template</code> (typed template rendering), <code>plot</code> (SVG line/bar/scatter plots), <code>data</code> (CSV loading and schema inference), and <code>game</code> (an ECS-plus-frame-arena engine framework in which Fid is its own scripting language).</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/fixpoint-verified","url":"https://fid-lang.org/changelog/fixpoint-verified","title":"Bootstrap fixpoint verified byte-for-byte","summary":"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.","date_published":"2026-09-12T00:00:00.000Z","content_html":"<p>The milestone every self-hosted compiler aims for: the compiler compiles itself, the result compiles itself again, and the output stops changing.</p>\n<pre><code>fides-c3.exe → fides-c.exe (gen 1) → fides-c2.exe (gen 2)\n→ fides-c3_new.exe (gen 3) → fides-c4.exe (gen 4) → fides-c5.exe (gen 5)\n\ncmp fides-c4.c fides-c5.c → identical (29,763,762 bytes)\n</code></pre>\n<ul>\n<li><strong>The fixpoint converges at generation 4/5.</strong> 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.</li>\n<li><strong>Self-compilation runs clean end to end.</strong> 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 <code>stdlib/time.fd</code> parses again.</li>\n<li><strong>Seven Rust-to-Fid gaps closed</strong>: bounds-aware <code>str_substring</code> in <code>pir.fd</code>, a real <code>--lto</code> mode in <code>opt.fd</code>, <code>DynCall</code> and <code>TryUnwrap</code> code generation in <code>codegen_c.fd</code>, inline struct globals, the standalone Linux x86-64 code generator ported to <code>compiler/x86.fd</code>, 19 additional CLI commands in <code>main.fd</code> (debug, autopsy, gpu, link, parse-header, profile, qualify, repl, replay, sbom, spdx, …), and autograd plus PRNG support in <code>interp.fd</code>.</li>\n<li><strong>New IR instruction</strong>: <code>StructCopy(dst, src, ty)</code> for struct-by-value copies.</li>\n<li><strong>Updated stats</strong>: 52 compiler modules, 100,934 LOC of Fid; 104 standard library modules; 304 test programs.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/v1-0-0","url":"https://fid-lang.org/changelog/v1-0-0","title":"v1.0.0: First stable release","summary":"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.","date_published":"2026-09-09T00:00:00.000Z","content_html":"<p>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.</p>\n<h2 id=\"download\">Download</h2>\n<ul>\n<li><strong>Windows installer:</strong> <code>Fides-Setup-1.0.0.exe</code> (2.5 MB) from <a href=\"https://github.com/pledgeandgrow/fid/releases/tag/v1.0.0\">GitHub Releases: v1.0.0</a></li>\n<li><strong>From source:</strong> <code>cargo build --release</code>, then use <code>./target/release/fidesc</code> or build the self-hosted compiler.</li>\n<li>See the <a href=\"/docs/install\">Installation guide</a>.</li>\n</ul>\n<h2 id=\"self-hosted-compiler\">Self-hosted compiler</h2>\n<ul>\n<li><strong>3 bootstrap generations verified</strong> (Rust → c1 → c2 → c3, all work): the self-hosted compiler (50 modules, 93,605 LOC in <code>compiler/*.fd</code>) type-checks and borrow-checks the full compiler. The byte-identical fixpoint (<code>fides-c2.c == fides-c3.c</code>) 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.</li>\n<li><strong>38/38 self-host tests pass</strong> on all three backends (Interpreter, C Codegen, PE Emitter): 0 regressions.</li>\n<li>The Rust compiler (<code>src/*.rs</code>) remains as the bootstrap reference and is only needed when changing compiler internals.</li>\n</ul>\n<h2 id=\"windows-installer\">Windows installer</h2>\n<ul>\n<li><strong>NSIS installer</strong> (<code>Fides-Setup-1.0.0.exe</code>, 2.5 MB): tested and working on Windows.</li>\n<li>Installs the compiler (<code>fides.exe</code>), the full standard library (99 modules), the C runtime, documentation, and examples.</li>\n<li>PATH integration (system-wide), <code>.fd</code> file association, and Start Menu shortcuts.</li>\n<li>Uninstaller via Add/Remove Programs.</li>\n<li>A GitHub Actions workflow builds the installer automatically on tagged releases.</li>\n</ul>\n<h2 id=\"standard-library\">Standard library</h2>\n<ul>\n<li>99 language-level modules (OS modules moved to the separate <code>fides-os</code> project).</li>\n<li>26 game/media modules added in Session 21 (SDL, OpenGL, physics, audio, networking, and more).</li>\n</ul>\n<h2 id=\"test-baseline\">Test baseline</h2>\n<ul>\n<li>265/265 unit tests pass, 0 skipped, 0 known-fail.</li>\n<li>Interpreter: 164/165 normal tests. C Codegen: 164/165 matched. PE Emitter: 165/165 valid.</li>\n<li>Cross-compilation to x86-64, ARM64, RISC-V, and Windows, all producing valid executables with zero external tools.</li>\n</ul>\n<h2 id=\"recent-language-features-session-23\">Recent language features (Session 23)</h2>\n<p>Six high-priority language features landed just before release:</p>\n<ul>\n<li><strong><code>@zeroize</code> (F88)</strong>: compiler-inserted <code>memset(0)</code> at scope exit for secrets.</li>\n<li><strong><code>@secret</code> (F74)</strong>: information-flow control: secrets cannot reach output sinks.</li>\n<li><strong><code>@interrupt(N)</code> (F29)</strong>: interrupt handler annotation with automatic IDT setup.</li>\n<li><strong><code>@firmware</code> (F30)</strong>: rejects OS-dependent calls in bare-metal code.</li>\n<li><strong><code>parallel { | }</code> (F13)</strong>: fork-join syntax via a contextual keyword.</li>\n<li><strong><code>@simd</code> (F23)</strong>: aggressive loop vectorization (wider vectors, relaxed cost).</li>\n</ul>\n<p>Test baseline improved: +2 interpreter, +1 C codegen, 0 regressions.</p>"},{"id":"https://fid-lang.org/changelog/batch-19","url":"https://fid-lang.org/changelog/batch-19","title":"Update 19: Self-hosting underway","summary":"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.","date_published":"2026-08-29T00:00:00.000Z","content_html":"<p>The compiler is being rewritten in the language it compiles, and the milestone numbers are real.</p>\n<ul>\n<li><strong>10 of 10 rewritten modules compile.</strong> Token, diagnostics, JSON, formatter, AST, lexer, parser, IR, typechecker, and lowerer: 22,526 lines of Rust have become 18,329 lines of Fid.</li>\n<li><strong>The parser</strong> (<code>parser.fd</code>, 4,989 lines, 91 functions) compiles to a <strong>384KB native executable</strong> via <code>fidesc build</code>: no assembler, no linker, no C compiler.</li>\n<li><strong>The lexer and formatter are verified</strong>: both produce output identical to their Rust counterparts across all 240 test files.</li>\n<li><strong>The IR module is done</strong>: 25 tests passing on the interpreter, C codegen, and PE emitter.</li>\n<li>The typechecker (4,813 lines) and lowerer build to native binaries; differential testing against the Rust originals is the next step.</li>\n</ul>\n<p>Still ahead: the monomorphizer and borrow checker rewrites, then the back end, then the bootstrap moment: Fid compiling Fid compiling Fid, with a <code>diff</code> 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.</p>"},{"id":"https://fid-lang.org/changelog/batch-18","url":"https://fid-lang.org/changelog/batch-18","title":"Update 18: A clean bill of health","summary":"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.","date_published":"2026-08-28T00:00:00.000Z","content_html":"<p>Before starting the self-host rewrite, the project audited itself, and fixed everything the audit found.</p>\n<ul>\n<li><strong>Skip list: 42 → 0.</strong> 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 <code>Vec_push</code> and other side-effecting runtime calls.</li>\n<li><strong>Known-fail list: 10 → 0.</strong> 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.</li>\n<li><strong>The baseline now:</strong> 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.</li>\n<li><strong>Debugging infrastructure</strong>: <code>dump-tokens</code>/<code>dump-ast</code>/<code>dump-ir</code>/<code>dump-pir</code>/<code>dump-c</code> commands, a <code>diff-test</code> command that compares every compiler stage against golden files, <code>--trace</code> per-stage timing, a configurable <code>--max-recursion</code> limit, and an iterative parser fallback that survives 1000-level nested expressions.</li>\n<li><strong>Stdlib for compiler-writers</strong>: <code>assert_msg</code>/<code>assert_eq_msg</code> with f-string formatting, binary file I/O, and a full set of string utilities.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/syntax-v1","url":"https://fid-lang.org/changelog/syntax-v1","title":"Syntax v1.0: Standard keywords","summary":"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.","date_published":"2026-08-26T00:00:00.000Z","content_html":"<p>The final Fid syntax, adopted ahead of self-hosting. The original signature keywords are replaced with standard, universally understood ones.</p>\n<h2 id=\"the-changes\">The changes</h2>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n<table><thead><tr><th>Old</th><th>New</th></tr></thead><tbody><tr><td><code>pf</code></td><td><code>fn</code></td></tr><tr><td><code>pv</code></td><td><code>val</code></td></tr><tr><td><code>pv mut</code></td><td><code>var</code></td></tr><tr><td><code>pc</code></td><td><code>const</code></td></tr><tr><td><code>ret</code></td><td><code>return</code></td></tr><tr><td><code>ty</code></td><td><code>type</code></td></tr><tr><td><code>pm</code></td><td>removed; use <code>var x: T;</code></td></tr></tbody></table>\n<p><code>cap</code> (capabilities/traits) and <code>use ... with { ... }</code> (capability grants) are kept. They are short, distinct, and part of Fid’s identity.</p>\n<h2 id=\"why\">Why</h2>\n<ul>\n<li><strong>Familiar over unique</strong>: every new user previously had to learn six unfamiliar keywords before writing a line of code.</li>\n<li><strong>AI-native</strong>: models are trained on billions of lines using <code>fn</code>- and <code>return</code>-style keywords; the original spellings fought that familiarity for zero benefit.</li>\n<li><strong>Self-hosting</strong>: the compiler will be written in Fid itself. Standard keywords make its source readable to every contributor.</li>\n<li><strong>Zero cost</strong>: keyword spelling has no effect on compile speed, binary size, or runtime performance.</li>\n</ul>\n<p>The <code>val</code>/<code>var</code> pair (from Kotlin/Scala/Swift) gives a clean three-keyword binding model with <code>const</code> for compile-time values, and <code>var</code> without an initializer replaces the old <code>pm</code> keyword, backed by the same definite-assignment analysis.</p>\n<p>Migration is mechanical: a single ordered find-and-replace converts a whole codebase. See the <a href=\"/docs/migration\">migration guide</a> for the script and edge cases.</p>"},{"id":"https://fid-lang.org/changelog/batch-17","url":"https://fid-lang.org/changelog/batch-17","title":"Update 17: AI & LLM serving","summary":"Tape-based autodiff, layer/model keywords, GPU kernels, INT8 quantization, KV-cache regions with budgets, checkpointing, and LoRA hot-swap.","date_published":"2026-08-22T00:00:00.000Z","content_html":"<p>The AI story deepened from tensors-in-the-stdlib to language-level ML semantics.</p>\n<ul>\n<li><strong><code>layer</code> / <code>model</code> keywords</strong>: desugar to plain structs and impls, so a network definition reads like the math: <code>x |> self.l1.forward |> relu |> self.l2.forward</code>.</li>\n<li><strong>Pipeline operator <code>|></code></strong>: <code>x |> f |> g</code> is <code>g(f(x))</code>, resolved at parse time.</li>\n<li><strong>Compile-time shape safety</strong>: <code>Tensor&#x3C;f32, [784, 128]></code> with symbolic batch dimensions; <code>matmul</code>, <code>conv2d</code>, <code>concat</code>, and friends are shape-checked before the program runs.</li>\n<li><strong>Tape-based autodiff</strong>: <code>grad(w) { ... backward(loss); }</code> records and replays a gradient tape (interpreter runtime; IR support across backends).</li>\n<li><strong>GPU kernels</strong>: <code>@kernel</code> functions with <code>thread_id()</code> / workgroup builtins compile to SPIR-V, with a CPU fallback so kernels are testable in the interpreter.</li>\n<li><strong>Quantization</strong>: the <code>~> q8</code> cast operator, symmetric INT8 parameters, <code>qmatmul</code>, and dequantization.</li>\n<li><strong>LLM serving primitives</strong>: 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 <code>persist</code>.</li>\n</ul>\n<p>Honesty note: checkpointing, DP, and tensor parallelism are partial (interpreter-level or single-rank simulation today); see <a href=\"/docs/feature-status\">Feature Status</a>.</p>"},{"id":"https://fid-lang.org/changelog/batch-16","url":"https://fid-lang.org/changelog/batch-16","title":"Update 16: The tooling ecosystem","summary":"A package manager (pacte), doc generator (scribe), coverage tool (veil), formatter, linter, benchmarker, debuggers, and a 23-pass optimizer with incremental compilation.","date_published":"2026-08-20T00:00:00.000Z","content_html":"<p>The toolchain grew from a compiler into an ecosystem: still one codebase, now four binaries.</p>\n<ul>\n<li><strong><code>pacte</code></strong>: the package manager. <code>init</code>, <code>add</code> (path and git dependencies), <code>install</code>, <code>lock</code>, <code>update</code>, and more, with a <code>pacte.toml</code> manifest, a <code>pacte.lock</code> lock file, and a built-in TOML parser. Zero external dependencies; a registry is planned.</li>\n<li><strong><code>scribe</code></strong>: the documentation generator. Extracts <code>///</code> doc comments from <code>.fd</code> files and produces styled HTML or Markdown with navigation, signatures, and parameter tables.</li>\n<li><strong><code>veil</code></strong>: the coverage tool. Tracks function, line, and instruction coverage and reports as annotated text or HTML.</li>\n<li><strong><code>fidesc fmt</code> / <code>lint</code> / <code>bench</code> / <code>profile</code></strong>: formatter, linter (unused functions and imports), benchmark runner with timing statistics, and a per-function profiler.</li>\n<li><strong><code>fidesc debug</code> / <code>autopsy</code> / <code>replay</code></strong>: an interactive debugger (breakpoints, stepping, locals), a native ptrace-based debugger, and execution-trace replay.</li>\n<li><strong>Optimizer maturity</strong>: 23 passes (const-fold, CSE, GVN, SROA, inlining, TCO, loop vectorization, region pooling, effect-aware reordering, and more), enabled by default in <code>build</code> with <code>--lto</code> for cross-module inlining. 19 of the passes run in parallel across CPU cores.</li>\n<li><strong>Incremental compilation</strong>: optimized modules are cached by source hash, shared across the LSP server, watch mode, and the test harness.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-15","url":"https://fid-lang.org/changelog/batch-15","title":"Update 15: Cross-compilation, zero tools","summary":"One build command now targets ARM64 Linux, RISC-V Linux, and Windows from any host, with instruction encoders, runtimes, and linker all built in.","date_published":"2026-08-18T00:00:00.000Z","content_html":"<p>The zero-external-tools philosophy now spans architectures. <code>fidesc build --target &#x3C;t></code> cross-compiles with no assembler, no linker, and no C compiler installed:</p>\n<ul>\n<li><strong>ARM64 Linux</strong> (<code>--target arm64-linux</code>): a built-in AArch64 instruction encoder plus a libc-free runtime speaking raw SVC syscalls. A hello world is a 27KB ELF64.</li>\n<li><strong>RISC-V Linux</strong> (<code>--target riscv64-linux</code>): a built-in RV64 encoder (all six instruction formats plus pseudo-instructions) and a raw ECALL syscall runtime. 29KB.</li>\n<li><strong>Windows</strong> (<code>--target x86-64-windows</code>): the direct PE emitter wired into the unified build command. 98KB.</li>\n<li><strong>Target-aware integrated linker</strong>: handles ARM64 relocations (BL, B.cond, ADRP/ADD:lo12) and RISC-V relocations (JAL, branches) in-process.</li>\n<li><strong>Object files in three formats</strong>: <code>fidesc codegen</code> emits relocatable ELF64, Mach-O, and COFF objects for integration with existing toolchains.</li>\n</ul>\n<p>47 new cross-compilation encoder and runtime unit tests, zero regressions.</p>"},{"id":"https://fid-lang.org/changelog/batch-14","url":"https://fid-lang.org/changelog/batch-14","title":"Update 14: Security hardening","summary":"Binary hardening on by default, @constant_time against timing side channels, @tainted against injection, and stack traces on panic.","date_published":"2026-08-16T00:00:00.000Z","content_html":"<p>Security went from a capability model to a full hardening posture.</p>\n<ul>\n<li><strong>Binary hardening by default</strong>: every C-codegen binary ships with stack canaries (<code>-fstack-protector-strong</code>), PIE/ASLR, full RELRO, and a non-executable stack. No opt-in required.</li>\n<li><strong><code>@constant_time</code></strong>: a compile-time defense against timing side channels (Spectre-class and cache-timing attacks). Inside a <code>@constant_time</code> function the compiler rejects early returns, IO/network/spawn effects, memory allocation, and calls to non-constant-time functions, transitively.</li>\n<li><strong><code>@tainted</code></strong>: parameters marked as untrusted user input cannot flow into dangerous sinks: SQL queries, shell commands, HTML output, or file paths.</li>\n<li><strong>Stack traces on panic</strong>: panics now print the chain of function calls that led there, in both the interpreter and native output.</li>\n<li><strong>“Did you mean?” diagnostics</strong>: the typechecker suggests corrections for misspelled variables, functions, methods, and struct fields.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-13","url":"https://fid-lang.org/changelog/batch-13","title":"Update 13: The borrow checker","summary":"Compile-time aliasing analysis with field-wise borrows, two-phase borrows, and non-lexical lifetimes: Rust-grade guarantees without lifetime annotations.","date_published":"2026-08-14T00:00:00.000Z","content_html":"<p>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 <code>Send</code>/<code>Sync</code> traits.</p>\n<p>Three rules, checked in a dedicated pass after typechecking:</p>\n<ol>\n<li>One <code>&#x26;mut</code> borrow at a time.</li>\n<li>Any number of <code>&#x26;</code> borrows, but not while a <code>&#x26;mut</code> exists.</li>\n<li>No mutation of a value while it is borrowed.</li>\n</ol>\n<p>What makes it pleasant rather than painful:</p>\n<ul>\n<li><strong>Field-wise borrows</strong>: <code>&#x26;s.x</code> and <code>&#x26;mut s.y</code> coexist; borrowing one field does not lock the whole struct.</li>\n<li><strong>Two-phase borrows</strong>: call arguments reserve first and activate later, so the common <code>v.push(v.len())</code> pattern just works.</li>\n<li><strong>Non-lexical lifetimes (NLL)</strong>: a borrow ends at its last use, not at the end of the scope, so <code>val r = &#x26;v; print(*r); v = 20;</code> compiles.</li>\n<li><strong>No annotations</strong>: there are no <code>'a</code> parameters anywhere in the language. Regions stay inferred.</li>\n<li>Controlled by <code>--borrowck=off|warn|on</code>.</li>\n</ul>\n<p>Also in this update: <code>val</code> immutability is now a hard type error on reassignment and on struct-field mutation, and <code>@send</code>/<code>@sync</code> checks landed for thread-safety annotations.</p>"},{"id":"https://fid-lang.org/changelog/batch-12","url":"https://fid-lang.org/changelog/batch-12","title":"Update 12: Safety for the real world","summary":"Compile-time financial conservation, linear types, transactions, gas budgets, crash-free proofs, contracts, and typed strings: the safety annotation cluster lands.","date_published":"2026-08-10T00:00:00.000Z","content_html":"<p>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.</p>\n<ul>\n<li><strong><code>@linear</code> types</strong>: move semantics with no duplication. A money value cannot be processed twice; consuming a linear variable inside a loop is a compile error.</li>\n<li><strong><code>@conserve</code></strong>: a compile-time financial conservation proof: money in must equal money out. Double-credit and lost-money bugs fail to compile.</li>\n<li><strong><code>txn { }</code> blocks</strong>: atomic transactions with rollback on failure.</li>\n<li><strong><code>@gas(N)</code></strong>: compile-time gas budgets for bounded-cost functions.</li>\n<li><strong><code>@crashfree</code></strong>: a compile-time proof that a function cannot panic.</li>\n<li><strong><code>@audit</code></strong>: automatic function audit logging with parameter values.</li>\n<li><strong><code>@medical</code></strong>: IEC 62304-style restrictions: no dynamic allocation, no recursion, no unbounded loops, no unwrap, must be <code>@audit</code>.</li>\n<li><strong><code>given</code> / <code>ensure</code> contracts</strong>: Design-by-Contract preconditions verified at call sites.</li>\n<li><strong>Typed strings</strong>: <code>SQLString</code>, <code>ShellString</code>, <code>HTMLString</code>, <code>JSONString</code>, <code>PathString</code>. Concatenating user input into a query is a type error, not a code-review hope.</li>\n<li><strong>Init guarantee</strong>: <code>var x: T;</code> without an initializer plus definite-assignment analysis: reading before assignment is a compile error.</li>\n<li><strong>Checked arithmetic everywhere</strong>: integer overflow panics (always on, not just in debug), with <code>@wrapping</code> as the explicit escape hatch. Bounds checks are always on, skippable only inside <code>unsafe { }</code>.</li>\n<li><strong>Stdlib support</strong>: <code>money</code> (fixed-point currency), <code>banking</code> (accounts, transfers, double-credit detection), <code>time</code> (LogicalTime: timezone-free, clock-free deterministic date math), and <code>memo</code>.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-11","url":"https://fid-lang.org/changelog/batch-11","title":"Update 11: Enhanced built-in types","summary":"49 new built-in methods across String, Vec, and HashMap, with full interpreter runtimes and native implementations for the core set.","date_published":"2026-08-06T00:00:00.000Z","content_html":"<p>The built-in collection types grew up in one push.</p>\n<ul>\n<li><strong>49 new built-in methods</strong> across <code>String</code>, <code>Vec</code>, and <code>HashMap</code>: <code>contains</code>, <code>starts_with</code>, <code>trim</code>, <code>split</code>, <code>replace</code>, <code>to_uppercase</code>, <code>parse_int</code>, <code>insert</code>, <code>remove</code>, <code>sort</code>, <code>reverse</code>, <code>get_or</code>, and more.</li>\n<li>Full runtime implementations in the interpreter; type checking and IR lowering for every method.</li>\n<li>Native x86-64 implementations in the PE emitter for the core set (<code>len</code>, <code>is_empty</code>, <code>clear</code>, <code>first</code>, <code>last</code>, <code>contains</code>, <code>parse_int</code>, …), with stubs registered for the rest.</li>\n<li>A comprehensive collections test suite covering all 49 operations, with every test passing in the interpreter.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-10","url":"https://fid-lang.org/changelog/batch-10","title":"Update 10: The direct PE emitter","summary":"Fid now produces native Windows executables with zero external tools: no assembler, no linker, no C compiler.","date_published":"2026-08-04T00:00:00.000Z","content_html":"<p>The flagship backend landed: <code>emit</code> goes from source to a finished <code>.exe</code> <strong>with zero external tools</strong>.</p>\n<ul>\n<li>Full x86-64 instruction encoder: REX prefixes, ModR/M + SIB bytes, displacement and immediate encoding, all 16 registers.</li>\n<li>Complete PE file construction: DOS/PE headers, <code>.text</code> + <code>.rdata</code> sections, import directory, and an Import Address Table pulling <code>GetStdHandle</code>, <code>WriteFile</code>, and <code>ExitProcess</code> from <code>kernel32.dll</code>.</li>\n<li>Print, panic, and allocation runtime generated inline as machine code, with no libc anywhere in the binary.</li>\n<li>Deferred label relocation for jumps and calls; Windows x64 ABI-compliant stack frames.</li>\n</ul>\n<h2 id=\"bugs-worth-remembering\">Bugs worth remembering</h2>\n<p>Three subtle codegen bugs were found and fixed along the way:</p>\n<ol>\n<li><strong>Swapped REX.R/REX.B bits</strong> in register-to-register moves, so any <code>mov</code> involving R8-R15 selected the wrong register, causing access violations.</li>\n<li><strong>A 64-bit store clobbering adjacent stack data</strong>: zeroing a 4-byte variable wrote 8 bytes, silently corrupting the neighboring newline and digit bytes.</li>\n<li><strong>An off-by-one in integer print length</strong> that dropped the trailing newline.</li>\n</ol>\n<p>Output now matches the interpreter and MASM backends byte-for-byte, and exit codes propagate correctly.</p>"},{"id":"https://fid-lang.org/changelog/batch-9","url":"https://fid-lang.org/changelog/batch-9","title":"Update 9: Monomorphization & module imports","summary":"Generics become zero-cost via per-call-site specialization, and use imports resolve real files from disk.","date_published":"2026-08-04T00:00:00.000Z","content_html":"<ul>\n<li><strong>Generics are now zero-cost</strong>: every generic call site gets a specialized non-generic copy (<code>identity__i64</code>), including generic methods on structs.</li>\n<li><code>use foo::bar</code> resolves real files from disk (<code>&#x3C;path>.fd</code> or <code>&#x3C;path>/mod.fd</code>), with module merging and visibility enforcement.</li>\n<li>Import errors come with “did you mean…” suggestions (Levenshtein distance).</li>\n<li>The core standard library is auto-included in every program, and user definitions always win on conflict.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-8","url":"https://fid-lang.org/changelog/batch-8","title":"Update 8: C codegen backend","summary":"A portable backend: SSA IR to C99 source, compilable with MSVC, GCC, or Clang, with automatic MSVC discovery on Windows.","date_published":"2026-08-04T00:00:00.000Z","content_html":"<ul>\n<li>New portable backend: SSA IR → C99 source, compilable with MSVC, GCC, or Clang.</li>\n<li>Automatic MSVC discovery and environment setup on Windows (<code>find_cl</code>, <code>vcvarsall.bat</code>).</li>\n<li>Polymorphic <code>print</code> dispatch, struct typedefs, and basic-block <code>goto</code> control flow.</li>\n<li>Careful renaming to dodge C macro conflicts: <code>main</code> → <code>main_entry</code>, plus <code>#undef</code> guards for MSVC’s <code>max</code>/<code>min</code>/<code>abs</code>.</li>\n</ul>\n<p>The C backend doubles as a verification tool: output parity across the interpreter, C, and native backends catches codegen bugs early.</p>"},{"id":"https://fid-lang.org/changelog/batch-7","url":"https://fid-lang.org/changelog/batch-7","title":"Update 7: Lowering the language","summary":"The interpreter learned most of the language in one push: arrays, match expressions, methods, tuples, enums, closures, and defer.","date_published":"2026-08-04T00:00:00.000Z","content_html":"<p>One large push took most of the surface language from “parses” to “runs”:</p>\n<ul>\n<li><strong>Arrays</strong>: literals, indexing, element assignment, compound assignment, and <code>for</code> loops over arrays.</li>\n<li><strong><code>match</code> as an expression</strong>, with string, range, and enum-variant patterns.</li>\n<li><strong>Struct methods</strong> with SRET returns, <strong>tuples</strong>, <strong>enums with payloads</strong>, the <strong><code>?</code> operator</strong>, <strong>closures</strong> via lambda lifting, and <strong><code>defer</code></strong> blocks that run before every return.</li>\n<li>Typed allocas throughout the lowerer, so loads now carry correct types instead of defaulting to <code>i64</code>.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-6","url":"https://fid-lang.org/changelog/batch-6","title":"Update 6: SSA IR, x86-64 backend & interpreter","summary":"The compiler grew its middle and back ends: a typed SSA IR, full AST lowering, an interpreter, and a MASM x86-64 backend.","date_published":"2026-08-04T00:00:00.000Z","content_html":"<p>The compiler’s architecture took shape:</p>\n<ul>\n<li>A typed <strong>SSA intermediate representation</strong>: basic blocks, explicit terminators, an effect-set per function.</li>\n<li>Full <strong>AST → IR lowering</strong>: control flow, function calls, f-string concatenation, mutable variables via alloca.</li>\n<li>An <strong>IR interpreter</strong> (<code>run</code>) for instant iteration with no external tools.</li>\n<li>A <strong>MASM x86-64 backend</strong> (<code>build</code>) with the Windows x64 calling convention, inline print/panic runtime, and no C runtime dependency.</li>\n</ul>\n<p>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.</p>"},{"id":"https://fid-lang.org/changelog/batch-5","url":"https://fid-lang.org/changelog/batch-5","title":"Update 5: Generics, closures & error handling","summary":"Generic types and functions, the ? operator, closures in both forms, and tuples, plus the parser bug that had been blocking generics.","date_published":"2026-08-03T00:00:00.000Z","content_html":"<ul>\n<li>Generic types (<code>Option&#x3C;T></code>, <code>Result&#x3C;T, E></code>) and generic functions.</li>\n<li>The <code>?</code> operator for error propagation.</li>\n<li>Closures in block and expression form.</li>\n<li>Tuple types and literals.</li>\n<li>Fixed a parser double-advance bug that had been breaking generic function parsing: the parser was consuming one token too many after type names.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-4","url":"https://fid-lang.org/changelog/batch-4","title":"Update 4: Enums, references & modules","summary":"Enums with payload data and variant patterns, reference types, string concatenation, imports, and attributes.","date_published":"2026-08-02T00:00:00.000Z","content_html":"<ul>\n<li>Enums with payload data, variant construction (<code>Shape::Circle(3.14)</code>), and variant pattern matching.</li>\n<li>Reference types (<code>&#x26;T</code>, <code>&#x26;mut T</code>) and dereferencing.</li>\n<li>String concatenation with <code>+</code> and string patterns in <code>match</code>.</li>\n<li><code>use</code> imports and <code>#[attributes]</code>.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-3","url":"https://fid-lang.org/changelog/batch-3","title":"Update 3: Arrays, match & f-strings","summary":"Array types and indexing, match statements with five pattern kinds, and first-class f-string interpolation.","date_published":"2026-08-02T00:00:00.000Z","content_html":"<ul>\n<li>Array types, literals, and indexing.</li>\n<li><code>match</code> statements with int, bool, binding, wildcard, and enum patterns.</li>\n<li>First-class f-string interpolation: <code>f\"Hello, {name}!\"</code>, lexed with brace-depth tracking and embedded expressions re-parsed properly.</li>\n<li>Float literal codegen.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-2","url":"https://fid-lang.org/changelog/batch-2","title":"Update 2: Ranges, aliases & methods","summary":"Range-based for loops, type aliases, struct methods via impl blocks, and blocks as expressions.","date_published":"2026-08-02T00:00:00.000Z","content_html":"<ul>\n<li><code>for x in 0..10</code> and inclusive <code>0..=10</code> ranges.</li>\n<li>Type aliases.</li>\n<li>Struct methods via <code>impl</code> blocks, with method-call syntax.</li>\n<li>Blocks and <code>if</code> as expressions.</li>\n<li>Hex, binary, and octal literals with underscore separators.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/batch-1","url":"https://fid-lang.org/changelog/batch-1","title":"Update 1: The language takes shape","summary":"The original keyword set, the .fd extension, operators, control flow, and the first end-to-end feature set.","date_published":"2026-08-02T00:00:00.000Z","content_html":"<p>The language found its first shape:</p>\n<ul>\n<li>The original signature keywords, later standardized to <code>fn</code> / <code>val</code> / <code>var</code> / <code>const</code> in the <a href=\"/changelog/syntax-v1\">v1.0 syntax</a>, plus <code>cap</code>, <code>comptime</code>, <code>defer</code>, <code>spawn</code>, and <code>region</code> reserved for what was coming.</li>\n<li>The <code>.fd</code> file extension.</li>\n<li>Compound assignment, bitwise operators, boolean literals, <code>while</code> / <code>loop</code> / <code>break</code> / <code>continue</code>, mutable variables, constants, and type inference.</li>\n<li>Block comments, f-string lexing, and VS Code syntax highlighting via a TextMate grammar.</li>\n</ul>"},{"id":"https://fid-lang.org/changelog/initial","url":"https://fid-lang.org/changelog/initial","title":"The seed compiler","summary":"Where it all started: a hand-written lexer, a recursive descent parser, a basic type checker, and an ARM64 code generator.","date_published":"2026-08-01T00:00:00.000Z","content_html":"<p>The very first cut of the compiler:</p>\n<ul>\n<li>Hand-written lexer and recursive descent parser. No generators, on principle.</li>\n<li>Basic type checker covering integers, floats, strings, bools, structs, and functions.</li>\n<li>An ARM64 (AArch64) code generator.</li>\n<li>Structs, enums, functions, if/else expressions, arithmetic, comparisons, logical operators, and a <code>print()</code> builtin.</li>\n</ul>\n<p>Everything since has been built on this foundation: same philosophy, every layer custom.</p>"}]}