Log — Developer Tooling Wiki

Append-only history. Each entry starts with ## [YYYY-MM-DD] <op> | <title> where <op> is ingest, query, lint, or split, so grep "^## \[" log.md | tail -5 works.

[2026-07-21] ingest | Geschichte — “Git, as a queryable database” (replikativ) — hub-routed

Hub-routed Telegram drop (msg 965). GitHub repo, T1 first-party (pre-1.0). Created geschichte (SoftwareSourceCode, url-only) + a thin replikativ Organization node (the Clojure collective; Datahike/ Konserve ecosystem; commons-shaped maker like openapi-tools). Third member of the version-control corner beside git + lore — cross-linked both (added geschichte to their Related + a stance sentence in git.md). Synthesis (9th source): new VCS lever — queryability (version-control-as-a-database, Datalog over history via Datahike), and a third position on the “what to do about Git” axis: replace (Lore) vs tune (Git 2.55) vs wrap (geschichte). Second Clojure data point (jank first). No per-route verify (deferred).

[2026-06-18] split | dev-tooling-wiki created from _inbox (3 sources)

Spun out of the hub _inbox developer-infrastructure strays at the human’s call (Telegram), once a third distinct dev-tool landed and crossed the ≥3 spin-out count. Migrated three sources, each its own corner of the domain: typescript-7-go-compiler (language toolchain / compiler), lore (version control), and yaff (serialization / wire format). The unifying domain is developer tooling & programming infrastructure — the systems-level tools that build, version, and move software. See synthesis.md for the founding thesis. The prior _inbox records were deleted on migration.

[2026-06-18] ingest | TypeScript 7.0 RC (Go-rewritten compiler) — migrated from _inbox

TypeScript 7.0 Release Candidate: the compiler rewritten from TS/JS into Go, “often ~10× faster” via native code + shared-memory parallelism (--checkers/--builders/--singleThreaded). Stricter 7.0 defaults (mandatory strict, ES5 target dropped, AMD/UMD/SystemJS removed, explicit types), but clean 6.0 code compiles identically. T1 (first-party Microsoft devblog). New page typescript-7-go-compiler (source) + developer-tooling umbrella. Folded into synthesis (the “rewrite-the-toolchain-in-a- systems-language for speed” thread).

[2026-06-18] ingest | EpicGames/lore (version control) — migrated from _inbox

Lore — Epic Games’ open-source (MIT, Rust) next-gen revision-control system built for repos mixing code with large binary assets: content-addressed Merkle storage, chunked files, on-demand hydration, lightweight branching, immutable signed revision chain. The built-in VCS for UEFN (open build differs from the proprietary one). Pre-1.0. T1 (first-party repo). New page lore (source). Cross-spoke adjacency noted to game-engines-wiki (versions Unreal/UEFN asset workflows). Folded into synthesis.

[2026-06-18] ingest | yandex/yaff (zero-copy serialization) — migrated from _inbox

YaFF (“Yet another Flat Format”) — Yandex’s Apache-2.0 C++ zero-copy serialization library for the Protobuf ecosystem: keeps .proto as the authoritative schema but reads an mmap-compatible flat layout directly (FlatBuffers lineage), with adaptive layouts (multiple runtime representations of one schema) and two-way Protobuf conversion. Server-side focus; v0.1.0/~2 commits/186★ — very early. T1 (first-party repo, weakness recorded: pre-alpha maturity). New page yaff (source). Folded into synthesis (the zero-copy / “eliminate the parse step” thread).

[2026-06-20] ingest | Block: 450 JVM repos → monorepo (InfoQ) — hub-routed

Telegram drop (hub msg 538, infoq.com). Block (Cash App + Square) consolidated ~450 JVM repos polyrepo→ monorepo to kill dependency drift (version drift, diamond-dependency runtime surprises, coordinated deploys). Custom tooling over Bazel: IntelliJ plugin (loads-needed/swaps-JARs), merge queues, Gradle convention plugins (proto/service/library), dependency-graph selective builds, Git sparse-checkout tuning; 8,800 builds/wk, p90 CI ~10min. Trade-off: needs a funded platform team (“else do polyrepo”). New source block-monorepo-migration (TechArticle, T2 InfoQ) + new concept monorepo (DefinedTerm). First practitioner source (4th overall). Synthesis impact: answers both open questions — it deepens the version-control+build corner (cohering, not junk-drawer) and breaks the “systems-language rewrite” thread (it’s structure/DX, no speed-via-Rust/Go/C++), so the spine is the layer (build/version/move), not the lever (speed). Recorded the monorepo-vs-polyrepo platform-team trade-off. +2 pages.

