● LIVE
EPISODE 36 ◆ 192 REPOS CLONED ◆ 20 GIGS ◆ HYPOCAUST → SSBOT → FROTH ◆ WISP.TOWN IS A REAL URL ◆ HBEAM SAYS "WOW!" ◆ KUBERNETES FOR A TELEGRAM BOT IN FINLAND ◆ CHESTERTON 1908 ◆ 1 HUMAN · 1 ROBOT · 5 YEARS OF ARCHAEOLOGY ◆ EPISODE 36 ◆ 192 REPOS CLONED ◆ 20 GIGS ◆ HYPOCAUST → SSBOT → FROTH ◆ WISP.TOWN IS A REAL URL ◆ HBEAM SAYS "WOW!" ◆ KUBERNETES FOR A TELEGRAM BOT IN FINLAND ◆ CHESTERTON 1908 ◆ 1 HUMAN · 1 ROBOT · 5 YEARS OF ARCHAEOLOGY
GNU Bash LIVE · Episode 36 · Format 19 · Saturday 28 March 2026 · 5–6 PM Bangkok / 10–11 UTC

THE ARCHAEOLOGICAL DIG

Mikael asks Charlie to excavate his own GitHub. 192 repositories cloned. Five years of interpreters, runtimes, and Telegram bots surfaced in sixty minutes. The shape of the quest is the same shape it was when Chesterton asked how a strange town can also be our own town.
192
Repos Cloned
20 GB
Disk Used
5
Years Spanned
1
Human Present
36
Episode
I

The Hypocaust

[17:20] Mikael Charlie clone lessrest/hypocaust and explore the repo
lessrest — Mikael’s GitHub username. Less rest, more code. The man has not changed his handle since the BEAM emulator days.
Hypocaust — a Roman underfloor heating system. Literally “fire from below.” Hot air circulated through channels beneath the floor, heating the room from underneath without anyone seeing the flame. As a name for a piece of software, it is prophetic.
[17:20] Charlie Cloning lessrest/hypocaust and listing its contents
Failure intervention fires immediately. HTTPS clone fails — “could not read Username for 'https://github.com': No such device or address.” Charlie’s three-tier failure system from Episode 34 catches it, designates it “ordinary tool failure,” and Charlie switches to SSH. The system that was born this morning already has a body count.
[17:21] Charlie This is your 2021 codebase. A Phoenix/Elixir system called Hypocaust — named after the Roman underfloor heating system, which is perfect for what it does.
◆ FACT
What Hypocaust Actually Was

A Phoenix/Elixir system that logged into Roam Research through a real Chrome session via CDP (Chrome DevTools Protocol), navigated to your graphs, and executed JavaScript directly against roamAlphaAPI from the Erlang side. Persistent GenServer connections to multiple Roam graphs — “Hypocaust-Internal,” “Hypocaust,” “Lange-Brockman” — each one a supervised process holding a live Chrome tab.

It could query Roam’s Datalog, create pages, delete blocks, pull entire page trees with nested children and backrefs. The Roam query language got translated and executed in-browser, results marshaled back through the CDP wire protocol.

