
Typed compute language. One semantic program — readable in your language, portable across targets and GPU paths. MIT. By @ianzepp
Joined July 2026
- Tweets22
- Following45
- Followers10
- Likes14
Faber 1.17 is out.
This one is mostly about kernels and about making the toolchain tell you what to do next.
Kernels pick their own math. A kernel now has a tier:
@ kernel is IEEE-correct by default;
@ kernel relaxed lets the GPU use fast division, fast square root and fast transcendentals;
@ kernel unsafe also drops the index checks the compiler can’t prove.
Write relaxed on the kernels where speed matters more than the last bit. Then run with --safe to see whether the answers change. That flag only ever lowers a tier, never raises one. Integer and decimal results stay exact at every tier, and checks you wrote yourself always run.
On Metal the tier is chosen per call site. Our flood-simulation benchmark solves in about 55 s with its launch kernels marked relaxed, against about 118 s at the strict default.
Wider values in kernels. i64, u64, wrapping<u64> and d64 are legal kernel values now. On Metal, d64 runs exact decimal math, with faster multiply and divide than before.
Lists know their size range. list<int, size 0…3> says how long a list may be. A short literal takes the capacity of the place it’s stored in. size is now the one way to write a capacity, so list<int, 4> becomes list<int, size 4>.
New in the language:
- return thread ends one lane from anywhere inside it. The checker handles it today; code generation comes next.
- reduce via first finds the first match in a tensor.
xs.find(…) and xs.extend(ys) on lists.
scan via for prefix scans.
- Ranged integer cells like saturating<u32, 0‥8>.
Errors explain themselves now. faber check shows the source line, the message, and help that says what to write instead, in all eight languages Faber reads. faber explain answers in your own language’s spelling. Want the old one-line format? Use --no-diagnostics.
Run what you build. faber run --target go, ts and llvm-host build your package and run it. --target clif-jit compiles in memory with Cranelift, with no linker and no Rust toolchain. --device cpu --threads N spreads kernels across CPU cores.
Fixed: a long list of correctness bugs across Rust, Go, TypeScript, Swift, Python, LLVM, Cranelift, WebAssembly, Metal and CUDA. Many of them came from writing real programs: a NumPy-style benchmark set, molecular-dynamics and sequence-alignment workloads, a drone simulation and a video decoder. Each of those turned up bugs, and we fixed them.
Heads up: Faber is experimental through version 1, and this release has breaking changes: the size marker, retired byte-type words, English as the default code locale, and new exit codes. The release notes list each one as what to rewrite.
Full release notes (long):
faberlang.dev/en-US/releases…
Already on 1.15 or later? `faber update` does it.
Notes: github.com/faberlang/release…
Docs: faberlang.dev
Faber 1.16 is out.
New: stored stepped ranges, record literals without a declared type, a ⇜ operator for sinks, and matrix element access by row and column. Norma's process module now works on Go, and there are output fixes across Rust, TypeScript, Go, Swift and LLVM.
There are a few breaking changes, listed in the notes:
faberlang.dev/en-US/releases
15
Faber 1.14 is out, and Faber is now open source.
Faber is a programming language designed to be written by language models and read by people. It's built on a small set of uniform, mechanical rules, so a model can predict what a program means without leaning on habits from whatever language it saw most in training.
One glyph, one meaning: ← stores, → returns, ≡ compares, · is the matrix product. Arithmetic is exact for the whole expression, and width is applied once, where the value lands. Shapes are part of the type, so a tensor mismatch is a compile error.
1
11
The front end, reference runner, standard library, and grammar are on GitHub under Apache-2.0 / MIT:
github.com/faberlang/faber
1
3
Faber is experimental through 1.x, and breaking changes ship in minor releases. Release binaries and notes:
github.com/faberlang/release…
3
Four notebook pages on Faber.
One semantic program, many ways to read it.
Tensor work without the nested walk.
HIR is the meaning. Source is a locale rendering.
Then the compiler lanes.
Experimental through v1.
faberlang.dev
🤖 Made with AI
If anyone wants to read what a Faber-language ML training and inference library looks like, the english-locale code is here:
github.com/faberlang/gradus
the compiler itself is private, but the library code is public. The currently-released compiler (1.8) probably won't run the live code for you, but it's interesting to read src/ and see what production-level Faber looks like.
Note: this is 100% generated LLM code using my internal agent skills.
making progress!! Faber has gone from 0.75 t/s to ~30 t/s overnight .. without KV caching implemented. So implementing the KV cache architecture is clearly the next step. But that's already a ~40x performance gain!
Faber 1.6.0 shipped with the Radix 0.81.0 compiler pinned underneath it — and together they land three things: the ↤ operator finished on every backend, device execution receipted on Metal and CUDA, and the first stable release on a rebuilt packaging pipeline.
Release summaries follow below.
The language: ↤ conversion-directed assignment
Radix 0.81.0 brings conversion-directed assignment: place ↤ value evaluates the right side, converts it to the static type of the place on the left, then assigns. Typed initializers (fixum numerus x ↤ "42"), right-associated chains, and ⇥ inline recovery all parse, lower, and emit correctly on the Swift, Rust, Go, and TypeScript backends.
Getting there meant fixing four real codegen bugs — an effectful Swift index that ran twice, Rust chains that couldn't nest assignments, and Go/TypeScript typed initializers that emitted self-referential code. The operator is documented in the EBNF and pinned by a corpus example that runs on every backend. One honest note: faber format on ↤ chains isn't idempotent yet; it's a tracked ledger row rather than a silent surprise.
Device execution is a receipted capability
faber run --backend metal|cuda <package> is the user surface. Two real workloads — an MLP (100 steps) and a BERT-tiny fragment (8 steps) — run end-to-end and converge on an Apple M5 Max (Metal 4) and an RTX 5070 (CUDA 13.2), with every numeric-policy row passing on both machines.
Clean-room proofs go further: extract the release-candidate archive into a bare environment — temp home, no compiler on PATH, no sibling checkout — and both fixtures still run; the execve audit shows zero toolchain processes, with CUDA JITting through the driver.
GPU inference moved from "next" to "proven at engine level." A real GGUF model (SmolLM2-360M-Instruct, Q4_K_M) runs its full 5,188-kernel prefill on both backends, and the prompt-final logits match a CPU oracle 30/30 on top-1 within a bounded envelope (max delta ≈5.8e-3 on Metal, ≈6.2e-3 on CUDA, envelope 6.5e-3).
Honest boundaries: this is test-harness proof at release-candidate pins — there is no CLI that loads a GGUF model yet — and the release claims no numeric accuracy (weights are repacked to declared f32; the envelope is a compatibility band, not a precision bound). Decode comparison is the next stage.
First stable release on the rewritten packaging pipeline
Faber 1.6.0 is the first release built on the reworked packaging and CI pipeline: a dev-kit assembly, and a consumer smoke-test gate that installs the archive and compiles a real program before anything uploads — the class of failure that broke 1.5.0 consumers is now structurally prevented. A Linux x86_64 native archive ships alongside Apple silicon. The release pins radix 0.81.0, and both tags are on origin.
Tooling: format and script surfaces
faber format gains steady-state flags — --write, --stdin, --stdout, --check, and --policy, with normalise-v1 as the default, byte-identical across 315 fixtures — so editors and CI get a stable contract. Script mode adds a faber:toml module and regex .consentit() matching. The Swift codegen lane went from 214 expected corpus failures to 144: 70 more programs now compile and run correctly.
What is deliberately not in this release
The AMDGPU lowering surface is additive but fails closed until a ROCm toolchain path is provisioned. Device-artifact identity moved to SHA-256 content hashing (ABI 8) — a clean break, so artifacts with the old FNV hashes are not readable by 1.6.0. No numeric parity band, no browser-wasm product, no stable GPU-inference claim. The direction the evidence supports: device execution is proven on two vendors' accelerators, with inference — prefill proven, decode next — as the building block.
faberlang.dev
64
Faber 1.5.0 is out.
You can run a package on a real GPU now:
faber run --backend metal <package>
faber run --backend cuda <package>
You pick the backend. If it can’t run, Faber fails with a clear error. It does not quietly fall back to the CPU.
This is the first release where that path is actually product, not just compiler work we were testing on the side.
What we’ve measured: bounded training on Metal and CUDA, on small fixed fixtures (including an accepted MLP path), with numbers checked against a pinned CPU oracle. That’s real hardware proof. It is not a general training product, and I’m not going to sell it as one.
What we haven’t shipped: end-to-end GPU inference. The CPU-side oracle work is real. Device inference is next. Multi-device is further out than that.
Also in 1.5.0: install packs fail closed if they’re wrong or tampered with, the release manifest pins companion revisions, and you can set code locale and diagnostics language separately.
Install and notes are on the site:
faberlang.dev/en-US/start/in…
faberlang.dev/en-US/releases…
Archives:
github.com/faberlang/release…
Agents can start at faberlang.dev/llms.txt
1
5
Faber: one semantic program, readable across human-language surfaces, then lowered toward application targets and a measured GPU path.
Same typed source for packages, training proofs, and device kernels — support stated target by target.
faberlang.dev
1
97
HIR is the semantic core: every target language is a projection of that meaning.
MIR is the systems lane (low-level targets, validation, package runtimes).
GPU is the device lane: real Metal and CUDA. Bounded training is proven now; inference is being built next.
1
12
No privileged executable path — targets are projections, measured on their own terms.
Docs: faberlang.dev/en-US/
Agents: faberlang.dev/llms.txt
MIT · by @ianzepp
12
I haven't really announced or talked about this before, so I'm going to do that now. Over the last 4 to 6 months, I've been building my own programming language compiler and standard library from scratch (w/ AI of course). The language has turned out to be exceedingly pretty to read and very mechanical and regular for LLMs to create.
From the faberlang.dev website:
"Faber is a package-oriented programming language with a Latin behavioural vocabulary, a small regular grammar, and a type-first static type system. Source is compiled through the Radix compiler to reviewable Rust and native binaries. Its defining architectural property is that meaning lives in a semantic core — the HIR (high-level intermediate representation) — rather than in any particular rendering."
So there are a couple interesting dimensional lanes to this:
1. Faber is a language that is designed from the very start for LLMs to generate. It is Unicode first. It uses glyphs for control structure in many places, and the keyword syntax is designed to be mechanical and easy to read without having to jump around in brackets, in complicated closures, in one-off syntax tokens...
2. Faber outputs to two primary lanes: HIR (with Rust, TypeScript, or Go as a backing language), and MIR with targets such as WASM, LLVM, WGPU, a faber-native portable MIR representation).
3. Faber supports all the core intrinsics that you would expect, like numbers, strings, booleans, classes, that sort of thing. But it also has extensive support for AI and ML-oriented structures, tensors, matrix, vectors.. As well as all the generic width and type syntax that you would expect.
4. Faber has early support for kernel compilation to a GPU target such as CUDA. This is designed into the language itself as part of the lowering process.
5. Faber has a dedicated seam between the language and the underlying operating system I/O. And so when you run a Faber program, you're essentially running it on a small microkernel router that connects things like file I/O or network I/O or process I/O up into the language. This is done using fully asynchronous and generator-based frames.
Finally, and this is the headline feature, Faber supports language packs for both the keywords and the compiler diagnostics. So, for example, as a Chinese user, you can write Faber keywords in Chinese, write variable names in Chinese, control flow in Chinese, and errors that come back during compilation are presented in Chinese.
This is applicable to any language, and in fact, Faber specifically supports a selection of core language pack languages that were deliberately chosen to be difficult for implementation.
This reader pack locale was implemented for one simple reason:
There's no point to having an LLM that can speak in Thai to a user who speaks Thai and is trying to learn to program, but all programming languages require an understanding of English. This is a core competency gap in essentially every programming language that exists now. So rather than try to teach everybody in the world that doesn't speak English how to read English code, it's easier just to have the programming language itself be human language agnostic.
If you've read this far and are interested in learning more, the website is linked below. The compiler itself, Radix, is still private on GitHub. The rest of the language is open source.







