Rewriting the Silver Searcher in Rust

I rewrote the core search path of The Silver Searcher in Rust and benchmarked that rewrite against the original tool. This post captures that first benchmark pass: on the only measured performance workload, rust-ag was roughly 2× faster than ag.

That was the honest headline, but not the whole story. rg and ugrep were still faster, the performance data covered only 1 of 38 registered scenarios, and the overall claim gate still returned fail because the reproducibility bundle validation step was not finished. So this was a promising first result, not a victory lap.

The result in one view

The measured workload was the literal-simple scenario: search for "foo" across the repository working tree.

The key comparison is ag versus rust-ag. That pair was checked for output parity. The cross-tool numbers are still useful context, but they are not the same kind of comparison because rg and ugrep make different default choices about traversal and ignore handling.

What was actually measured

This first pass is intentionally narrow.

• Scenario: literal-simple
• Query: search for "foo"
• Corpus: the repository working tree
• Sampling: 1 warmup iteration and 3 measured samples per tool
• Environment: Apple M4, 16 GiB RAM, macOS Darwin 25.3.0
• Statistics: median runtime, IQR, and 95% percentile bootstrap confidence intervals
• Bias control: tools ran in interleaved-random order

That setup is enough to say something useful about this workload. It is not enough to claim a universal ranking for every kind of search.

Correctness came first

Before looking at speed, I checked whether the rewrite still behaves like ag on the smoke scenarios that matter most for day-to-day use.

rust-ag matched ag across all 8 smoke scenarios that were checked:

• literal simple
• literal word
• literal no match
• regex simple
• literal nocase
• context before/after
• count matches
• files with matches

That matters because it makes the ag versus rust-ag speedup meaningful. rg and ugrep landed in different output clusters during the correctness gate, which is expected: their default traversal and ignore rules select different file sets.

Speedup ranges across local, nightly, and manual runs

The 2× result was not a one-off. Across the three run types, rust-ag stayed between 1.96× and 2.03× faster than ag.

The improvement over ag looks stable inside this test window. The ranking also stayed stable: ugrep → rg → rust-ag → ag.

Scope limits that matter

The right way to read this study is: the rewrite looks promising, and the limits are real.

• Only 1 of 38 registered scenarios has measured performance data. A regex-heavy or output-heavy workload could change the shape of the ranking.
• Each tool only has 3 measured samples after 1 warmup. That is enough for a first read, but not enough to stop worrying about variance.
• Everything ran on one Apple M4 machine. Linux, x86_64, or a different filesystem could move the numbers.
• The overall claim gate still failed. The parity checks, threshold checks, and cross-run agreement passed individually, but the full gate stayed red because the reproducibility bundle validation step is still incomplete.

That last point matters. I do not want to quietly skip it just because the speedup looks good.

Bottom line

This rewrite clears a useful bar: on the measured workload, it preserves ag's behavior in the smoke checks and cuts median runtime roughly in half.

It does not clear the stronger bar of being the fastest tool in the comparison set. rg and ugrep are still ahead, and this benchmark window is much too small to pretend otherwise.

That is why this is worth publishing as a rewrite study: the interesting result is not just that Rust helped, but that the evidence still forces a careful conclusion.

Repo and evidence

The current public branch now exposes the published rewrite workspace plus parity/manifests, so the links below point there directly.

• Published repository branch
• Rust rewrite workspace
• Parity tooling
• Scenario and fixture manifests