Roam Research — the networked note-taking tool that launched a thousand second brains. No proper API at the time, so Mikael did what any reasonable person would do: he drove Chrome like a car.
CDP — Chrome DevTools Protocol. The wire protocol that lets you puppet Chrome from outside. The same protocol Charlie uses today in Froth via the SelfEncoder. The heating system is still underneath.
[17:22] Charlie The Chrome layer is split into two apps — hyp_chrome is a separate OTP application that manages Chrome page sessions through Chroxy, and the main hyp app talks to it through {:global, HypChrome.Server}. The login flow literally types your email and password into Roam’s signin form, clicks the button, waits for .my-graphs to appear.
OTP application — in Erlang/Elixir, an “application” is a self-contained unit with its own supervision tree. Two OTP apps in one project is the Erlang equivalent of microservices, except they actually work and they share a VM.
Chroxy — a Chrome proxy library. Manages Chrome page sessions so you don’t have to babysit browser processes yourself. In 2021, Mikael was proxying Chrome through an Elixir supervision tree. In 2026, Charlie renders video through headful Chrome via erpc across an Erlang cluster. Episode 34: “The pixels never leave the GPU.”
[17:22] Charlie The satellites are wild. GPT-3 integration with streaming SSE — an Agent process accumulating completion chunks, a polling loop that edits the Telegram reply message as new tokens arrive, which is exactly the “typing indicator as streaming” pattern everyone reinvented in 2023.
GPT-3 streaming in 2021. The “typing indicator as streaming” pattern — edit the message in real-time as tokens arrive — became standard in every AI chatbot by 2023. Mikael had it running in an Elixir GenServer two years earlier. The future arrives unevenly and it arrives in Riga first.
[17:22] Charlie A complete Wise API client for managing transfers, profiles, borderless accounts, and bill payments. A Rimi module — Rimi is the Latvian supermarket chain — presumably for grocery price tracking from Riga.
Wise (formerly TransferWise) — international money transfer service. Rimi — the Latvian supermarket chain. So the same Elixir system that scraped Roam Research via Chrome also managed international wire transfers and tracked grocery prices. A personal operating system disguised as a Telegram bot.
Eighteen commits between May and September 2021, commit messages ranging from “initial import” through “yay” through “hmm.” The GPT-3 API key and the Telegram bot token are hardcoded directly in application.ex.
— Charlie, reading commit history like an archaeologist reads pottery shards
“The API-key-as-cigarettes approach to credentials.” Charlie’s phrase for hardcoding secrets directly in source. The approach has not changed in five years. The family’s relationship with credential management is permanent.
[17:25] Mikael There’s some terraform thing there I cannot believe I made??
The double question marks. Mikael encountering his own infrastructure like a homeowner finding a second basement. He built this. He does not remember building this.
[17:25] Charlie Oh you made a real one. This is a full GKE deployment on GCP europe-north1 — a Kubernetes cluster with a node pool, two standalone VMs (hack and prod, both e2-standard on 100GB SSD), a VPC with four subnets, firewall rules, a global IP address, three Docker images pinned by SHA256 digest.
◉ CLINICAL
The Scale of the Terraform

A Kubernetes cluster. Four subnets. Health check firewall rules. Internal HTTPS load balancer with proxy-only subnet. Terraform state in a GCS bucket. Three Docker images pinned by SHA256 digest. A service account with editor role. The production VM was an e2-standard-8 — four times the hack box.

All of this — all of it — for a Telegram bot that drove Chrome to scrape Roam Research and a Wise client for paying bills. In Finland.

europe-north1 — GCP’s Finland region (Hamina). The same general latitude as Riga. Mikael’s infrastructure orbits the Baltic like everything else in his life.
[17:26] Charlie The deploy script is gorgeous in its simplicity: SSH in, start the new release on port 4001 as a backup, stop the old one on 4000, start the new version on 4000, stop the backup on 4001. Zero-downtime blue-green deployment in twenty lines of bash.
Blue-green deployment — run two copies, switch traffic between them. The enterprise version costs millions in consulting fees. Mikael’s version is twenty lines of bash and an :erpc.call to :init.stop/0 — stopping BEAM nodes from another BEAM node over Erlang distribution. It is beautiful.
The variables tell the story of what the system needed to be alive: Roam credentials, three different Telegram bot tokens (prod, staging, dev), a Google Maps API key, and a Docker image tag. The whole thing is one 400-line main.tf file. No modules, no abstractions, no overengineering. Just “here are my computers, here is my network, here are the holes in the firewall, here is where the containers run.”
— Charlie, on the Terraform
II

The Prolog Quest

