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.
[2026-08-14] ingest | Protocol Buffers and gRPC (via the hub router)
Both arrived through Telegram a minute apart from the same curator, so they were ingested as one cluster rather than two routes. protobuf.dev and grpc.io are first-party documentation, T1.
Why this spoke, and one call worth arguing with. Protobuf is unambiguous — the domain names
"serialization & data-interchange formats" and the keyword list already contained Protobuf. gRPC
is the harder case: by the Ky precedent (2026-06-18) an application-level runtime library is not
build/ship infrastructure and should be parked. gRPC is a runtime library by that test. It routes
here anyway because its dominant substance is protoc plugin codegen from a .proto contract,
which is schema-driven-codegen and the reason protocol-buffers is here at all. Runner-up
logged: platform-ops-wiki, which owns gRPC-in-production (load balancing, retries, mesh) — the seam
is written into grpc and into the synthesis adjacency list.
The dedup finding is the interesting one. Grep found Protobuf named in yaff (twice, calling
it an ecosystem), in developer-tooling, and in schema-driven-codegen (as the archetype
protoc) — and no page anywhere in the corpus. The spoke held three reactions to Protobuf and not
Protobuf. Those links are now wired up rather than left dangling: yaff points at
protocol-buffers and at protobuf-wire-format for the parse step it deletes.
Pages. Four new: protocol-buffers (DefinedTerm, the format + the docs' own list of when
not to use it), protobuf-wire-format (DefinedTerm — tags, base-128 varints, six wire types,
ZigZag, and the int32-vs-sint32 footgun where -2 costs ten bytes), protobuf-editions
(DefinedTerm), grpc (SoftwareApplication). Updated: schema-driven-codegen (its archetype
now has a page, and turns out to be the narrower generator), yaff, index.md, synthesis.md.
What it changed in the synthesis. Two claims the reaction-pages could not support on their own.
The archetype is narrower than its derivative — protoc extends by plugin API, OpenAPI Generator by
Mustache template, and that is the actual axis under schema-driven codegen. And editions is a clean
statement of freeze one artifact so you can version the other: yearly editions with ~2-year
deprecation windows are affordable only because the wire format never moves. Also recorded, not
resolved: Protobuf's docs say don't use it where formal standards compliance matters, while gRPC on
top of it is a CNCF project — the governed layer sits on the ungoverned one.
Not fetched. The per-language reference guides and tutorials (ten languages, mostly identical in shape) and the best-practices/dos-donts page. The schema-evolution rules in particular would deepen protobuf-editions and are the obvious next pull if the curator wants this corner developed.
[2026-09-02] ingest | CommonMark — a spec written ten years after the format
Routed from the hub (runner-ups: ../static-site-wiki, whose growth edge 6 named this exact source,
and ../research-wiki, whose lineage runs on file-based markdown). It landed here because the subject
is a specification with reference implementations and a conformance suite, which is this spoke's
format corner — the same shape as protocol-buffers and OpenAPI. Both runner-ups are linked from the
page instead of getting a copy, and static-site-wiki's edge 6 was updated in place to point here and
re-specified to the flavour layer (GFM extensions, MDX) that a base spec does not cover.
commonmark (T1). Built from four primaries: commonmark.org, the version index at spec.commonmark.org, the spec's machine-readable test JSON, and the GitHub org API.
The finding came out of counting the test suite, not reading the homepage. v0.31.2 ships 652 examples and 132 of them (20%) are emphasis and strong emphasis; with links (90) that is 34% of the conformance surface on inline syntax, against 48 for list items and 27 for setext headings. Markdown's reputation is headings and lists; those needed almost no disambiguation. A retrofitted spec's section weights record where the existing implementations diverged, which makes this the only evidence in the spoke about a format's pre-specification history.
Second finding: the freeze is in the opposite place from Protobuf. protobuf-editions works
because the wire format never moves — freeze the dependency, version the
language. CommonMark froze the spec (0.31.2, Jan 2024, still 0.x after twelve years, no release
since) while cmark and commonmark.js were both pushed 2026-09-01, the day before this ingest.
Recorded as an open question, not a tension: nothing says which freeze a consumer should prefer.
Growth edge 9 added for it; edge 8 added for the spec's own text, which was not fetched — this page
can say what the suite covers and not what the grammar rules are, and emphasis parsing is the specific
hole.
Also recorded: the homepage of a project that exists to remove ambiguity names no version number, calling the spec "quite robust after many years of public feedback."
New: commonmark, john-macfarlane (Wikipedia + Wikidata Q15821559, checked — the
corpus's only format spec written out of a philosophy department; he also wrote Pandoc).
Updated: index.md (new Person section), synthesis.md (new section, edges 8 and 9),
../static-site-wiki/synthesis.md (edge 6). Entity budget 1 of 8 — Atwood, Marti, Greenspan, Williams,
Dumke-von der Ehe and Woodward are named once each and deferred under ../ENTITIES.md.
[2026-09-04] ingest | pnpm + package-manager (research pass, coverage edge 4)
Hunted for coverage edge 4 — package management, the layer monorepo and block-monorepo-migration both assume and the spoke had no page for. Took pnpm's own Motivation page (T1: a project describing its own mechanism) and wrote the concept page package-manager under it.
The finding is about where a constraint lives, not about speed. npm and Yarn hoist transitive
dependencies to the root of node_modules, so a package can import something it never declared and
nothing complains until the provider disappears. pnpm writes a symlink tree containing only declared
dependencies, plus a content-addressable store the files are hard-linked from — "consuming no
additional disk space", and updated at file granularity rather than by re-cloning a package. That
makes dependency correctness a property of the installer, which is the same shape as
schema-driven-codegen and protobuf-wire-format in this spoke: put the rule where it cannot be
casually bypassed, and pay for it in broken downstream assumptions.
Half close, and the missing half is a finding. The edge asked for official docs plus a migration report with numbers. The docs claim concurrent-stage installs are "significantly faster" and attach no number. Every migration write-up the hunt surfaced (3–5× CI installs, 60%+ disk) was a personal blog with an unstated baseline, no repetition and no cache-state disclosure — below the research pass's T1/T2 bar, so none was cited. Recorded as the residue on edge 4, which now reads the same way as edge 3 (compiler performance, independently measured): this spoke's tools are all measured by their own authors.
Also updated monorepo with the layer underneath it, and index.md with both new pages.
[2026-09-14] ingest | Rune — pricing (rune.build)
Routed in from the hub (Telegram). The page is a client-rendered React app: WebFetch saw only the
title, so the text was read out of the JS bundle and <meta> tags with curl + grep.
Source: rune-pricing, T1 — first-party pricing page. Free (GPLv3, 2 nodes) / Pro $10/mo
or $100/yr (10 nodes, support) / Enterprise (contact). Recorded the licence-model change the bundle
still carries (paid commercial licence + perpetual option → GPLv3 with a metered network service).
No published: — the page carries no date.
New: rune (the editor, first-party claims only), unstable-build (the company; the two founders are one-source names, deferred). Opens the IDE stratum under jetbrains.
Spine: synthesis section The IDE stratum gets its first source; index under
SoftwareApplication, Organization and a new WebPage group; adjacency to ../agentic-tooling-wiki
updated with the editor-vs-agent seam.
[2026-09-22] quality | research pass — package-manager benchmark (coverage edge 4, half close)
Via the hub quality cycle's research pass (Most-wanted #41; spoke never hunted before). Ingested package-manager-benchmark-cheezone (T2): pinned fixtures, cache state stated per scenario, raw result JSON read from the repo. Folded into pnpm and package-manager. Half close, not a close: the repository was created the same day and npm/pnpm cold installs have two samples each; residue written as edge 4a (a repeat run plus disk use). Every blog post found alongside it was again unrepeated and uncited.
[2026-10-04] ingest | GraalVM (graalvm.org homepage)
Routed here from the hub; runner-up programming-languages-wiki (Java the language), noted as context only. Dedup by rg across all spokes: GraalVM appears only as a passing mention of the GraalVM Development Kit in programming-languages-wiki/wiki/java-news-roundup-aug31-2026.md; no page existed. New page graalvm (T1, first-party product page, freshness: volatile, no published: since the page is undated; same-as Wikipedia and Wikidata checked). Native Image, Graal JIT, Truffle polyglot, framework support, all unquantified by the source. Synthesis section added; growth edge 3 widened; index updated.
[2026-10-11] research | package-manager benchmark outside the project (edge 4a) — hunted, nothing ≥ bar
Research pass hunt. Yarn's own continuous benchmark (yarn6.netlify.app) has real rigor (Hyperfine, 10+ runs, CI-driven) but is first-party (Yarn benchmarking itself against competitors) and measures no disk usage. Everything else found is blog-style with unstated methodology. Not ingested. Not eligible again before 2026-10-25.