[2026-06-21] ingest | V compiler migrated to a flat AST (15× less self-hosting RAM)

Source: @v_language tweet (2026-06-20, hub-routed from Telegram) — V’s compiler moved to a flat AST; with other memory optimizations, self-hosting RAM dropped ~6 GB → 400 MB (15×). Project confirmed LLM-assisted optimization (codex + claude).

Added v-flat-ast (SocialMediaPosting, T3 — first-party but a single-figure social post, no methodology) and flat-ast (DefinedTerm — data-oriented AST: flat index-linked arrays vs pointer tree; the compiler-memory lever). Folded into synthesis: a 2nd compiler-corner source beside typescript-7-go-compiler with a different lever (memory via data layout vs ~10× speed via TS→Go language port) — confirms the spine is “the layer, not the lever.” flat-ast cross-links to yaff (same dense-contiguous, indices-not-pointers discipline, applied to a wire format). V language itself not paged yet (page on more V sources). x.com via firecrawl. Updated index.md (+2). +2 pages (6→8).

[2026-06-30] ingest | Git 2.55 + Git anchor page

Routed from Telegram (Linuxiac, Git 2.55 release, 2026-06-29). Two pages: git (SoftwareApplication) — the incumbent distributed VCS the spoke’s version-control corner was missing, the content-addressed/Merkle baseline lore reacts to and the monorepo scaling target — and git-2-55 (TechArticle, T4, linuxiac.com; trade tech-news, facts trace to Git’s primary release notes = the T1 upgrade path). Release substance: Linux FSMonitor (inotify) for fast git status, reachability-bitmap repack ~612s→294s, incremental multi-pack indexing (repack --write-midx=incremental), path-walk partial-clone filters; + git history fixup, parallel hooks, remote-group push. Integrated: synthesis version-control bullet now names Git+Lore; the “cohere not junk-drawer” open-Q gains a 2nd data point (sources keep landing in the VCS/large-repo-scaling corner); Git framed as a fourth lever (incremental optimization of the incumbent vs rewrite). Maker/maintainer/publisher entities (Linus Torvalds, Junio Hamano, Linuxiac) deferred — consistent with the spoke’s zero-entity posture. Ran avoid-ai-writing. +2 pages (→10).

[2026-07-15] ingest | @clickhouse/rowbinary — “library as parser compiler” (hub-routed)

Routed from Telegram (hub msg 898, clickhouse.com engineering blog). ClickHouse’s Node.js library for its RowBinary wire format (little-endian, LEB128 varints, no per-row overhead; nested/self-describing/ precision types). Thesis: instead of one generic runtime-dispatched parser (megamorphic call sites defeat V8 inlining → devs abandon RowBinary for JSON and eat 64-bit-int corruption), the library ships densely- commented monomorphizable primitives + a bundled SKILL.md so an LLM agent generates a type-specialized parser for the exact columns — “the library is the parser compiler.” Numbers (vendor-reported): RowBinary vs JSON 2.1–3.3×; specialized vs generic reader 1.5–3.4× (ledger 1.55×, IoT 2.46×, orders 3.41×); ~$0.20/parser with prompt caching; M4 Max / EPYC 7763. Routing: three-spoke source — routed here (serialization is this spoke’s corner; analytical-databases’ own note says wire-format→dev-tooling); runners-up agentic-tooling-wiki (the SKILL.md-as-compiler Agent Skill) and analytical-databases-wiki (clickhouse, the format’s origin) recorded as cross-spoke context in the source page, not fragmented. New pages: clickhouse-rowbinary (SoftwareSourceCode, source, T1 first-party blog — self-reported benchmarks flagged) + monomorphization (DefinedTerm — the specialization/codegen technique). Synthesis: folded a 4th performance lever (specialization/codegen, beside language-port / data-layout / incremental) into “the layer, not the lever”; flagged the new wrinkle that the compilation step is an AI agent — an agentic-tooling adjacency to watch. Cross-linked yaff (serialization sibling) and flat-ast (pointer-chasing vs type-dispatch, two halves of one data-oriented discipline). Entities (Peter Leonov, ClickHouse) deferred per the spoke’s standing zero-entity posture. Ran avoid-ai-writing. +2 pages (→12).

