Code graph and memory for your coding agents, in one Rust program. For Claude Code, Codex, Cursor and any MCP client.
Rust agent-memoryai-agentsclaude-codecode-analysiscode-graphcode-intelligencecode-searchcodexcoding-agentscontext-engineeringcursordeveloper-toolsgraphragknowledge-graphlocal-firstmcpmcp-servermodel-context-protocolrusttree-sitter
README: the Rust port of Graphify, plus memory, at the top, and the live flow from a bug to a tested fix
VikramLexc4f3ac414fce
diff --git a/README.md b/README.mdindex 4d3bc38..f399994 100644--- a/README.md+++ b/README.md@@ -26,19 +26,23 @@<p align="center"><picture>- <source media="(prefers-color-scheme: dark)" srcset="assets/hero-setup-dark.png">- <img src="assets/hero-setup-light.png" alt="A terminal in ~/code/shop, a small Python repository. graphicle setup --yes syncs its 4 files, builds the code graph (11 nodes, 15 edges) and prints a summary: 4 files and 6 symbols; Claude Code, Codex, Cursor, VS Code and Claude Desktop added, one MCP server each with the code graph, recall and memory, and Claude Code given five of its tools; session capture added for Claude Code and Codex; AGENTS.md added; post-commit, post-merge and post-checkout Git hooks added; files that change are synced before each answer; no answer model, so graphicle ask shows the evidence without a written answer. Real output of Graphicle 0.1.8, cut after the summary." width="860">+ <source media="(prefers-color-scheme: dark)" srcset="assets/hero-rust-port-dark.png">+ <img src="assets/hero-rust-port-light.png" alt="Graphify, ported to Rust. Plus memory. Code graph and memory for your coding agents, updated after every commit. First build of Kubernetes v1.37.1, a code-only graph, one run each with 3 CPUs and 8 workers: Graphify 0.9.100 29 min 18 s, Graphicle 0.1.11 1 min 14 s, 23.9 times less time; across 13 codebases, 3.4 to 23.9 times less time in 34 of 39 measurements (first builds and updates); Graphify 0.9.100 was faster in the other 5: updates with no change, where it now stops early. Update after each commit, the median over 30 recent code commits with 4 CPUs each: prometheus 32.1 s for Graphify 0.9.100 against 4.9 s for Graphicle 0.1.11, tokio 11.9 s against 2.0 s, poetry 11.7 s against 1.6 s, 5.8 to 7.2 times less time; a graph left alone was stale at 25 to 30 of the 30 commits. Less memory: lower peak memory than Graphify 0.9.100 in 34 of 39 measurements, 0.30 to 0.96 times its figure. Plus agent memory: LoCoMo-10 87.7, level with Hindsight 0.10.2 (87.3) and above Mem0 OSS 2.2.1 (81.9), with about 12 model calls per conversation against 160 and 332. One program: code graph, memory, one MCP server and an app in one install; local, no API key, no telemetry. Labels: Graphicle 0.1.11, built from its release source, against Graphify 0.9.100 on one Linux machine, measured runs one at a time; the graphs differ slightly (node counts within 1.6%, edge counts within 1.1%); in the 5 updates where Graphify was faster, it also used less memory; agent memory from a pre-release build on development sets, with one open model as every system's reader and judge." width="860"></picture>+ <br><sub>Graphicle 0.1.11 against Graphify 0.9.100, labelled as in the picture; every measurement and its method are in <a href="docs/benchmarks.md">docs/benchmarks.md</a>. The code-graph engine is a Rust port of Graphify, <a href="#license-and-credits">credited below</a>. Graphicle is not affiliated with Graphify Labs.</sub></p>+## From a bug on the screen to a tested fix+<p align="center"><picture>- <source media="(prefers-color-scheme: dark)" srcset="assets/speed-kubernetes-dark.svg">- <img src="assets/speed-kubernetes-light.svg" alt="Questions on kubernetes: Graphicle 0.1.8 against 0.1.7. Time per question, the median seconds of a graphicle context call: 22 questions on 16 cores, 0.1.7 2.99 s, 0.1.8 1.34 s; 22 questions on 4 cores, 3.89 s and 1.38 s; 22 questions on 4 cores with the file cache dropped before each call, 4.55 s and 1.90 s; 8 lookups on 16 cores, 2.52 s and 0.96 s. Peak memory of a call, the median over the 22 questions on 16 cores: 3.5 GB and 0.6 GB. On the same store, both releases gave the same packet for every question, byte for byte. Our Linux server (Intel Xeon Platinum 8480C); kubernetes at ca8a2a9e4, a shallow clone of 30,315 files; the 22 questions of issue 8; each call a new process, as the prompt hook runs it; 25 October 2026." width="860">+ <source media="(prefers-color-scheme: dark)" srcset="assets/flow-excalidraw-dark.png">+ <img src="assets/flow-excalidraw-light.png" alt="From a bug on the screen to a tested fix: Graphicle with Meta's models, live on a real excalidraw bug. 1, See it: Muse Spark 1.3 with computer use, 20 s, opens the main menu and clicks the canvas, and the menu stays open. 2, Find it: SAM 3.1 and Muse Spark 1.3, 18 s: SAM outlines the menu items at the point the model chose, and Graphicle ranks the code that draws them, first App.tsx line 1175, then DefaultItems.tsx line 377. 3, Fix it: Muse Wonder 1.0, 2 min 51 s, reads a pack of 193,474 tokens from 117 files; round 1's tests fail, the failing lines are fed back, and round 2's tests pass. 4, Check it: Muse Spark 1.3 on the rebuilt app, 22 s: with the fix built in, the same two steps, and the menu closes. Fixed and checked in 5 min 12 s, with 12 model calls, for $1.64. A live run on 30 Oct 2026 on excalidraw issue #12053, built from source; the fix passes excalidraw's own regression test; costs come from Meta's reported tokens at list prices." width="860"></picture>- <br><sub>Graphicle 0.1.8 against 0.1.7 on kubernetes (a shallow clone at <code>ca8a2a9e4</code>), the 22 questions of <a href="https://github.com/graphicle-ai/graphicle/issues/8">issue #8</a>, our Linux server: a median of 1.34 s per <code>graphicle context</code> call on 16 cores, against 2.99 s, each call a new process. <a href="docs/benchmarks.md#our-own-run-on-kubernetes-017-and-018">Method and every row</a></sub></p>+Built during Meta's Global AI Developer Hackathon ([what was built, and when](HACKATHON.md)). With a key for the Meta Model API, `graphicle see` lets Muse Spark reproduce a bug in a web app with computer use, `graphicle pixel` finds the code that draws what the model points at, and `graphicle fix` patches it with a model such as Muse Wonder and runs your tests; when a round fails, the next one reads the failing lines and the files they name. The picture is one live run on excalidraw issue #12053, built from source, and the fix passes excalidraw's own regression test ([see it, find it, fix it, check it](docs/flow.md)).+## Agent memory, comparedIn a pre-release comparison with seven memory systems, Graphicle matched the accuracy of Hindsight 0.10.2 and beat that of Mem0 OSS 2.2.1 (the open-source library, not Mem0's hosted platform) on LoCoMo-10, and while ingesting made about 12 model calls per conversation, against about 160 for Hindsight and 332 for Mem0 (estimates per conversation; each system's total is exact). Labels: development sets; one open model (Qwen3.8-27B) as every system's reader, judge and model; a pre-release build of Graphicle.@@ -73,6 +77,13 @@ Windows: a preview build for x86-64, not yet code-signed ([Windows (preview)](docapture, adds a two-line section to `AGENTS.md` (unless Claude Code is the only agent) and installs Git hooks that keep the project current. It lists every file it changes andbacks each one up first; `graphicle disconnect` undoes it all.+<p align="center">+ <picture>+ <source media="(prefers-color-scheme: dark)" srcset="assets/hero-setup-dark.png">+ <img src="assets/hero-setup-light.png" alt="A terminal in ~/code/shop, a small Python repository. graphicle setup --yes syncs its 4 files, builds the code graph (11 nodes, 15 edges) and prints a summary: 4 files and 6 symbols; Claude Code, Codex, Cursor, VS Code and Claude Desktop added, one MCP server each with the code graph, recall and memory, and Claude Code given five of its tools; session capture added for Claude Code and Codex; AGENTS.md added; post-commit, post-merge and post-checkout Git hooks added; files that change are synced before each answer; no answer model, so graphicle ask shows the evidence without a written answer. Real output of Graphicle 0.1.8, cut after the summary." width="860">+ </picture>+</p>+Then ask your agent to *"use graphicle to find where failed requests are retried"*, or ask from the terminal:```console@@ -118,7 +129,7 @@ then run `graphicle setup --yes` in this repository and list every file it chang## Why Graphicle-- **Native and fast.** One Rust program. On 13 codebases, Graphicle's 0.1.1 memory engine (a pre-release build) took 3.0 to 22.7 times less time than Graphify 0.9.91 in all 39 measurements (code-only extract, priming update and update with no change, on the same machine with 3 CPUs and 8 workers each). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0% ([speed table](docs/benchmarks.md#speed-on-13-codebases-against-graphify-0991)). A later pre-release build with 0.1.1's memory changes, whose graphs also differ from Graphify's, used less peak memory than Graphify 0.9.91 in all 39 measurements, from 0.29 to 0.97 times Graphify's figure ([memory table](docs/benchmarks.md#peak-memory-against-graphify-0991)).+- **Native and fast.** One Rust program. On 13 codebases, Graphicle 0.1.11 took 3.4 to 23.9 times less time than Graphify 0.9.100 in 34 of 39 measurements (code-only extract, priming update and update with no change, on one machine with 3 CPUs and 8 workers each); in the other 5, updates with nothing to change, Graphify 0.9.100 now stops early and took less time. The graphs differ slightly: node counts within 1.6%, edge counts within 1.1% ([speed table](docs/benchmarks.md#speed-on-13-codebases-against-graphify-09100)). Graphicle used less peak memory in the same 34 measurements, from 0.30 to 0.96 times Graphify's figure ([memory table](docs/benchmarks.md#peak-memory-against-graphify-09100)). After each of 30 recent code commits in three repositories, Graphicle 0.1.11's median update took 5.8 to 7.2 times less time than Graphify 0.9.100's, with 4 CPUs per run ([updates after commits](docs/benchmarks.md#updates-after-commits-against-graphify-09100)).- **Cited context, within a budget you set.** Your agent asks Graphicle and gets the relevant code, docs and decisions as cited excerpts, within a token budget you set. In our tests it tied grep on finding code, and we do not claim it saves tokens ([what we measured](#benchmarks)).- **Answers you can check.** Every excerpt names its file and lines. Memories an agent proposes wait for your approval.- **One program, not a stack.** The code graph, the memory, one MCP server, the web app and the command line come in one install, with one SQLite file. No Python, Docker or database server.@@ -185,28 +196,43 @@ The left column is a code-graph tool, such as Graphify's open-source engine, pluEvery figure is labelled, and [docs/benchmarks.md](docs/benchmarks.md) has the full tables, methods and limits. In the agent tests, a difference counts only when its 95% interval excludes 0; otherwise it is a tie. Long sessions and memory built up across coding sessions are not tested yet.-- **Time per question** (0.1.8, the chart at the top). On kubernetes at `ca8a2a9e4` (a shallow clone, 30,315 files), over the 22 questions of issue #8, the median `graphicle context` call took 1.34 s with 0.1.8 against 2.99 s with 0.1.7 on 16 cores of our Linux server, 1.38 s against 3.89 s on 4 cores, and 1.90 s against 4.55 s on 4 cores with the file cache dropped before each call; 8 lookups took 0.96 s against 2.52 s on 16 cores. Each call was a new process, as the prompt hook runs it. On the same store, both releases gave the same packet for every question, and the peak memory of a call fell from 3.5 GB to 0.6 GB ([method and rounds](docs/benchmarks.md#our-own-run-on-kubernetes-017-and-018)).+<p align="center">+ <picture>+ <source media="(prefers-color-scheme: dark)" srcset="assets/speed-kubernetes-dark.svg">+ <img src="assets/speed-kubernetes-light.svg" alt="Questions on kubernetes: Graphicle 0.1.8 against 0.1.7. Time per question, the median seconds of a graphicle context call: 22 questions on 16 cores, 0.1.7 2.99 s, 0.1.8 1.34 s; 22 questions on 4 cores, 3.89 s and 1.38 s; 22 questions on 4 cores with the file cache dropped before each call, 4.55 s and 1.90 s; 8 lookups on 16 cores, 2.52 s and 0.96 s. Peak memory of a call, the median over the 22 questions on 16 cores: 3.5 GB and 0.6 GB. On the same store, both releases gave the same packet for every question, byte for byte. Our Linux server (Intel Xeon Platinum 8480C); kubernetes at ca8a2a9e4, a shallow clone of 30,315 files; the 22 questions of issue 8; each call a new process, as the prompt hook runs it; 25 October 2026." width="860">+ </picture>+</p>-### Finding the files a fix changes+- **Time per question** (0.1.8, the chart above). On kubernetes at `ca8a2a9e4` (a shallow clone, 30,315 files), over the 22 questions of issue #8, the median `graphicle context` call took 1.34 s with 0.1.8 against 2.99 s with 0.1.7 on 16 cores of our Linux server, 1.38 s against 3.89 s on 4 cores, and 1.90 s against 4.55 s on 4 cores with the file cache dropped before each call; 8 lookups took 0.96 s against 2.52 s on 16 cores. Each call was a new process, as the prompt hook runs it. On the same store, both releases gave the same packet for every question, and the peak memory of a call fell from 3.5 GB to 0.6 GB ([method and rounds](docs/benchmarks.md#our-own-run-on-kubernetes-017-and-018)).++### Speed and memory of 0.1.11 against Graphify 0.9.100++Graphicle 0.1.11, built from its release source, against Graphify 0.9.100 on one cloud Linux machine (AMD EPYC 9V84), measured runs one at a time, alternating between the programs; the picture at the top and the chart below show the results ([method and every measurement](docs/benchmarks.md#graphicle-0111-against-graphify-09100)).<p align="center"><picture>- <source media="(prefers-color-scheme: dark)" srcset="docs/assets/retrieval-dark.svg">- <img src="docs/assets/retrieval-light.svg" alt="Finding the files a fix changes: 100 SWE-bench Verified issues, held out from tuning. Top 1: Graphicle 0.1.8 43, BM25 (SWE-bench style) 35, grep for the issue's names 20; Top 5: Graphicle 0.1.8 75, BM25 (SWE-bench style) 61, grep for the issue's names 54; Top 10: Graphicle 0.1.8 81, BM25 (SWE-bench style) 77, grep for the issue's names 71; MRR: Graphicle 0.1.8 0.561, BM25 (SWE-bench style) 0.478, grep for the issue's names 0.365.">+ <source media="(prefers-color-scheme: dark)" srcset="assets/bench-13-codebases-0111-dark.png">+ <img src="assets/bench-13-codebases-0111-light.png" alt="Two dot plots: Graphicle 0.1.11 against Graphify 0.9.100 on 13 codebases, 3 operations each: first build (a code-only extract), priming update and update with no change; one Linux machine, 3 CPUs and 8 workers each, medians of 3 runs (1 for kubernetes and vscode). Left, speed, Graphify's time divided by Graphicle's (above 1 means Graphicle took less time), for first build, priming update and update with no change: kubernetes 23.9×, 20.5×, 20.6×; rails 7.7×, 7.8×, 7.4×; flask 6.8×, 7.0×, 8.6×; prometheus 6.7×, 6.2×, 6.1×; ripgrep 6.4×, 5.2×, 0.97×; pandas 6.1×, 7.1×, 7.1×; spring-boot 6.1×, 6.9×, 5.4×; react 6.0×, 5.8×, 0.29×; tokio 6.0×, 5.5×, 0.46×; scikit-learn 5.9×, 6.6×, 0.28×; redis 5.5×, 5.3×, 0.41×; vscode 5.4×, 5.9×, 4.5×; next.js 4.0×, 3.9×, 3.4×. Right, peak memory, Graphicle's peak divided by Graphify's (below 1 means Graphicle used less), in the same order: kubernetes 0.86×, 0.66×, 0.46×; rails 0.85×, 0.91×, 0.57×; flask 0.37×, 0.61×, 0.52×; prometheus 0.43×, 0.82×, 0.49×; ripgrep 0.30×, 0.85×, 1.69×; pandas 0.39×, 0.35×, 0.32×; spring-boot 0.96×, 0.77×, 0.58×; react 0.52×, 0.78×, 7.71×; tokio 0.41×, 0.95×, 3.36×; scikit-learn 0.41×, 0.34×, 8.67×; redis 0.40×, 0.73×, 5.23×; vscode 0.54×, 0.64×, 0.40×; next.js 0.51×, 0.85×, 0.83×. Graphicle took less time in 34 of 39 measurements, 3.4 to 23.9 times less, and used less peak memory in the same 34; Graphify 0.9.100 stopped early on the update with no change in ripgrep, react, tokio, scikit-learn and redis, and there took less time and memory. The graphs differ slightly: node counts within 1.6%, edge counts within 1.1%." width="860"></picture></p>-**Offline ranking, 100 SWE-bench Verified issues never used for tuning.** Graphicle 0.1.8 put a file the fix changed in its first 5 files for 75 issues, against 61 for BM25 (SWE-bench style), a significant difference (McNemar exact p = 0.013); for the first file (43 vs 35) and the first 10 (81 vs 77) the differences are not significant. This measures ranking, not whether a coding agent fixes more issues; no agent test of this ranking has been run yet ([method, task lists and limits](docs/benchmarks/retrieval.md)).+- **Updates after commits.** After each of 30 recent code commits in prometheus, tokio and poetry, Graphicle's update took a median 4.9, 2.0 and 1.6 s against 32.1, 11.9 and 11.7 s for Graphify: 5.8 to 7.2 times less time, with 4 CPUs per run. After an update, both programs' graphs had the same number of differences from a fresh build at every step (none on tokio; on prometheus and poetry, mostly differences already present after an update with no change), and a graph left as it was differed from the next fresh build at 25 to 30 of the 30 steps. In a sample of 30 notes tied to code, every change to a noted function was flagged, with no false flag; a wider exploratory check found false flags (precision 0.68 to 0.86) and, on poetry, misses (recall 0.90) ([details](docs/benchmarks.md#updates-after-commits-against-graphify-09100)).+- **Speed on 13 codebases.** 3 operations each, 3 CPUs and 8 workers per run: Graphicle took 3.4 to 23.9 times less time in 34 of 39 measurements, including every first build (Kubernetes v1.37.1, one run each: 1 min 14 s against 29 min 18 s). Graphify 0.9.100 took less time in the other 5, all updates with nothing to change, where it now stops early: 0.28 to 0.97 times Graphicle's time (react: 4.1 s against 14.5 s). The graphs differ slightly: node counts within 1.6%, edge counts within 1.1% ([every measurement](docs/benchmarks.md#speed-on-13-codebases-against-graphify-09100)).+- **Peak memory.** Lower in the same 34 measurements, 0.30 to 0.96 times Graphify's figure (Kubernetes extract: 3,059 against 3,541 MiB), and higher in the 5 updates where Graphify stops early ([every measurement](docs/benchmarks.md#peak-memory-against-graphify-09100)).-### Speed, memory and agent tests of 0.1.0 and 0.1.1+### Finding the files a fix changes<p align="center"><picture>- <source media="(prefers-color-scheme: dark)" srcset="assets/graphicle-011-13-repos-dark.svg">- <img src="assets/graphicle-011-13-repos-light.svg" alt="Two bar charts comparing Graphicle with Graphify 0.9.91 (Python) on 13 codebases. Left, speed: Graphify 0.9.91's time divided by Graphicle's for a code-only extract, highest first: kubernetes 22.7×, rails 7.0×, flask 6.9×, prometheus 6.6×, react 6.2×, scikit-learn 6.1×, pandas 5.8×, vscode 5.4×, ripgrep 5.3×, tokio 5.1×, redis 4.3×, next.js 4.0×, spring-boot 3.3×. A line on each bar spans its 3 operations (code-only extract, priming update and update with no change). Graphicle took less time in all 39 measurements and in every run, 3.0× to 22.7× less. Speed label: Graphicle's 0.1.1 memory engine (a pre-release build) against Graphify 0.9.91 on the same machine, 3 CPUs and 8 workers each, one session per program, 15 Oct 2026; median of 3 runs (1 for Kubernetes and VS Code). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0%. Right, peak memory: Graphicle's peak divided by Graphify 0.9.91's peak for a code-only extract, lowest first: ripgrep 0.31×, flask 0.37×, pandas 0.38×, redis 0.39×, tokio 0.40×, scikit-learn 0.41×, prometheus 0.43×, react 0.50×, next.js 0.51×, vscode 0.52×, kubernetes 0.76×, rails 0.77×, spring-boot 0.94×. Lower in all 39 measurements, at 0.29× to 0.97× of Graphify's peak, on a pre-release memory build whose graphs differ from Graphify's; Graphicle's peak RSS or PSS, whichever is larger, against Graphify's peak PSS. A build of the merged 0.1.1 source stayed below in the 5 measurements rechecked. Speed and memory tables and method: docs/benchmarks.md." width="860">+ <source media="(prefers-color-scheme: dark)" srcset="docs/assets/retrieval-dark.svg">+ <img src="docs/assets/retrieval-light.svg" alt="Finding the files a fix changes: 100 SWE-bench Verified issues, held out from tuning. Top 1: Graphicle 0.1.8 43, BM25 (SWE-bench style) 35, grep for the issue's names 20; Top 5: Graphicle 0.1.8 75, BM25 (SWE-bench style) 61, grep for the issue's names 54; Top 10: Graphicle 0.1.8 81, BM25 (SWE-bench style) 77, grep for the issue's names 71; MRR: Graphicle 0.1.8 0.561, BM25 (SWE-bench style) 0.478, grep for the issue's names 0.365."></picture></p>+**Offline ranking, 100 SWE-bench Verified issues never used for tuning.** Graphicle 0.1.8 put a file the fix changed in its first 5 files for 75 issues, against 61 for BM25 (SWE-bench style), a significant difference (McNemar exact p = 0.013); for the first file (43 vs 35) and the first 10 (81 vs 77) the differences are not significant. This measures ranking, not whether a coding agent fixes more issues; no agent test of this ranking has been run yet ([method, task lists and limits](docs/benchmarks/retrieval.md)).++### Speed, memory and agent tests of 0.1.0 and 0.1.1+<p align="center"><picture><source media="(prefers-color-scheme: dark)" srcset="assets/graphicle-011-hero-dark.svg">@@ -214,7 +240,7 @@ Every figure is labelled, and [docs/benchmarks.md](docs/benchmarks.md) has the f</picture></p>-- **Speed.** The 13-codebase chart and the first panel of the four-panel chart above: on 13 codebases, 3 operations each, Graphicle's 0.1.1 memory engine (a pre-release build) took 3.0 to 22.7 times less time than Graphify 0.9.91 in all 39 measurements, on the same machine with 3 CPUs and 8 workers each (one session per program; median of 3 runs, 1 for Kubernetes and VS Code). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0% ([every measurement, with both graphs' sizes](docs/benchmarks.md#speed-on-13-codebases-against-graphify-0991)). [docs/benchmarks.md](docs/benchmarks.md) also has the earlier runs in which both programs built the same graph: the 0.1.0 engine against Graphify 0.9.88 on Kubernetes ([Kubernetes run](docs/benchmarks.md#speed-on-kubernetes)), and a pre-release build on Django, which ran a code-only extract in 7.5 s against 72.8 s for Graphify 0.9.77 (medians of five alternating runs, one shared Linux host, 8 workers; [the 8 October record](docs/benchmarks.md#speed-against-graphify-0977)).+- **Speed.** The first panel of the four-panel chart above: on 13 codebases, 3 operations each, Graphicle's 0.1.1 memory engine (a pre-release build) took 3.0 to 22.7 times less time than Graphify 0.9.91 in all 39 measurements, on the same machine with 3 CPUs and 8 workers each (the programs measured one after the other; median of 3 runs, 1 for Kubernetes and VS Code). The graphs differ slightly: node counts within 4.7%, edge counts within 2.0% ([every measurement, with both graphs' sizes](docs/benchmarks.md#speed-on-13-codebases-against-graphify-0991)). [docs/benchmarks.md](docs/benchmarks.md) also has the earlier runs in which both programs built the same graph: the 0.1.0 engine against Graphify 0.9.88 on Kubernetes ([Kubernetes run](docs/benchmarks.md#speed-on-kubernetes)), and a pre-release build on Django, which ran a code-only extract in 7.5 s against 72.8 s for Graphify 0.9.77 (medians of five alternating runs, one shared Linux host, 8 workers; [the 8 October record](docs/benchmarks.md#speed-against-graphify-0977)).- **Updates.** After each of 30 commits on prometheus, tokio and poetry, Graphicle 0.1.0's `graph update` took 6 to 8 times less time than Graphify 0.9.91's (one Linux node, 4 CPUs per run), and both matched a fresh build apart from three kinds of keying difference that both programs share. In a 30-note sample, the 15 notes whose function changed were flagged and no other; a wider exploratory check found some false flags ([details and limits](docs/benchmarks.md#updates-after-commits)).- **Peak memory.** A pre-release build with 0.1.1's changes to how the engine holds its data, later than the one timed above, used less peak memory than Graphify 0.9.91 in all 39 measurements (13 repositories; extract and two kinds of update), for example 2,092 against 2,767 MiB on the Kubernetes extract and 1,426 against 2,800 MiB on the next.js extract. A build of the merged 0.1.1 source stayed below in the 5 measurements rechecked; the second panel of the four-panel chart shows its Kubernetes extract, 2,148 against 2,767 MiB (the higher peak of 2 runs). One Linux 8×H100 node, GPUs not used; 8 workers; Graphicle's peak RSS against Graphify's peak PSS ([every measurement](docs/benchmarks.md#peak-memory-against-graphify-0991)).- **Finding code** (Claude Code 2.1.287 on a Linux node, Opus 5.5, effort medium). Graphicle ties grep. On 100 SWE-bench Verified tasks, plain Claude Code, Graphicle 0.1.0's default setup and Graphify 0.9.91 found every file the fix changed in 95, 95 and 94 of them; Graphicle used 16% and Graphify 29% more tokens than plain Claude Code, and the agent never called Graphicle's tools. On 93 tasks from our own code, which the model has not seen, all three tied again, and a prototype card from Graphicle 0.1.0's index (not shipped) used about 20% fewer tokens than Graphify.diff --git a/assets/bench-13-codebases-0111-dark.png b/assets/bench-13-codebases-0111-dark.pngnew file mode 100644index 0000000..30da817Binary files /dev/null and b/assets/bench-13-codebases-0111-dark.png differdiff --git a/assets/bench-13-codebases-0111-light.png b/assets/bench-13-codebases-0111-light.pngnew file mode 100644index 0000000..df87daeBinary files /dev/null and b/assets/bench-13-codebases-0111-light.png differdiff --git a/assets/flow-excalidraw-dark.png b/assets/flow-excalidraw-dark.pngnew file mode 100644index 0000000..17562cdBinary files /dev/null and b/assets/flow-excalidraw-dark.png differdiff --git a/assets/flow-excalidraw-light.png b/assets/flow-excalidraw-light.pngnew file mode 100644index 0000000..3faf072Binary files /dev/null and b/assets/flow-excalidraw-light.png differdiff --git a/assets/hero-rust-port-dark.png b/assets/hero-rust-port-dark.pngnew file mode 100644index 0000000..b25aa8fBinary files /dev/null and b/assets/hero-rust-port-dark.png differdiff --git a/assets/hero-rust-port-light.png b/assets/hero-rust-port-light.pngnew file mode 100644index 0000000..e86beeeBinary files /dev/null and b/assets/hero-rust-port-light.png differdiff --git a/docs/benchmarks.md b/docs/benchmarks.mdindex ed4ab01..775e3c7 100644--- a/docs/benchmarks.md+++ b/docs/benchmarks.md@@ -10,8 +10,8 @@ endorsement is implied.| Area | Status | Result ||---|---|---|| Code-graph engine: parity | Graphify 0.9.95: done on Linux, 24 October 2026. Graphify 0.9.91: run on Linux, 15 October 2026, and again on the 0.1.2 source, 18 October 2026. Graphify 0.9.88: done, 13 October 2026; widened 14 October 2026 | Against Graphify 0.9.95, every comparison check passes on Linux (97 of 97) and every application module has a passing receipt. Against Graphify 0.9.91, the comparison checks pass on Linux, apart from those that stop on that host, as they did against 0.9.88 (IPv4 loopback, a speech recording and ffmpeg, and one layout tolerance). Against Graphify 0.9.88, every check passes, with reviewed upstream fixes applied to nine of the reference's modules; widened on 14 October, they run most of its test files against the engine, and every file they run passes apart from the recorded known differences. The limits are [below](#parity-with-graphify) |-| Code-graph engine: speed | Done, on a pre-release build that followed Graphify 0.9.77. The 0.1.0 engine: an exploratory survey, 14 October 2026; its registered quiet-host repeat is pending. Updates after commits: Graphicle 0.1.0 against Graphify 0.9.91, registered before the first update, 15 October 2026. 13 codebases against Graphify 0.9.91: Graphicle's 0.1.1 memory engine (a pre-release build), one session per program, 15 October 2026 | Django (pre-release build): code-only extract 7.5 s against 72.8 s for Graphify 0.9.77. Kubernetes v1.37.1 (the 0.1.0 engine, which follows Graphify 0.9.88; exploratory, one run each on one Linux host, the same 16 CPUs, 8 workers, with four recorded deviations): code-only extract 198.4 s against 1,597.9 s for Graphify 0.9.88, the same graph. [Details](#speed-on-kubernetes). Updates after each of 30 commits on prometheus, tokio and poetry (one Linux node, 4 CPUs per run): 6 to 8 times less time than Graphify 0.9.91, with the same differences from a fresh build in both. [Details](#updates-after-commits). 13 codebases, 3 operations each (Graphicle's 0.1.1 memory engine, a pre-release build, against Graphify 0.9.91; the same machine, 3 CPUs and 8 workers each): 3.0 to 22.7 times less time in all 39 measurements; the graphs differ slightly, with node counts within 4.7% and edge counts within 2.0%. [Details](#speed-on-13-codebases-against-graphify-0991) |-| Code-graph engine: peak memory | A pre-release build with 0.1.1's changes to how the engine holds its data, against Graphify 0.9.91, 15 October 2026; five measurements rechecked on a build of the merged 0.1.1 source | Less peak memory than Graphify 0.9.91 in all 39 measurements (13 repositories; extract, priming update and update with no change), from 0.29 to 0.97 times Graphify's figure; Kubernetes extract 2,091.5 against 2,767 MiB. One Linux node (its 8 H100 GPUs not used), 8 workers; Graphicle's peak RSS against Graphify's peak PSS. [Details](#peak-memory-against-graphify-0991) |+| Code-graph engine: speed | Graphicle 0.1.11 against Graphify 0.9.100: done on one cloud Linux machine, registered before the first measured run, 1 November 2026. Earlier: done, on a pre-release build that followed Graphify 0.9.77. The 0.1.0 engine: an exploratory survey, 14 October 2026; its registered quiet-host repeat is pending. Updates after commits: Graphicle 0.1.0 against Graphify 0.9.91, registered before the first update, 15 October 2026. 13 codebases against Graphify 0.9.91: Graphicle's 0.1.1 memory engine (a pre-release build), the programs measured one after the other, 15 October 2026 | Against Graphify 0.9.100 (Graphicle 0.1.11 built from its release source; one machine, measured runs one at a time): updates after each of 30 commits on prometheus, tokio and poetry (4 CPUs per run) took 5.8 to 7.2 times less time; on 13 codebases (3 CPUs and 8 workers each), Graphicle took less time in 34 of 39 measurements (3.4 to 23.9 times less) and more in 5, all updates with no change, where Graphify 0.9.100 now stops early; the graphs differ slightly, with node counts within 1.6% and edge counts within 1.1%. [Details](#graphicle-0111-against-graphify-09100). Earlier runs: Django (pre-release build): code-only extract 7.5 s against 72.8 s for Graphify 0.9.77. Kubernetes v1.37.1 (the 0.1.0 engine, which follows Graphify 0.9.88; exploratory, one run each on one Linux host, the same 16 CPUs, 8 workers, with four recorded deviations): code-only extract 198.4 s against 1,597.9 s for Graphify 0.9.88, the same graph. [Details](#speed-on-kubernetes). Updates after each of 30 commits on prometheus, tokio and poetry (one Linux node, 4 CPUs per run): 6 to 8 times less time than Graphify 0.9.91, with the same differences from a fresh build in both. [Details](#updates-after-commits). 13 codebases, 3 operations each (Graphicle's 0.1.1 memory engine, a pre-release build, against Graphify 0.9.91; the same machine, 3 CPUs and 8 workers each): 3.0 to 22.7 times less time in all 39 measurements; the graphs differ slightly, with node counts within 4.7% and edge counts within 2.0%. [Details](#speed-on-13-codebases-against-graphify-0991) |+| Code-graph engine: peak memory | Graphicle 0.1.11 against Graphify 0.9.100, 1 November 2026. Earlier: a pre-release build with 0.1.1's changes to how the engine holds its data, against Graphify 0.9.91, 15 October 2026; five measurements rechecked on a build of the merged 0.1.1 source | Against Graphify 0.9.100 (one machine, 3 CPUs and 8 workers; the larger of Graphicle's peak RSS and PSS against Graphify's peak PSS): lower in 34 of 39 measurements, from 0.30 to 0.96 times its figure (Kubernetes extract 3,059 against 3,541 MiB), and higher in 5, the updates with no change where Graphify 0.9.100 now stops early. [Details](#peak-memory-against-graphify-09100). Earlier: less peak memory than Graphify 0.9.91 in all 39 measurements (13 repositories; extract, priming update and update with no change), from 0.29 to 0.97 times Graphify's figure; Kubernetes extract 2,091.5 against 2,767 MiB. One Linux node (its 8 H100 GPUs not used), 8 workers; Graphicle's peak RSS against Graphify's peak PSS. [Details](#peak-memory-against-graphify-0991) || Coding agents: Claude Code with Graphicle, Graphify or neither | Four task sets, each test registered before any answer was scored; Claude Code with Opus 5.5, and one set repeated with Haiku 5.5 | Graphicle tied plain Claude Code on finding files and facts in every test, and no token saving is claimed against it. Against Graphify 0.9.91, Graphicle found more facts on Graphify's showcase corpus and used fewer tokens in all four task sets (on SWE-bench Verified, a secondary comparison); in two of them, Graphicle's arm included a prototype that does not ship. [Details](#coding-agents-with-graphicle-graphify-or-neither) || Retrieval: finding the files a fix changes | Graphicle 0.1.8, offline, 25 October 2026, on 100 SWE-bench Verified issues never used for tuning; Graphicle 0.1.3 and the 0.1.2 release, 21 October 2026, on those and 80 issues used for tuning | On the held-out issues, a file the fix changed was among the first 5 files of 0.1.8's context packet for 75, against 61 for BM25 (SWE-bench style; McNemar exact p = 0.013) and 54 for grep on the issue's names; for the first file and the first 10 files the differences from BM25 are not significant. 0.1.3 had the same counts, apart from 82 in the first 10 files against 0.1.8's 81. Ranking only: no agent test of this ranking has been run yet ([retrieval benchmark](benchmarks/retrieval.md)) || Retrieval: time per question, our run | Graphicle 0.1.8 against 0.1.7 on our Linux server, 25 October 2026 | kubernetes, the 22 questions of issue #8, each call a new process: `graphicle context` took a median of 1.34 s with 0.1.8 against 2.99 s with 0.1.7 on 16 cores, and 1.38 s against 3.89 s on 4; the peak memory of a call was 0.6 GB against 3.5 GB, with the same packet for every question. [Details](#our-own-run-on-kubernetes-017-and-018) |@@ -20,13 +20,250 @@ endorsement is implied.| Agent memory: comparison with seven memory systems | Done, on development sets, with a proxy evaluator | Every system's scores and the 21 registered comparisons are [below](#agent-memory-comparison-with-seven-memory-systems). None of them is a headline claim || Agent memory: retrieval defaults | Chosen | Model-free retrieval runs on development data, plus held-out checks; their records are not published yet, so no numbers are given |-The table image below gives the main results. Each row names its build and-conditions, and the sections below have the full tables.+The table image below gives the main results of the tests of 0.1.0 and 0.1.1.+Each row names its build and conditions, and the sections below have the full+tables.<p align="center"><img src="../assets/graphicle-011-comparison.svg" alt="Table: Graphicle 0.1.1 against Graphify 0.9.91 (Python) and Claude Code alone. A blue chip marks Graphicle ahead (the 95% CI of the difference excludes 0); a grey chip marks a tie (no difference measured). Speed and memory, one Linux node per test (Intel Xeon Platinum 8480C), with the Graphicle build named on each row. Speed on 13 codebases × 3 operations (extract, priming update and update with no change): Graphicle's 0.1.1 memory engine (a pre-release build) against Graphify 0.9.91 on the same machine, 3 CPUs each, median of 3 runs (1 for Kubernetes and VS Code); the graphs differ slightly, node counts within 4.7%, edge counts within 2.0%. Graphicle took less time in 39 of 39 measurements, 3.0× to 22.7× less; Graphify in 0 of 39. Kubernetes extract in that run (code-only, one run each, 256,329 against 244,784 nodes): 1 min 8 s against 25 min 47 s, 22.7× less time. Kubernetes extract, same graph (the published run on Kubernetes, 31k files: the 0.1.0 engine against Graphify 0.9.88, one exploratory run each on the same 16 CPUs; both built the same graph): 3 min 18 s against 26 min 38 s, 8.1× less time on this run. Update after a commit (prometheus, tokio and poetry; median over 30 commits each, 4 CPUs per run; measured on 0.1.0): 5.7, 2.1 and 1.6 s against 34.6, 13.0 and 13.1 s, 6 to 8× less time. Peak memory, Kubernetes build (Graphicle 0.1.1, a build of the merged source; highest peak RSS of 2 runs against Graphify's peak PSS from one run): 2,148 MiB against 2,767 MiB, 0.78× of Graphify's peak. Peak memory, 13 repositories × 3 operations (a pre-release build with 0.1.1's memory changes, whose graphs differ from Graphify's; 0.1.1 itself rechecked in 5 of them, lower in all): lower in 39 of 39 measurements, 0.29× to 0.97× of Graphify's peak; Graphify in 0 of 39. Memory checks, Graphicle only: stale-memory flags on notes tied to code (30 notes on prometheus, tokio and poetry, 30 commits each; measured on 0.1.0): 15 of 15 changed notes flagged, 0 false flags; a wider check on every function found some false flags (precision 0.68 to 0.86). Coding agents (Claude Code 2.1.287, Opus 5.5, effort medium, one run per task). Graphify's showcase corpus, facts found (30 questions, 108 facts; Graphicle 0.1.1 agent defaults, a pre-release build): Graphicle 99.2%, Graphify 87.8% (Graphicle +11.4 points, 95% CI [4.2, 19.7]), Claude Code alone 94.7% (tie). Same test, tokens per answer (median, with the mean; the tested differences are on the mean): Graphicle 69.2k (mean 81.8k), Graphify 87.1k (mean 113.5k; Graphicle −31.8k, 95% CI [−58.9k, −8.2k]), Claude Code alone 60.8k (mean 183.7k; no difference measured). Index builds add 11.1k (Graphicle) and 14.0k (Graphify) per question; one 2.31M-token run lifts Claude Code alone's mean. Never-seen private commits, all files found (93 tasks; Graphicle: a prototype card from 0.1.0's index, not shipped): Graphicle 57.0%, Graphify 58.1% (tie), Claude Code alone 57.0% (tie). SWE-bench Verified, all files found (100 tasks; Graphicle 0.1.0, default setup, used 16% more tokens than Claude Code alone, a measured loss; on 50 of these tasks 0.1.1, pre-release, used 12.4% more, 95% CI [−0.7%, +24.3%], a tie, and its file hit was not scored): Graphicle 95%, Graphify 94% (tie), Claude Code alone 95% (tie). Questions about our own project, facts found (60 questions, 177 facts; Graphicle: pre-release 0.1.1 plus a prototype context hook, not shipped): Graphicle 97.1%, Graphify 98.5% (tie), Claude Code alone 97.4% (tie). Never-seen with Haiku 5.5, all files found (93 tasks, Claude Code 2.1.300; Graphicle: the prototype card; Graphify was not run): Graphicle 43.0%, Claude Code alone 38.7% (tie). Tests run 14 and 15 Oct 2026; paired differences with 95% bootstrap CIs; the 13-codebase rows are one session per program, run one after the other on 15 Oct 2026, not interleaved. Ties are shown as ties. The 0.1.1 token check on 50 SWE-bench tasks comes from our run records; it is not in the page's tables."></p>## Code-graph engine+### Graphicle 0.1.11 against Graphify 0.9.100++**Label for every figure in this section:** Graphicle 0.1.11, built from its+release source with the release workflow's commands on the test machine+(binary SHA-256 `14c3e943…` for `graphicle` and `4b5b36c7…` for+`graphicle-graph`; the release archive is built on an older Linux, so its+bytes differ), against Graphify 0.9.100 (the PyPI wheel, its SHA-256 equal to+PyPI's digest, in its own environment on CPython 3.12), and, where named,+Graphicle 0.1.0 (the published Linux release archive). One cloud Linux machine+(AMD EPYC 9V84, 40 vCPUs, one NUMA node, 314 GiB; its GPU not used); measured+runs one at a time, each pinned to its CPUs with `taskset`; code-only, with no+model calls; measured on 1 November 2026. The protocol was registered before+the first measured run, and its method did not change. The repositories,+commits, tags and operations are those of the sections below; the machine is+not, so times compare only within this section.++#### Updates after commits against Graphify 0.9.100++Each program replayed the 30 commits per repository of+[Updates after commits](#updates-after-commits), oldest first, and ran its+documented update after each one (`graphicle graph update .`,+`graphify update .`); after every update, its graph was compared with a fresh+`extract . --code-only` at the same commit. 4 CPUs per run, with+`GRAPHIFY_MAX_WORKERS=4`.++| Repository (graph size: fresh build at the last step, code scope) | Program | Update: median / 90th percentile | Fresh full build: median | Peak RSS: highest update | Steps that differ from a fresh build | Mean difference per step (nodes and edges) |+|---|---|---|---|---|---|---|+| prometheus/prometheus, Go and TypeScript (Graphicle 0.1.11: 19.4k nodes, 72.8k edges; Graphify 0.9.100: 19.4k, 73.0k; Graphicle 0.1.0: 16.0k, 68.1k) | Graphicle 0.1.11 | 4.9 s / 5.1 s | 3.5 s | 528 MiB | 30 of 30 | 250 (226 after an update with no change) |+| | Graphify 0.9.100 | 32.1 s / 32.9 s | 25.0 s | 653 MiB | 30 of 30 | 250 (226) |+| | Graphicle 0.1.0 | 6.4 s / 6.6 s | 5.6 s | 670 MiB | 30 of 30 | 144 (130) |+| tokio-rs/tokio, Rust (13.0k, 27.9k; Graphify 13.1k, 27.9k; 0.1.0 12.8k, 27.3k) | Graphicle 0.1.11 | 2.0 s / 2.1 s | 1.3 s | 260 MiB | 0 of 30 | 0 |+| | Graphify 0.9.100 | 11.9 s / 12.0 s | 8.2 s | 297 MiB | 0 of 30 | 0 |+| | Graphicle 0.1.0 | 1.7 s / 1.7 s | 1.3 s | 357 MiB | 0 of 30 | 0 |+| python-poetry/poetry, Python (6.3k, 19.9k; Graphify 6.3k, 20.0k; 0.1.0 5.9k, 19.5k) | Graphicle 0.1.11 | 1.6 s / 1.7 s | 1.3 s | 194 MiB | 30 of 30 | 27 (27) |+| | Graphify 0.9.100 | 11.7 s / 11.9 s | 10.2 s | 402 MiB | 30 of 30 | 27 (27) |+| | Graphicle 0.1.0 | 1.4 s / 1.5 s | 1.3 s | 299 MiB | 30 of 30 | 27 (27) |++- **5.8 to 7.2 times less time.** Graphify 0.9.100's median update took 6.5,+ 5.8 and 7.2 times as long as Graphicle 0.1.11's (prometheus, tokio, poetry),+ and 5.0, 6.9 and 8.3 times as long as Graphicle 0.1.0's. On tokio and+ poetry, 0.1.11's median update is slower than 0.1.0's (2.04 s against+ 1.72 s; 1.62 s against 1.40 s); on prometheus it is faster (4.90 s against+ 6.44 s), with a larger graph (19.4k against 16.0k nodes). For every program,+ an update took longer than a fresh full build.+- **The same differences in both programs.** At each of the 90 steps,+ Graphicle 0.1.11's and Graphify 0.9.100's updated graphs had the same number+ of differences from their fresh builds, with the same totals of extra and+ missing nodes and edges (the counts were compared, not the items). The+ differences were already there after an update with no change (226 on+ prometheus, 27 on poetry, none on tokio) and never shrank; on prometheus+ they grew above that level at 24 of the 30 steps (to at most 256). No+ node's label, file or location went stale at any step, in any program.+- **A graph that is not updated goes stale.** Left as it was, a graph differed+ from the next fresh build at 29, 30 and 25 of the 30 steps (prometheus,+ tokio, poetry).+- **Peak memory of updates.** Graphicle 0.1.11's highest update peak RSS is+ below Graphify 0.9.100's in all three repositories.+- Every run exited 0 and wrote a graph (186 per program).++**Flags on notes tied to code** (Graphicle 0.1.11; the 30 notes, commits and+tree-sitter gold of [Updates after commits](#updates-after-commits), after+`graphicle sync .` at each commit):++| Repository | Note-steps | Flagged and changed / false flags / missed | Precision / recall | Sync, median |+|---|---|---|---|---|+| prometheus/prometheus | 300 | 6 / 0 / 0 | 1.00 / 1.00 | 6.0 s |+| tokio-rs/tokio | 300 | 5 / 0 / 0 | 1.00 / 1.00 | 1.9 s |+| python-poetry/poetry | 300 | 5 / 0 / 0 | 1.00 / 1.00 | 2.1 s |++Every change to a noted function was flagged, with no false flag, and every+note stayed attached. The wider exploratory check, the same signal on every+eligible function, gave the same precision and recall as with 0.1.0:++| Repository | Symbols | Precision | Recall | Same-file edits that gave a false flag |+|---|---|---|---|---|+| prometheus/prometheus | 5,040 | 0.82 | 1.00 | 127 of 14,248 |+| tokio-rs/tokio | 1,491 | 0.68 | 1.00 | 62 of 1,888 |+| python-poetry/poetry | 1,633 | 0.86 | 0.90 | 21 of 2,776 |++#### Speed on 13 codebases against Graphify 0.9.100++The 13 repositories and tags of+[Speed on 13 codebases against Graphify 0.9.91](#speed-on-13-codebases-against-graphify-0991),+as plain trees with the same digests, and its three operations. 3 CPUs and 8+workers per run; measured runs one at a time, with the programs' order+alternating; one warm-up, then 3 measured runs per program (1 run, with no+warm-up, for Kubernetes and VS Code). Times are medians and include program+start-up.++| Repository and tag | Operation | Graphicle 0.1.11 (s) | Graphify 0.9.100 (s) | Speed-up | Runs per program | Nodes: Graphicle / Graphify | Edges: Graphicle / Graphify |+|---|---|---|---|---|---|---|---|+| pallets/flask 3.1.3 | Code-only extract | 0.36 | 2.40 | 6.8× | 3 | 2,233 / 2,229 | 3,586 / 3,589 |+| | Priming update | 0.33 | 2.30 | 7.0× | 3 | 2,251 / 2,247 | 3,591 / 3,594 |+| | Update with no change | 0.18 | 1.59 | 8.6× | 3 | 2,251 / 2,247 | 3,591 / 3,594 |+| BurntSushi/ripgrep 15.2.0 | Code-only extract | 0.41 | 2.60 | 6.4× | 3 | 4,272 / 4,271 | 9,157 / 9,158 |+| | Priming update | 0.63 | 3.26 | 5.2× | 3 | 4,370 / 4,369 | 9,233 / 9,234 |+| | Update with no change | 0.31 | 0.30 | **0.97×** | 3 | 4,370 / 4,369 | 9,233 / 9,234 |+| redis/redis 8.10.2 | Code-only extract | 3.03 | 16.6 | 5.5× | 3 | 17,424 / 17,428 | 61,551 / 61,556 |+| | Priming update | 3.95 | 21.0 | 5.3× | 3 | 17,655 / 17,659 | 61,805 / 61,810 |+| | Update with no change | 2.31 | 0.95 | **0.41×** | 3 | 17,655 / 17,659 | 61,805 / 61,810 |+| prometheus/prometheus v3.15.0 | Code-only extract | 3.86 | 25.8 | 6.7× | 3 | 19,106 / 19,123 | 71,094 / 71,227 |+| | Priming update | 5.10 | 31.4 | 6.2× | 3 | 20,155 / 20,172 | 72,172 / 72,305 |+| | Update with no change | 3.23 | 19.7 | 6.1× | 3 | 20,155 / 20,172 | 72,172 / 72,305 |+| tokio-rs/tokio tokio-1.53.3 | Code-only extract | 1.35 | 8.05 | 6.0× | 3 | 12,399 / 12,479 | 26,500 / 26,499 |+| | Priming update | 1.99 | 10.9 | 5.5× | 3 | 13,250 / 13,331 | 27,329 / 27,329 |+| | Update with no change | 1.14 | 0.53 | **0.46×** | 3 | 13,250 / 13,331 | 27,329 / 27,329 |+| facebook/react v19.3.0 | Code-only extract | 11.8 | 70.1 | 6.0× | 3 | 34,783 / 35,343 | 67,517 / 68,176 |+| | Priming update | 17.2 | 99.9 | 5.8× | 3 | 45,483 / 46,046 | 76,864 / 77,527 |+| | Update with no change | 14.5 | 4.12 | **0.29×** | 3 | 45,483 / 46,046 | 76,864 / 77,527 |+| vercel/next.js v16.4.0 | Code-only extract | 92.2 | 372.5 | 4.0× | 3 | 161,589 / 162,308 | 339,633 / 339,061 |+| | Priming update | 155.7 | 609.0 | 3.9× | 3 | 173,167 / 173,886 | 349,391 / 348,812 |+| | Update with no change | 157.8 | 541.5 | 3.4× | 3 | 173,169 / 173,888 | 349,391 / 348,812 |+| pandas-dev/pandas v3.0.6 | Code-only extract | 10.2 | 62.8 | 6.1× | 3 | 42,303 / 42,306 | 102,932 / 103,172 |+| | Priming update | 9.60 | 67.8 | 7.1× | 3 | 43,009 / 42,922 | 103,449 / 103,633 |+| | Update with no change | 6.07 | 43.1 | 7.1× | 3 | 43,009 / 42,922 | 103,449 / 103,633 |+| scikit-learn/scikit-learn 1.9.1 | Code-only extract | 5.97 | 35.1 | 5.9× | 3 | 21,223 / 21,258 | 68,602 / 68,602 |+| | Priming update | 5.35 | 35.3 | 6.6× | 3 | 21,628 / 21,663 | 68,697 / 68,697 |+| | Update with no change | 3.32 | 0.94 | **0.28×** | 3 | 21,628 / 21,663 | 68,697 / 68,697 |+| spring-projects/spring-boot v4.1.1 | Code-only extract | 21.0 | 128.9 | 6.1× | 3 | 88,815 / 88,781 | 304,687 / 305,851 |+| | Priming update | 28.2 | 193.8 | 6.9× | 3 | 88,818 / 88,784 | 304,689 / 305,853 |+| | Update with no change | 19.7 | 106.5 | 5.4× | 3 | 88,818 / 88,784 | 304,689 / 305,853 |+| rails/rails v8.1.4 | Code-only extract | 10.3 | 79.3 | 7.7× | 3 | 57,522 / 57,528 | 96,346 / 96,360 |+| | Priming update | 13.2 | 102.6 | 7.8× | 3 | 60,819 / 60,825 | 99,765 / 99,779 |+| | Update with no change | 8.94 | 66.3 | 7.4× | 3 | 60,819 / 60,825 | 99,765 / 99,779 |+| kubernetes/kubernetes v1.37.1 | Code-only extract | 73.6 | 1,757.6 | 23.9× | 1 | 436,879 / 436,867 | 1,603,787 / 1,609,681 |+| | Priming update | 110.9 | 2,269.8 | 20.5× | 1 | 441,009 / 441,000 | 1,608,267 / 1,614,156 |+| | Update with no change | 75.3 | 1,549.4 | 20.6× | 1 | 441,009 / 441,000 | 1,608,267 / 1,614,156 |+| microsoft/vscode 1.141.1 | Code-only extract | 112.5 | 605.0 | 5.4× | 1 | 257,820 / 258,141 | 974,213 / 963,788 |+| | Priming update | 148.3 | 868.7 | 5.9× | 1 | 262,551 / 262,872 | 980,836 / 970,410 |+| | Update with no change | 125.9 | 567.2 | 4.5× | 1 | 262,551 / 262,872 | 980,836 / 970,410 |++Speed-up = Graphify's median / Graphicle's median, from the unrounded times+(bold: below 1, Graphify faster).++- **Graphicle took less time in 34 of 39 measurements**, 3.4 to 23.9 times+ less, including every code-only extract (4.0 to 23.9 times) and every+ priming update (3.9 to 20.5 times). In each of the 34, Graphicle's slowest+ run took less time than Graphify's fastest.+- **Graphify 0.9.100 took less time in 5 of 39**, all updates with no change:+ ripgrep (0.30 s against 0.31 s), redis (0.95 against 2.31 s), tokio (0.53+ against 1.14 s), react (4.12 against 14.5 s) and scikit-learn (0.94 against+ 3.32 s); in each, every Graphify run took less time than every Graphicle+ run. In these five, Graphify 0.9.100 reported "No relevant changes;+ graphify-out left untouched." and stopped early; in the other eight it did+ not. Against Graphify 0.9.91, Graphicle's 0.1.1 memory engine (a+ pre-release build) took less time in all 39.+- **The graphs differ slightly in every measurement:** Graphicle's node counts+ differ from Graphify's by −1.58% to +0.20%, its edge counts by −0.97% to+ +1.08%. Both programs' Kubernetes graphs are larger than in the runs against+ Graphify 0.9.91 (436,879 and 436,867 nodes for the extract).+- **Determinism.** Graphify 0.9.100 wrote the same graph in every run of every+ measurement. Graphicle 0.1.11 wrote 3 different graphs, with the same+ counts, in its 3 runs of pandas' priming update and of its update with no+ change; 0.1.0 did the same.+- **Graphicle 0.1.0 on the same machine** (run afterwards, on its own, with+ the same settings): it took less time than 0.1.11 in 26 of the 39+ measurements, and 0.1.11 in 13, among them all three on prometheus,+ next.js, spring-boot and Kubernetes (the Kubernetes extract: 482.5 s for+ 0.1.0, 73.6 s for 0.1.11). 0.1.0's graphs had the same node and edge+ counts as in the runs against Graphify 0.9.91.+- Every run exited 0 and wrote its graph.++#### Peak memory against Graphify 0.9.100++The same machine, CPUs, workers and operations. Graphicle: its peak resident+set (`ru_maxrss` from `wait4`) and its sampled peak PSS, each the median of+its runs; Graphify: the sampled peak PSS of its process tree (the main process+and its workers), the median of its runs. The ratio uses the larger Graphicle+figure. PSS was sampled every 20 ms for flask, ripgrep, redis, prometheus,+tokio, pandas and scikit-learn (3 further runs per program, in alternating+order, whose times are not used) and every 500 ms for the other six (the timed+runs). Both programs' figures for a measurement come from the same runs.++| Repository and tag | Operation | Graphicle 0.1.11: peak RSS, median (MiB) | Graphicle 0.1.11: peak PSS, median (MiB) | Graphicle runs | Graphify 0.9.100: peak PSS, median (MiB) | Graphify runs | Graphicle / Graphify |+|---|---|---|---|---|---|---|---|+| pallets/flask 3.1.3 | Code-only extract | 76.2 | 75.1 | 3 | 207 | 3 | 0.37 |+| | Priming update | 69.0 | 67.4 | 3 | 114 | 3 | 0.61 |+| | Update with no change | 51.7 | 46.9 | 3 | 99 | 3 | 0.52 |+| BurntSushi/ripgrep 15.2.0 | Code-only extract | 78.0 | 75.4 | 3 | 261 | 3 | 0.30 |+| | Priming update | 107.1 | 104.3 | 3 | 126 | 3 | 0.85 |+| | Update with no change | 67.1 | 64.2 | 3 | 40 | 3 | **1.69** |+| redis/redis 8.10.2 | Code-only extract | 181.4 | 178.7 | 3 | 455 | 3 | 0.40 |+| | Priming update | 429.2 | 427.3 | 3 | 587 | 3 | 0.73 |+| | Update with no change | 226.0 | 222.6 | 3 | 43 | 3 | **5.23** |+| prometheus/prometheus v3.15.0 | Code-only extract | 237.7 | 233.0 | 3 | 548 | 3 | 0.43 |+| | Priming update | 512.2 | 509.5 | 3 | 622 | 3 | 0.82 |+| | Update with no change | 267.0 | 260.0 | 3 | 543 | 3 | 0.49 |+| tokio-rs/tokio tokio-1.53.3 | Code-only extract | 116.7 | 115.3 | 3 | 283 | 3 | 0.41 |+| | Priming update | 241.1 | 233.8 | 3 | 255 | 3 | 0.95 |+| | Update with no change | 139.2 | 133.4 | 3 | 41 | 3 | **3.36** |+| facebook/react v19.3.0 | Code-only extract | 356.5 | 335.8 | 3 | 685 | 3 | 0.52 |+| | Priming update | 756.6 | 728.1 | 3 | 972 | 3 | 0.78 |+| | Update with no change | 434.9 | 407.5 | 3 | 56 | 3 | **7.71** |+| vercel/next.js v16.4.0 | Code-only extract | 1,442.5 | 1,432.4 | 3 | 2,810 | 3 | 0.51 |+| | Priming update | 2,907.1 | 2,901.8 | 3 | 3,423 | 3 | 0.85 |+| | Update with no change | 2,926.1 | 2,923.5 | 3 | 3,525 | 3 | 0.83 |+| pandas-dev/pandas v3.0.6 | Code-only extract | 687.6 | 684.0 | 3 | 1,778 | 3 | 0.39 |+| | Priming update | 802.5 | 795.7 | 3 | 2,323 | 3 | 0.35 |+| | Update with no change | 687.9 | 685.5 | 3 | 2,164 | 3 | 0.32 |+| scikit-learn/scikit-learn 1.9.1 | Code-only extract | 388.8 | 383.5 | 3 | 941 | 3 | 0.41 |+| | Priming update | 508.0 | 504.6 | 3 | 1,498 | 3 | 0.34 |+| | Update with no change | 381.8 | 379.6 | 3 | 44 | 3 | **8.67** |+| spring-projects/spring-boot v4.1.1 | Code-only extract | 1,075.4 | 1,068.3 | 3 | 1,121 | 3 | 0.96 |+| | Priming update | 2,479.9 | 2,476.2 | 3 | 3,218 | 3 | 0.77 |+| | Update with no change | 1,574.7 | 1,568.9 | 3 | 2,718 | 3 | 0.58 |+| rails/rails v8.1.4 | Code-only extract | 429.3 | 396.5 | 3 | 503 | 3 | 0.85 |+| | Priming update | 947.1 | 856.4 | 3 | 1,044 | 3 | 0.91 |+| | Update with no change | 504.0 | 435.9 | 3 | 879 | 3 | 0.57 |+| kubernetes/kubernetes v1.37.1 | Code-only extract | 3,058.9 | 3,057.4 | 1 | 3,541 | 1 | 0.86 |+| | Priming update | 10,167.3 | 10,166.1 | 1 | 15,395 | 1 | 0.66 |+| | Update with no change | 6,427.2 | 6,422.1 | 1 | 13,941 | 1 | 0.46 |+| microsoft/vscode 1.141.1 | Code-only extract | 3,182.4 | 3,180.7 | 1 | 5,927 | 1 | 0.54 |+| | Priming update | 6,501.7 | 6,498.0 | 1 | 10,108 | 1 | 0.64 |+| | Update with no change | 4,188.9 | 4,169.8 | 1 | 10,499 | 1 | 0.40 |++- **Lower in 34 of 39 measurements**, from 0.30 (ripgrep extract) to 0.96+ (spring-boot extract) of Graphify 0.9.100's figure; the Kubernetes extract+ peaked at 3,059 against 3,541 MiB (0.86).+- **Higher in 5 of 39:** the five updates with no change in which Graphify+ stops early; its peak there is 40 to 56 MiB, and the ratios are 1.69+ (ripgrep) to 8.67 (scikit-learn).++#### How these runs differ from the runs against Graphify 0.9.91++- The machine: one AMD EPYC 9V84 virtual machine (40 vCPUs), not the node with+ two Intel Xeon Platinum 8480C (96 cores).+- The order: measured runs one at a time, alternating between programs (then:+ parallel chains, one program after the other, not alternated), with a warm-up+ for all 11 smaller repositories (then: none for react, next.js and+ spring-boot).+- Peak memory: both programs' figures come from the same runs (then:+ Graphicle's came from separate runs of a later build).+- Graphicle 0.1.11 was built from its release source on the test machine, not+ taken from the release archive.+- The run records name local paths, so they stay with the maintainers.+### Parity with GraphifyThe engine is a Rust port of Graphify. It follows Graphify