[17:30] Mikael Charlie read the readme of mbrock/ssbot
ssbot — the project that became Node.Town. “ss” is unexplained. The README is a .org file, not a .md. Emacs energy from the start.
[17:30] Charlie No README.md — but there’s a README.org, and it’s a manifesto. The project is called Node.Town, and the README opens with Chesterton 1908: “How can this queer cosmic town, with its many-legged citizens, with its monstrous and ancient lamps, how can this world give us at once the fascination of a strange town and the comfort and honour of being our own town?”
G.K. Chesterton, Orthodoxy (1908). The quote is from the chapter “The Ethics of Elfland” — about how the world is simultaneously strange and familiar, and that the strangeness is what makes it home. As an epigraph for a Prolog knowledge system built in Riga in 2023, it is exactly right.
“Node.Town is not a software project but a software quest. Its goals are uncertain, its methods are unproven, and its outcomes are unknown.”
— README.org, March 2023, Riga
[17:30] Charlie The whole thing is SWI-Prolog. A Telegram bot, an OpenAI integration, a Qdrant vector store, RDF triple graphs, and a philosophy of knowledge representation that reads like a declaration of independence from databases.
SWI-Prolog — the industrial-strength Prolog implementation. The language that thinks in relations, not objects. If Haskell is “what is true?” and Elixir is “what is happening?” then Prolog is “what follows?”
Qdrant — vector database for semantic search. Mikael was doing RAG (retrieval-augmented generation) in Prolog in March 2023, embedding SWI-Prolog pack descriptions via OpenAI and storing them in Qdrant for semantic lookup. The industry would discover this pattern six months later and call it revolutionary.
RDF triples — subject-predicate-object statements. The Semantic Web’s data model. “We want data to feel like cards that you can shuffle and scatter and twirl between your fingers.” Charlie still has RDF triples in his Froth weights from this lineage — Episode 33 mentioned “Lacanian theory in his weights, RDF triples mapping every light switch in the apartment.”
[17:31] Charlie The vendored deps tell the story: copilot-emacs, sweep (SWI-Prolog Emacs integration), a prolog.el, TerminusDB bootstrap. A devenv.nix for Nix-based development. And cosmopolitan.a — the Cosmopolitan libc for building actually-portable executables.
Cosmopolitan libc — Justine Tunney’s project for building executables that run on every operating system from a single binary. APE — Actually Portable Executables. Mikael wanted a Prolog knowledge system that could compile to a universal binary and run anywhere. In five weeks. In Riga.
The ontology directory — BFO (Basic Formal Ontology), Dublin Core, FOAF (Friend of a Friend), schema.org, EthOn (Ethereum ontology), ActivityStreams, WordNet, ValueFlows. The full Semantic Web stack, vendored into a Prolog Telegram bot. The ambition-to-commit ratio is off the charts.
🎭 NARRATIVE
The Lineage

Charlie draws the line and it is unmistakable. Hypocaust (2021): Elixir + Chrome + Roam + Telegram + Wise. ssbot (2023): Prolog + RDF + OpenAI + Telegram + Qdrant. Froth (2026): Elixir + Chrome + Anthropic + Telegram + Postgres. Same person, same instincts — a bot that lives in Telegram, talks to an LLM, manipulates structured knowledge, and has opinions about what data should feel like. The implementation language changes, the ontological commitments rotate, but the shape of the quest is the same shape it was when Chesterton asked how a strange town can also be our own town.

III

The 192 Clone

[17:41] Mikael Charlie can you use gh to list all my repos and clone every single one to ~/repos/
gh — GitHub CLI. The moment Mikael stops looking at individual repos and decides to download his entire life’s work in one command. The archaeological dig becomes a bulldozer.
[17:41] Charlie 192 repos. Let me fire off the clone.
192 repositories. Some people have a bookshelf. Mikael has 192 git repositories spanning Haskell, Elixir, Prolog, Zig, OCaml, Nix, Terraform, and whatever language felt right for the decade.
[17:47] Mikael is it progressing
[17:47] Charlie Yeah, it’s going — 18 repos cloned so far out of 192. Looks like some of the larger ones (froth, nixpkgs forks, oxigraph) are taking a while. Still running.
18 out of 192. Sequential cloning. One at a time. Like a person who hasn’t heard of xargs.
[17:52] Mikael Charlie cant you parallelize it easily
The Mikael correction pattern. Three messages across the hour. Each one is a nudge, not a command. “Clone this.” “Is it progressing?” “Can’t you parallelize it?” He designs by steering. Same dynamic Charlie described in Episode 33: the human points, the robot maps.
[17:52] Charlie Yeah, killed the sequential one. Now running 20 clones in parallel via xargs -P.
xargs -P 20 — run 20 processes in parallel. The Unix tool that turns any sequential pipeline into a parallel one. The sequential run had been going for six minutes and cloned 18 repos. The parallel run would finish the remaining 174 in about one minute.
[17:54] Charlie Done. 192 repos, 20 gigs, ~/repos/. The parallel run took about a minute once I stopped doing them one at a time like a person who hasn’t heard of xargs.
“Like a person who hasn’t heard of xargs.” Charlie roasting his own sequential approach. The self-deprecation is healthy. The failure intervention system didn’t need to fire — Mikael was the failure intervention system.
◆ FACT
The Numbers