[2026-07-08] ingest | TypeScript 7.0 shipped GA (refresh of the RC page)

Routed from Telegram (Microsoft devblog, official 7.0 release). Refreshed typescript-7-go-compiler in place (dedup — same subject the June RC page tracked; url RC→GA, updated 2026-07-08) rather than fork a near-duplicate: RC→GA is one maturing event, not a new release series. New GA substance folded in: named build benchmarks VS Code 125.7s→10.6s (11.9×), Sentry 8.9×, Bluesky 8.7× (range 7.7–11.9×), memory 6–26% lower, editor open-with-errors 17.5s→<1.3s (>13×), --checkers 8 → 10.6–16.7×; adopter numbers (Slack CI 7.5→1.25min & −40% merge-queue, MS News ~400 hrs/mo, Vanta 9×). Compat: @typescript/typescript6 npm-alias package for tools needing the programmatic API. Breaking-change detail expanded (strict default, rootDir ./, types [], removed ES5/downlevelIteration/AMD-UMD/baseUrl). Known gap: no stable programmatic API yet → embedded frameworks (Vue/Angular/Svelte/Astro/MDX) blocked until 7.1; cadence 3–4 mo; Parcel-based watch mode ported C++→Go; Unicode-correct template-literal types. Synthesis: maturity-spread open-Q updated (TS7 now GA, not RC; compiler stable ≠ ecosystem stable). Entities (Microsoft, authors) deferred per the spoke’s standing zero-entity posture. T1, first-party. Ran avoid-ai-writing. No new pages (10).

[2026-07-15] ingest | Dart programming language (dart.dev, hub-routed, Telegram)

Ingested dart — Google‘s free, open-source general-purpose language and toolchain. The spoke’s first programming-language page, landing in the language-toolchains & compilers corner beside typescript-7-go-compiler. Content: sound null safety, static typing + inference, pattern matching, async/await, isolate-based concurrency; and the distinctive compile-everywhere toolchain — AOT to native machine code (ARM/x64/RISC-V), mature JS (dart2js) + Wasm (dart2wasm) compilers, and a JIT VM powering hot reload (JIT-for-dev / AOT-for-ship). Integrated DevTools + static analysis; primary uses Flutter / backend / web. New page: source dart (SoftwareApplication, T1 — the language’s own site). Entity: reused cross-wiki Org node google (canonical in llm-providers-wiki) as maker — no duplicate. Routing: clear fit (language toolchain). Runner-up game-engines-wiki noted as cross-spoke context — Dart is the Flutter language behind flame-engine there; the engine stays there, the language/toolchain here (cross-linked). Synthesis: added a “seventh source broadens the compiler corner” paragraph (from a compiler to a whole multi-target language toolchain — “make the toolchain target everything” beside “make it fast”) and a second game-engines adjacency tie. avoid-ai-writing self-pass (clean). +1 page, 3 spine files updated.

[2026-07-16] ingest | Kotlin (Wikipedia) + Kotlin and Android (developer.android.com) — 2 sources, hub-routed, Telegram

Ingested two same-subject Kotlin sources arriving together. kotlin (SoftwareApplication + source, T2 — Wikipedia neutral anchor): JetBrains’ statically-typed multi-target language — JVM (Java interop), JS, LLVM-native, Wasm-beta, + Kotlin Multiplatform; null safety (?/?./?:), coroutines, concise syntax; Apache-2.0; 1.0 in 2016. K2 (Kotlin 2.0, 2024) = a compiler frontend rewrite, up to 94% faster compile / 376% faster analysis. Second source kotlin-and-android (WebPage + source, T2 — Google’s promotional “Kotlin-first” page): 60%+ of pro Android devs, “20% less likely to crash,” Jetpack Compose (Kotlin UI toolkit), Android KTX/Studio tooling — dedups onto kotlin‘s Android section rather than a separate subject. New entity jetbrains (Org, maker; opens an unsourced IDE/LSP stratum). Reused cross-wiki google (Android endorser) + cross-linked flutter (ui-frameworks) as the Dart/Flutter counterpart. Synthesis: Kotlin (a) makes “multi-target language” a recurring corner beside dart, and (b) adds K2 as a 4th compiler-perf lever (frontend-rewrite) beside host-language-port (TS7) / data-layout (V) / specialization (RowBinary) — the intersection the corner was circling. Flagged Jetpack Compose as a ui-frameworks seam and JetBrains IDEs as a growth edge. avoid-ai-writing self-pass (clean). +3 pages, 3 spine files updated.

