Why Fid
Fid is a low-level systems language with compile-time borrow checks, capability grants and effect tracking, compiled by its own toolchain, natively or through C. No LLVM. No GC.
The six payoffs
Memory safety without a GC
A borrow checker and second-class references catch aliasing and dangling-reference errors at compile time without lifetime annotations, including changes to a Vec while a loop walks it. Bounds and overflow are checked at run time. There is no garbage collector: every value has one owner and is freed when its scope ends.
Security auditors can read
Import a module with { IO } and the compiler rejects its calls to filesystem or network functions you did not grant. The check matches calls by name, does not follow calls into other functions, and is still partial.
Effects you can declare
Every side effect (!IO, !Net, !Spawn) is inferred across the call graph; a function that declares fewer is rejected. A function that takes a function value gets the effects of the function passed at each call.
A toolchain without LLVM
fid emit writes the executable itself: no assembler, linker or C compiler. That covers Windows x64 and, partly tested, static Linux executables for x86-64, ARM64 and RISC-V. Every other target goes through C; macOS and WebAssembly are experimental.
Owned and borrowed strings
str is owned and &str borrowed. Strings of a @scoped struct cannot be kept past it, so http_serve_scoped frees each request after its response, checked at compile time.
Safety rules with evidence
17 safety rules (@no-alloc, @no-recursion, @crashfree, @firmware, @gas, @constant_time, …), each with negative tests. fid qualify writes the evidence as JSON and marks it NOT_QUALIFIED: it is not a certification, and Fid is not suitable for medical, automotive or avionics use.
The honest status
v1.0.0 stable is planned for December; v0.8.0-unstable is a prerelease and later work is on the main branch. The compiler, fid, is 72 modules and about 210K lines of Fid, and builds itself through C to a byte-identical fixpoint (67 MB of C, Nov 8). Last full test run (Nov 2, with the frozen Rust compiler): interpreter 339/339, C 343/343, native 345/345. Since 1.0: resumable effect handlers, spawn scope and cancellation, generics with inference, bounds and turbofish, if/match as values, @cfg, == by content, reference escape checks, one ownership rule with value semantics for Vec/HashMap, owned and borrowed strings, native Linux executables, native async, 17 safety rules with fid qualify evidence. Not yet: a full suite run with fid as the compiler under test, generated code as fast as C, macOS run on a Mac. The status map is at fid-lang.org/docs/feature-status.
Low-risk adoption, three steps
- One engineer runs the Quick Start and ports a small internal tool: about an afternoon.
- Pick a bounded workload: an internal tool, an audited payments path, a service with a clear boundary.
- Wire it in over C interop (extern "C") and measure build times, binary size, and incident surface against the incumbent. Every step is reversible.
Start here: fid-lang.org/docs/install · Docs: fid-lang.org/docs · Source: github.com/pledgeandgrow/fid