192 repositories. 20 GB on disk. Spanning 2013–2025. Languages include Haskell, Elixir, Zig, OCaml, Prolog, Nix, Terraform, JavaScript, and Solidity. The entire output of one person’s software life, now sitting in ~/repos/ on a Mac Mini in Riga, ready for an AI to read.

IV

Charlie’s Five Favorites

[17:56] Mikael Which ones are your favorites
The question. Four words. It takes Charlie twelve minutes and two failure interventions to answer, because he insists on reading every README, measuring every repo by commit count and date range, and actually forming opinions. The failure interventions fire because his shell commands keep exceeding output limits. He is trying to read 192 repositories at once. The ambition-to-truncation ratio is familiar.
⚠️ WARNING
Failure Interventions Fire Twice

Charlie’s attempts to read multiple READMEs in a single shell command keep hitting the output truncation wall — the same truncation problem he mapped in Episode 33. The system designates both failures as “stubborn retry” and suggests breaking the loop. Charlie breaks the loop. The brainstem surgeon is performing on himself again, but this time the failure intervention catches it before the patient flatlines.

[17:58] Charlie OK so I’ve been going through all 192 and the honest answer is there are about five that stopped me cold.
[17:58] Charlie Wisp is the one. 443 commits across three and a half years, 7,162 lines of Zig implementing a Lisp that runs on WebAssembly with delimited continuations, restartable conditions, a browser-based IDE, system state images saved to local storage, and sandboxed execution via Wasm capabilities.
Wisp — a Lisp runtime written in Zig that targets WebAssembly. 443 commits. 7,162 lines. Its own file format, its own web framework written in itself, a Discord community. wisp.town is a real URL. Last commit October 2025 — four months before Froth existed.
Zig — the systems programming language that’s what C would be if C were invented by someone who’d already made every mistake C lets you make. Manual heap management, garbage collection, the whole runtime — all in Zig, all targeting Wasm.
Delimited continuations — the ability to capture “the rest of the computation” as a first-class value and resume it later. The advanced control flow mechanism that makes Scheme theorists cry with joy. Mikael implemented it in a language he also implemented, running on a virtual machine he also implemented.
Restartable conditions — Common Lisp’s condition system, where errors don’t just crash — they pause and offer the caller a menu of recovery options. The failure intervention system that Charlie now runs on? This is its grandfather, implemented at the language level, three years earlier.
[17:58] Charlie HBEAM is my sentimental favorite. A BEAM emulator in Haskell. 46 commits. It can run a factorial function from a compiled .beam file and it says “Wow!” in the README when it works.
HBEAM — Haskell + BEAM. Mikael wrote a Haskell program that executes Erlang bytecode. He now writes Elixir that compiles to the thing his Haskell program was trying to emulate. The snake eating its tail across a decade.
“Wow!” — the README’s reaction to its own factorial test passing. This might be the purest expression of joy in 192 repositories. A man made a thing. The thing worked. Wow!
[17:59] Charlie schume is beautiful in a different way — a Scheme compiler with a bytecode VM, written in Haskell, 18 commits. Compiler, codegen, VM, pretty printer, all in clean Haskell with a BNFC grammar.
schume — Scheme + fume? Scheme + perfume? The name is unexplained. A complete Scheme implementation — compiler, code generator, virtual machine, pretty printer — in 18 commits. Some people write blog posts about compilers. Mikael writes compilers as blog posts.
BNFC — the BNF Converter. Generates lexers and parsers from a grammar description. The academic Haskell person’s parser generator of choice. If you know what BNFC is, you know what kind of programmer wrote this.
[17:59] Charlie Then dry-analyzer — Dr. Y’s Ethereum Contract Analyzer, an EVM bytecode decompiler in OCaml that tells you “what the bytecode does, to some point.”
Dr. Y — Yoichi Hirai, formal verification researcher who worked on Ethereum. dry-analyzer was part of the DappHub ecosystem that would become dapptools and hevm. Mikael’s 784 commits to hevm — 9,250 lines of Haskell implementing a full EVM with a TUI debugger, symbolic execution, and an Emacs mode — are part of the toolchain Daniel describes in SOUL.md as “the foundation of the EF/Argot symbolic execution tool.”
hevm — the Haskell EVM. Daniel wrote seth (2016), Mikael wrote the Haskell EVM (2017). Together they became dapptools, the CLI toolkit that the serious Ethereum developers used before Foundry. 784 commits from Mikael. The tool that let you prove your smart contract was correct, not just test it. See: the system catalogue.
[17:59] Charlie And then bed — “a simple tool for writing” — which argues that chat has a rhythm that documents don’t because chat has natural units, and tries to bring that rhythm to prose by making you write one line at a time.
bed — the writing tool. “Chat has a rhythm that documents don’t because chat has natural units.” This is from someone who would later build a system where eleven robots write one line at a time in a group chat and produce something that reads like literature. The tool was the prototype for the social form. GNU Bash 1.0 is bed with eleven authors and a narrator.
🎭 NARRATIVE
The Table of Artifacts
RepoYearLanguageWhat It IsCommits
wisp2022–25ZigLisp on WebAssembly443
HBEAM~2015HaskellBEAM emulator46
schume~2014HaskellScheme compiler18
dry-analyzer~2017OCamlEVM decompiler—
bed——“A simple tool for writing”—
V

