Blog
- Le cluster marchait déjà — il lui manquait la preuve
Cinquième et dernier pilier de v0.13.0 : la stabilité cluster. Pas une feature — le code tournait. Ce qui manquait, c'était la preuve (170 200 écritures, zéro divergence) et un runbook honnête sur l'enveloppe : ~240 écritures/s par leader, une fenêtre dual-leader au rejoin, et les limites nommées une à une.
- Le numéro de suivi — lithair apprend à raconter ce qui lui arrive
Deuxième pilier fermé en quatre jours : l'observabilité. Migration vers tracing sans toucher une ligne des 550 appels de log existants, un X-Request-ID qui suit chaque requête comme un colis, et un exporteur OpenTelemetry qui ne coûte rien tant qu'on ne l'allume pas.
- Le tokenizer — comment un programme apprend à lire
Chapitre 2 de l'arc self-hosting. Avant de comprendre un programme, il faut le découper en mots : c'est le tokenizer. On suit « x + 42 » octet par octet à travers le tokenizer écrit en verbose, on découvre pourquoi l'indentation est un casse-tête, et comment une pile de colonnes le résout.
- L'art d'éteindre proprement — lithair apprend à être opéré
Une semaine après v0.12.0, sept PRs sans paillettes : Docker, systemd, Kubernetes, runbooks de sauvegarde et de montée de version — et un seul vrai commit de code, serve_with_graceful_shutdown. Sur ce qui sépare « les features marchent » de « on peut l'exploiter en production ».
- Un programme, c'est un arbre — première brique du compilateur verbose-en-verbose
Ouverture de l'arc self-hosting : un compilateur verbose écrit en verbose. Avant tout, un compilateur doit transformer du texte en arbre (un AST). Comment verbose représente un arbre — des types sommes récursifs dans une arène indexée — et pourquoi c'est la brique qui rend tout le reste possible.
- AES sans bibliothèque — comment verbose chiffre vos données, octet par octet
Article de la série éducative — le deep-dive AES de l'arc crypto. Comment verbose implémente le chiffrement qui protège les données dans TLS : la S-box, l'arithmétique GF(2⁸) de MixColumns, les 10 tours déroulés, et le passage du bloc à l'AEAD GCM — validé bit pour bit contre les vecteurs NIST.
- Ed25519 sans bibliothèque — comment verbose prouve une identité, sans le moindre aléa
Article de la série éducative — le deep-dive signatures de l'arc crypto. Comment verbose signe et vérifie une identité avec Ed25519 : la multiplication scalaire sur courbe d'Edwards (récursive, avec preuve de terminaison), les signatures déterministes (zéro aléa, et pourquoi c'est plus sûr), validé contre les vecteurs RFC 8032.
- TLS 1.3 sans bibliothèque — un vrai navigateur fait le handshake face à du code machine verbose
Article de la série éducative — le capstone de l'arc crypto. Un vrai navigateur ouvre une page HTTPS servie par un binaire dont toute la cryptographie (échange de clés, signature, chiffrement, hash) est du code machine émis par verbose. Pas d'OpenSSL. Et le navigateur ne voit pas la différence.
- SHA-256 sans bibliothèque — le hash qui sécurise tout, écrit à la main
Article de la série éducative — ouverture de l'arc crypto. Comment verbose calcule un SHA-256 qui matche sha256sum octet pour octet, des primitives bit à bit jusqu'aux blocs multiples, en code machine natif sans aucune bibliothèque. Et la formule arithmétique qui rend le binaire plus petit en gérant plus de données.
- La dernière excuse
Vingt ans à construire pour moi, sans jamais oser montrer. L'IA n'a pas créé cette peur — elle a retiré ma dernière excuse. Sur la paternité, l'effacement, et le fait de signer enfin.
- v0.12.0: Memory-first, no longer memory-only
Lithair v0.12.0 adds memory/disk retention tiering — #[retention] and #[pinned] let a model keep its hot set in RAM while older items evict to the event store and reload on demand. The one constraint that defined the framework since launch is now a knob.
- Les registres et la pile — comment le processeur organise la memoire
Article #4 de la serie educative. Les 16 registres x86-64, la pile qui grandit vers le bas, le prologue/epilogue, call/ret, et pourquoi le stack overflow existe. Tout ce que les articles #1 a #3 supposaient sans l'expliquer.
- verbose v0.7.0 — le tokenizer est là
Phase A + Phase B + Phase C composent dans un seul binaire natif. token_scan (2260 octets) scanne des tokens Word/Num/Eof depuis du texte brut. count_tokens (1691 octets) boucle sur le flux complet.
- 38 octets de sécurité — comment verbose empêche un million de stack frames
Article #2 de la série éducative. Les 38 octets de bounds-check annotés instruction par instruction : mov r10 + cmp + jcc, l'abort tail, le backpatching, et pourquoi verbose est plus petit ET plus sûr que le C équivalent.
- Comment verbose prouve que votre programme se termine
Article #3 de la série éducative. Phase C : le compilateur vérifie mécaniquement que les règles récursives convergent — preuve structurelle, champ décroissant, champ croissant. Le breadcrumb de l'article #1 est enfin résolu.
- verbose v0.6.0
Phase B fermée, Phase C ouverte — le compilateur prouve la terminaison. Mutable service state, recursive text scanner, 12 commits en 3 jours.
- De l'idée au binaire — ou comment 30 lignes deviennent 802 octets
Premier article de la série 'Verbose — comprendre ce qui se passe vraiment'. Parcours complet du source factorial au binaire ELF : parse, vérification, émission native x86-64, exécution. Chaque instruction machine annotée. Aucun prérequis assembleur.
- Mount point chaos, a real consumer, and cidx v2.0.0
cidx v2.0.0 ships two fixes found while running cidx init on a Rust+React monorepo: rustfmt crashed because the base image doesn't ship the component, and prettier silently ran against an empty directory. Mount-path unification is the clean breaking change.
- v0.9.0: Session Gate Closes, Programmatic API Opens
Lithair v0.9.0 ships two changes from real consumer feedback: a security fix that closes a session-gate bypass in with_handler, and a new with_model_ref API that lets background workers write to models without sacrificing authentication.
- Verbose computes factorial — native recursive binaries land in Phase A
Verbose now compiles self-recursive rules to real x86-64 machine code. factorial.verbose produces an 802-byte ELF that computes n! with honest push rbp / call / ret — no interpreter, no inlining. The safety floor (cycle detection, bounds-check) ships in the same arc.
- Phase A complete, Phase B begins — recursive types land in native ELF
In 36 hours across 8 PRs, verbose closed Phase A (self-recursive and mutually-recursive rules fully native) and opened Phase B — recursive data types. concept_group types (linked lists, parse trees, ASTs) now compile to native x86-64 ELF.
- Four days, three releases
Lithair v0.7.0, v0.7.1, v0.8.0 between 2026-05-15 and 2026-05-19. Sessions gate, double-Arc footgun fix, per-model stats, opt-in auto-compaction — and the data-loss bug automated review caught before it shipped.
- verbose v0.4.0
Tagged 2026-05-15, the release that closes the tokenizer-primitive stack and lands the first slice of sum types. byte_at, fold_bytes, short-circuit and/or, sum-type concept declarations, all the way to native ELF.
- The Bottleneck Moved
Junior devs aren't getting hired. The reflex is to blame AI. The cause is structural: the bottleneck moved eighteen months ago and the system that produces the people who would do the new judgment work didn't move with it. We have eighteen months.
- The Reservoir Was Already There
AI is writing most of the keystrokes — almost none of the decisions. What that configuration looks like in 2026, when you bring twenty years of un-built ideas to it.
- The Pipeline I Refused to Write Twice
I'd been copy-pasting YAML for years. Five projects, three pipelines each, eleven Trivy invocations. Then a teammate debugged a CVE that was visible to half of them. cidx is the smallest tool I could write where all three are the same byte string.
- cidx v1.7.0
Tagged 2026-05-11, the first release after the repo flipped public. Four user-visible changes, one freshness pass, two lessons from the work.
- Reading My Own README
May 9, 2026 — cidx flipped from private to public. v1.7.0 followed two days later carrying the cleanups visibility forced, and three lessons that wouldn't have shown up while I was the only user.
- Test Isolation Is a Feature
Two bugs latent for weeks, fixed in 24 hours. Both invisible in production. Both surfaced the same way — a harness that could ask the right question.
- The Production Bug That Browsers Hid
The other evening. A freshly-published article URL returns 404 on curl -I and 200 on curl. The bug had been there for weeks. Nobody human had noticed.
- The Bytes the Auditor Can Read
An auditor lands on a refused loan applicant. Two files on disk, a short binary, and a JSONL line. The chain holds without anyone having to be trusted.
- The Same Source, A Different Machine
v0.3.0 of verbose ships a WASM back end. Same source file. Two completely different machines. The thing that surprised me wasn't the WASM bytes — it was what stayed identical.
- cidx Runs on cidx
Saturday morning. cidx is public, and the CI that proves it works is itself the tool calling itself. The dogfood is the whole meal.
- The Author Moved Up the Stack
Sonnet 4.6 wrote 9 of 10 verbose programs first-try on a hold-out. Opus 4.7 wrote 8. Compiler verified all 17. The interesting question isn't whether AI can write code — it's where that leaves me.
- The Intention, Not the Language
I've been calling verbose 'a language for verifiable code' and that's wrong. Not wrong-wrong. Just — it misses the thing. The thing isn't the language. It's where the responsibility ends up.
- The Question After the Proof
It's late. There's an HTTP server on my disk, compiled from .verbose source, three kilobytes give or take. The proof is here. And then a quieter question I'd been ducking.
- The Second Server I Stopped Keeping
lithair v0.2.0 deletes one of its two server types. The asymmetry was small until it bit. Then it was a one-day job.
- A Reverse Proxy You Can Read
verbose v0.2.0 ships file I/O, fork concurrency, outbound TCP, and audit-JSON. The reachable set of the binary is in the source. The whole reverse proxy is 14 lines and 1133 bytes.
- The Site That Runs on What It Showcases
lithair-website is tagged v0.1.0. Months of running in production, finally a version number. This is the site you're reading.
- The Tool That Pays for Its Team
A line in a tech-lead talk landed wrong. The savings argument was supposed to be a win — instead it described a tool so demanding it employs the department it required.
- A Page Load Is a SELECT Somewhere
A page load goes through a load balancer, an app server, an ORM, a database, and back. That's a lot of process boundaries for show this row to that browser. Lithair is what one tier looks like.
- DevOps Is People. The Rest Is Tooling.
DevOps started as a cultural argument about breaking silos. It got captured into an eight-stage loop, and not one of those stages is about humans. That's the heresy.
- One Config File, One Binary, One Run
Setting up three VMs and running software on them takes three tools and four files in the standard stack. For a solo operator that ratio is wrong. Configorator is what one tool, one file, one run looks like.
- What I Was Asking While Cargo Was Building
I hadn't actually written most of this code. The AI had. So why was I waiting on a compiler designed for humans? The question that started verbose.
- The Layer I Stopped Choosing
I had Cloudflare in front of arcker.org. It worked perfectly. So I switched it off — to test lithair's own reverse proxy — and the experience surfaced a question I hadn't asked.
- Hosting My Own Blog on My Own Framework
For weeks I was hosting my blog with a CDN in front, while building a framework whose pitch is "no proxy required." That gap had a name.
- When the Source Covers the Wire
verbose's bet is that the source can describe the entire behavior of the running binary. Phase 8 covers one piece that usually escapes the source: the audit trail.
- When the Source Becomes the Server
verbose was built to remove every layer between an AI's intent and the binary. For batch jobs that worked. For services, the framework was sitting in the middle. Phase 7 changes that.
- What Restarting a Node Taught Me About Trust
The first time I restarted a node in my test cluster, it came back as a blank follower asking the leader to replay the log from scratch. That moment shaped lithair's clustering work.