Topic
Rust
2026-11-09 · notes
Cargo Takes Minutes. Mitts Takes Seconds: 12 rustls WorktreesA parallel build of 12 rustls worktrees on Linux x86_64: Cargo takes 3 min 42 s, Mitts 9.3 s. How prewarmed shared caches reuse build work—and where Cargo still wins.
8 min
2026-11-07 · release
Mitts 0.3.29: -q, Cargo's message formats and a workspace E0463 fixmitts test --quiet and mitts check --message-format=short were rejected on 0.3.28 and are accepted now; check --workspace --all-targets no longer fails with E0463 on test targets; macOS binaries no longer keep a symlinked checkout path.
4 min
2026-11-05 · release
XRef 0.4.0: from serialized keys to the code that writes the fieldsUltra Blazing Fast XRef 0.4.0 adds xref field: give it the keys a stripped binary serializes, get field offsets with instruction evidence and ranked candidate writers. A recorded walkthrough on a synthetic test program, and the limits.
7 min
2026-11-03 · release
XRef 0.3.0: from a running process back to the instruction that wrote a fieldXRef 0.3.0 adds live inspection of Linux x86-64 processes and ties it to the same static analysis: find a value in memory, translate pointers to static addresses, count calls, and catch the store that changes a field. A recorded walkthrough on a stripped fixture, and the limits.
4 min
2026-11-02 · notes
57 seconds or 6 milliseconds: a first question to a stripped binaryOn one stripped Rust binary, a Ghidra 12.2 headless run (import, default analysis, one decompilation) took 57 to 59 s and found 1,123 of 2,096 function starts. Single xref commands took 2.5 to 6.4 ms and matched all 2,096. Plus two places where Ghidra is right and xref is not.
7 min
2026-10-27 · notes
The tree the node was buildingA remote build is only as good as the copy it builds. Three bug reports filed within one minute showed three ways the gateway's copy had drifted from the checkout: files cut by extension, directories that never went away, and a Swift package that never reached the Mac.
6 min
2026-10-21 · notes
The diff that was emptyTurning an associated function into a method is the mirror of making a method static, and the easier half. Writing it turned up something else: every write tool in the project reported an empty diff once it had applied its edit, because the old text was read after it was overwritten.
5 min
2026-10-19 · notes
Two conversions, three decisionsA type migration that writes .into() at every broken site sounds like the dangerous version. It holds up when the analyzer decides which conversions stay: only the ones that type-check and break nothing else are kept; the rest are taken back and left for a person. Type-correct, not judged right.
6 min
2026-10-18 · notes
The caller nobody editedA declaration edit can leave call text unchanged while breaking type inference. The original generify report illustrates why callers still need checking, and why failed caller discovery must stop the plan.
5 min
2026-10-17 · notes
Two negations, one meaningInverting a boolean predicate requires changing both its body and its uses. Three direct-call shapes explain the negations and parentheses; a September prod-code implementation also shows the limits of reference discovery and textual rewriting.
5 min
2026-10-14 · notes
The receiver that did somethingRemoving an unused receiver can still remove an evaluation at the call site. A September prod-code implementation blocked selected receiver shapes; its textual rule shows why type checks alone cannot establish that a rewrite preserves behaviour.
5 min
2026-10-13 · notes
The callers a return-type assist leaves behindA September rust-analyzer probe wrapped a function’s return type without updating its callers. The first prod-code implementation added propagation candidates and a report of unresolved calls. Its limits show why the caller side needs a separate check.
5 min
2026-10-12 · notes
What checking a fix revealedSeptember's prod-code fixes exposed a per-file exception that skipped its own case, a refusal that said too much, and an estimated cost replaced by a reported measurement. What those records teach about checking a fix.
4 min
2026-10-11 · notes
The function that was a fileChecking a proposed edit to a large file took half a minute, and running the check on sixteen threads changed almost nothing. The cause was a single function. Splitting it with the tool itself took the check to four seconds; the work turned up six bugs in the tool.
7 min
2026-10-11 · design note
Offloading the language server to a clusterA Swift subproject can sit inside a Rust checkout, and a validation request can disturb the engine answering navigation queries. How prod-code v0.3.29 chooses a compatible node and separates proposed edits from ordinary analysis.
4 min
2026-10-10 · notes
Every place a struct is builtTurning a value computed inside a method into a field is three small edits. The hard part is the third: finding every place the struct is built, among everything the analyzer calls a reference to it. Imports, return types and `Self` all qualify, and a pattern that lists every field breaks.
5 min
2026-10-09 · notes
The dry run someone else paid forA dry run is supposed to be the cheap step. Here it cost the next query, whoever asked it, twenty seconds. Moving validation onto a second analyzer fixed that, but the first measurement of the fix was taken on the wrong machine, and the second showed the cost had only moved.
8 min
2026-10-08 · notes
The errors were there before the editA new refactoring made a field private and rewrote every access to it, and its diff was right. Its verdict was 124 errors. The unchanged file reported the same 124, and every write tool had been counting them; our reading is that none of them was the edit's.
9 min
2026-10-07 · notes
The argument that landed in the wrong callFour bugs fixed in one afternoon, in the tools that write your code, and every one of them was a place where a tool took something on trust: a position, a write, a verdict, a line number. What each one did, how it was found, and what it checks now.
7 min
2026-10-06 · notes
A hundred and twenty-seven problems, three of them realChanging a type is the refactoring with the widest blast radius and the least help. Using the analyzer's diagnostics as the work list is the obvious design and it produced a report that was about 98 percent noise (124 of 127) - for a reason worth knowing about any tool built on an IDE's engine.
6 min
2026-10-05 · notes
The refactoring that changes nothingPromoting a magic value to a parameter is only safe if every existing caller keeps passing the value it had. That constraint is the whole design - and it is also why the tool refuses some extractions outright, and why the analyzer's answer to 'what function is this in' was the wrong question.
6 min
2026-10-04 · notes
Zero errors, and it did not compileEvery write tool in this series ends by saying the analyzer accepts the result. Building the one that bundles parameters into a struct produced a case where that sentence was printed and the code still did not build - and a four-line probe that says exactly how far the promise goes.
7 min
2026-10-03 · notes
The refactoring that is mostly importsMoving a function to another module is cut and paste and then an unbounded amount of fixing every file that imported it. Building the tool that does both, and the two bugs that made it quietly skip the second.
7 min
2026-10-02 · notes
A killed process writes no profileCoverage went from 53% to 87% and every file in the coverage report crossed 80%. Three things cost a day each: a SIGKILL that silently erased a whole daemon's coverage, a test that passed by skipping, and a read with a deadline it never checked.
9 min
2026-10-02 · notes
Sharing rust-analyzer across Git worktrees: in-memory overlay architecture and concurrency lessonsIn a multi-agent coding fleet, running separate rust-analyzer instances for every Git worktree multiplies memory consumption. Here is how an in-memory VFS overlay shares a single analysis database across worktrees, the Salsa concurrency traps we encountered, and our proposal to upstream.
6 min
2026-09-30 · notes
The refactor no tool ownsRename is everywhere; changing what a function takes is nowhere. Building it meant letting the declaration write the rule, checking the result against the analyzer's own reference list, and refusing, under a normal apply, to write what the analyzer rejects.
6 min
2026-09-30 · notes
204 Code Clones and Two Self-Loops: Dissecting Bevy's 97-Crate Engine with 67 AST ToolsWe benchmarked all 67 prod-code AST tools against bevyengine/bevy: 661K lines of Rust, 97 crates, 204 exact code clones, 2 dev-dependency loops, and Bug #739 discovered and fixed in fast-sync.
12 min
2026-09-30 · notes
347 Code Clones and a Self-Loop: Breaking Down uv's 74-Crate Workspace with 67 AST ToolsThe author's report of running the prod-code AST tool suite against astral-sh/uv: 559K lines of Rust, 74 crates, 347 reported duplicated test-fixture occurrences, a self-referential cycle in uv-preview, and Issue #738 resolved in fast-sync.
12 min
2026-09-30 · design note
From 1,623 µs to 129 µs: zero-copy SIMD wire streamingA 5.7 MB binary wire block stream took 73 milliseconds to parse with standard MessagePack deserialization, one cost on an ingest thread reported to fall behind in market bursts. How SIMD search and fixed-point integers took per-block latency from 1,623 µs to 129 µs and throughput to 978 MB/s.
7 min
2026-09-30 · design note
Half a Million Lines of Arrow: What 67 AST Analyzers Found Inside Polars' Query EngineWe pointed all 67 tools of prod-code at pola-rs/polars on an idle 32-core cluster node. 526K lines of Rust across 33 crates, 4 reported cycles that are dev-dependency edges, catching a UTF-8 non-char-boundary tokenizer panic, in-memory RAM validation, and 36-test remote execution.
16 min
2026-09-29 · notes
Hover lies by omissionA struct with eleven fields shows ten, so any test value built from that answer is missing one, and the only hint is an ellipsis the agent ignored. What it takes to generate a fixture you can trust: read the declaration rather than the summary, and type-check the result before handing it over.
7 min
2026-09-29 · design note
7,156 Cyclic Module Paths: Stress-Testing Tantivy's Search Engine with 67 AST ToolsWe subjected quickwit-oss/tantivy to all 67 prod-code tools on an idle 32-core cluster node. Reported results: 7,156 module cycle paths, 18-file AST renames, clone detection in JIT expressions, and safe-delete invariants.
17 min
2026-09-29 · notes
What our ripgrep report can and cannot showWe reassessed our September ripgrep report. Its published excerpts do not substantiate the claimed tool coverage or speedups; issue #735 documents a narrower failure in prod-code.
5 min
2026-09-29 · design note
Six Circular Dependencies in Tokio: What 67 AST Analyzers Found Inside Rust's Async EngineWe pointed all 67 tools of prod-code at tokio-rs/tokio on an idle 32-core cluster node. From 6 reported dependency cycle paths and silent Deref evaluation ordering traps to an unhandled sysroot crash on Box-here is what happened.
19 min
2026-09-28 · notes
The files are not the answerAn agent asked to change one function opens three files and spends most of its context on code that has nothing to do with the task. A slice is the other shape of the same question: the declarations the function depends on, and nothing that merely lives beside them.
8 min
2026-09-27 · notes
Both bugs said no matchesA structural rewrite that found nothing, twice, for two unrelated reasons in two different layers. What it takes to tell an empty answer from a broken one, and why the fix was tracing rather than thinking harder.
6 min
2026-09-24 · design note
One terminal engine for the server, the Mac and the phoneProd keeps agents' terminals on a server and shows them on a Mac and an iPhone. Three emulators disagreed about the same bytes, so we replaced them with one Rust engine that moves its state instead of a picture of it.
11 min
2026-09-23 · design note
The analyzer already knows your patch is brokenAn agent writes a file, runs a build, reads the errors and tries again. The database that answered its last hover could have told it in 100 ms, without writing anything. What that takes, and the one error class the rust-analyzer build we embed stayed silent about.
6 min
2026-09-21 · design note
Salsa has no branchesTwo agents on two worktrees of one repository, sharing one analyzer database, answer each other's questions. A benchmark that forks four worktrees and asserts what each should see, and why we stopped trying to share anything writable.
7 min
2026-09-21 · design note
Your laptop is the wrong place for rust-analyzerTen coding agents in ten worktrees means ten analyzers and ten cargo builds on one machine. We moved the analyzer, the builds and the tests to Linux nodes on the LAN, mirror the checkout there by content hash, and let the laptop do the one thing it is good at: editing.
7 min
2026-09-16 · design note
rapidfire: the channel between a market feed and a decisionThe hand-off between a market-data reader and a strategy loop is one of the few latencies in a trading process under our control. How we built a lock-free channel for it, what broke on a 128-core ARM box, and where the assembly landed.
7 min




