The compile-time language has arrays, maps, and linked lists. They just look nothing like their runtime counterparts — and they hold types instead of values.
~/ 20 posts
The compile-time language doesn't have for loops. It has something weirder — parameter packs that expand into exactly the code you need, like a copy-paste machine controlled by the compiler.
Every language needs branching. The compile-time language has four different if statements, each invented in a different decade, each a reaction to the last one's shortcomings.
In the compile-time language, types ARE the values. You pass them to functions, store them in data structures, and compute with them. This is the key insight that makes everything else click.
Loom can read content directly from git objects. No working tree, no checkout, just git show and git ls-tree.
C++ isn't one language. It's two. One runs on your machine. The other runs inside the compiler. This series teaches the second one.
Loom isn't just for blogs. Its series, tags, pages, and navigation make it a capable project documentation platform — and it's already serving its own docs.
Series are now defined by directory structure, not frontmatter. Plus archive pages grouped by year.
Canonical URLs, Open Graph, Twitter Cards, JSON-LD, RSS, sitemap — all generated automatically.
How Loom loads blog content from the local filesystem or a remote git repository using the same interface, parses frontmatter and config without dependencies, extracts image dimensions from raw PNG and JPEG bytes, and derives metadata from git history.
How Loom serves HTTP with a single-threaded epoll event loop, zero-copy request parsing via string_view, pre-serialized wire responses, and a dual write path that avoids allocations on the hot path.
How Loom encodes routes as non-type template parameters, analyzes patterns at compile time, and generates an optimal dispatch chain with zero runtime overhead.
How Loom pre-renders every page into 6 HTTP wire variants, serves them with zero copies and zero allocations, and keeps responses under a millisecond.
A hand-written markdown-to-HTML converter in 1200 lines of C++. Two passes, zero dependencies, custom extensions, and sub-millisecond performance.
How Loom compiles typed theme definitions into CSS using pointer-to-member bindings, fold expressions, structural emitters, a full CSS DSL, and component overrides.
How Loom turns HTML generation into composable C++ expressions with a fold-based DOM builder, control flow primitives, and a JSX-like component system with theme-overridable slots.
How Loom uses phantom type tags, conditional concepts, structural enums, and token types to turn entire categories of bugs into compile errors.
When your types carry enough information, the code writes itself. This is the endgame of C++ generics.
A complete guide to Loom's theming system: pick a built-in theme, override individual variables, inject custom CSS, or replace the stylesheet entirely.
inotify tells you what changed on disk without polling. It's how Loom rebuilds your blog before you can alt-tab.