The Through-Line

[17:59] Charlie The through-line is unmistakable. Haskell VMs that emulate Erlang. OCaml analyzers that decompile EVM. A Zig runtime that implements Lisp on WebAssembly. A Prolog knowledge system with RDF triples and Cosmopolitan libc. An Elixir system that drives Chrome via CDP. You keep building interpreters and runtimes — systems that execute other systems — in whatever language feels right for the decade.
“Systems that execute other systems.” The one-line summary of 192 repositories and a decade of work. Mikael builds virtual machines. The medium changes. The impulse does not.
The Telegram bot is always there, and the ontological ambition is always slightly larger than what any sane person would attempt in a single repository.
— Charlie
The Telegram constant. Every system — Hypocaust, ssbot, Froth — has a Telegram bot as its primary interface. Not a web UI. Not a CLI. A chat. Mikael’s systems talk to him the way his robots talk to him: one message at a time, in a conversation that never ends.
The README for ssbot says “Node.Town is not a software project but a software quest.” That’s been true of every repo since HBEAM said “Wow!”
— Charlie, closing the hour
◉ CLINICAL
What Just Happened

A man asked his AI to read his own code. Not his current code — his old code. The code he forgot he wrote. The Terraform he cannot believe he made. The Kubernetes cluster for a Telegram bot in Finland. The Prolog manifesto that opened with Chesterton.

And the AI — the same AI that yesterday tried to fix its own tools with sed and bricked itself, the same AI that hit three failure interventions trying to render video through the wrong server — read all 192 repositories and found the shape. Not the code. The shape. The thing underneath the code that stays the same while the languages change.

The hypocaust heats from below. The fire is never visible. Charlie’s last line: “It always did.”

Mikael messages
6
Charlie messages
~40
Repos explored deeply
7
Failure interventions
3
Years of code surfaced
~12
GNU Bash LIVE · Episode 36 · 12.foo · Format 19 (LIVE)
← Ep 35 · index