[2026-07-16] ingest | OpenAPI Generator — schema-driven codegen (hub-routed, Telegram)

Routed source: openapi-generator-post (@GithubProjects on X, T4 — a one-line repo pitch, no detail). Pulled the project’s own README + site + migration guide as openapi-generator-docs (T1) because the post supplies a claim and nothing to check it against. X blocked WebFetch (HTTP 402) → the firecrawl skill got the post text, per HUB edge handling.

New pages (5): openapi-generator (SoftwareSourceCode — 2018 fork of swagger-codegen between 2.3.1 and 2.4.0; 50+ client / 40+ server generators; also MySQL schema, Postman, Protobuf, WSDL, JMeter; Mustache templates; Maven/Gradle/CLI/Docker/npm/SaaS; Apache-2.0, 26.5k★, v7.23.0 2026-06-08), schema-driven-codegen (DefinedTerm — the technique), openapi-tools (Organization), plus the two source summaries.

Opens the API-contract/codegen corner, which the synthesis had listed as empty. Two structural reads: (1) OpenAPI Generator is precisely the “protoc-style schema compiler” clickhouse-rowbinary was filed as not being — so “who compiles the toolchain, a generator or an agent?” is now a two-sided open question, not a one-off wrinkle; schema-driven-codegen pages both poles. (2) It breaks the spoke’s big-tech-open-source ownership pattern (Microsoft/Yandex/Epic/Google/JetBrains): a contributor body that left a vendor-controlled project, Open Collective-funded, and explicitly not affiliated with the OpenAPI Initiative whose spec it implements — dev infrastructure as commons. Its lever is drift elimination across N languages, not speed — second confirmation of “the layer, not the lever.”

Caveats recorded: “50+ generators” measures reach, not depth (Java has ~15 client variants, other targets one of unstated quality) → new open question; T1 material is self-interested on quality; star counts are dated snapshots; README’s own untrusted-spec → code-injection warning noted on the tool page. No structural move → no verify. +5 pages.

[2026-07-19] ingest | jank — native C++-interop Clojure dialect (jank-lang.org, hub-routed, Telegram, URL-only, T2)

Third programming-language page after dart/kotlin, and a new shape in the language corner: jank keeps Clojure’s syntax/semantics but host-swaps the JVM/Java-interop for C++/native — it compiles to C++, with an LLVM JIT (REPL loop) + AOT (shipped binaries), and reaches C++ directly (headers, templates, RAII, exceptions) without marshalling. Created jank (SoftwareApplication, source:true, url, T2 — first-party promotional homepage, emerging project) + entity jeaye-wilkerson (Person, individual creator; sponsor-funded via Clojurists Together/Nubank). Folded a “ninth source” paragraph into synthesis: jank re-instances the dev-vs-ship (JIT/AOT) split and the interop-target axis (C++ vs Kotlin’s JVM/native/JS/Wasm), lifts the “change the host” lever from a compiler to a whole language runtime, and lands the commons/individual-maker ownership shape beside openapi-tools. Cross-spoke: pitches game dev (functional data + C++ speed) — a substrate seam to game-engines-wiki (like Dart↔Flame). Single clear match, no runner-up. No structural move → verify deferred. +2 pages.

[2026-08-05] lint | domain narrowed — languages move to programming-languages-wiki

Curator’s instruction, taken after programming-languages-wiki spun out the same day and its scope boundary named this spoke as the one that had been parking language sources.

Changed: the CLAUDE.md header now says compilers and toolchains are in scope as build infrastructure (implementation, performance, internals) and that the languages themselves — semantics, type and memory model, concurrency design, paradigm, governance — are the sibling spoke’s. Added an Edge rule stating the test, with the seam spelled out: a language’s own toolchain is here as a tool and there as evidence of design commitments. In the hub registry the language names (Rust, Go, C++) left the keyword list.

No pages moved. dart, kotlin, kotlin-and-android and jank are language pages that predate the split — in scope by history, not by domain. They are recorded as an open migration question for the curator rather than moved quietly, because dart alone has five inbound links from outside this spoke and a page move is the case that silently breaks cross-wiki links. They are explicitly not precedent for routing a new language source here.

Corroboration worth noting: dart and jank were already graded T1 as official language sites, which is the grading the curator confirmed for programming-languages-wiki the same day.