Fyra Labs Says Tov's Faster-Than-Rust Benchmarks Compare Against Slowed Rust

Fyra Labs published a rebuttal on Oct. 22 of the benchmarks that Tov, a 0.0.1 programming language, uses to claim it is "faster than Rust." The post says three of the Rust programs were written to run slowly, and that its own rewrites match Tov's times.

Tov is an MIT-licensed language with TypeScript-style syntax that checks its code, translates it to C and hands the result to clang. Its repository sits under the richiemcilroy GitHub account, and the site says it comes from the team behind the Cap screen recorder. The repository was created Sept. 29 and had 749 stars on Oct. 24.

The Fyra post, written by an author who signs as Madomado on the company's blog, says the Tov team's figures could not be reproduced. It names no individual developer, and it includes no response from Tov.

What Tov's own README now shows

The Tov README lists medians of five runs on an Apple M4 Max, dated Oct. 22. It is vendor-supplied data, and no independent party is named as having run it. The same table has Tov behind Rust on four of 12 rows.

Benchmark	Rust (ms)	Tov (ms)
binary_trees	849	268
dispatch	85	44
map_insert	548	204
decimal_ledger	139	310
async_calls	15	19
mandelbrot	546	564

The tov.sh page shows a different set of M4 Max figures: 36 ms against Rust's 77 ms on dispatch, and 284 ms against 490 ms on map_insert. It also credits Tov with a 33 KB binary against 351 KB for Rust, and notes that Tov checks integer overflow by default while Rust release builds do not.

Where Fyra says the Rust code was slowed

Fyra ran the repository at commit c2048582 on three machines: an Intel Xeon Platinum 8251C in a container, an i9-13900H laptop and a QEMU virtual machine. Rust was built with cargo build --release and timed with hyperfine.

The dispatch benchmark calls area() 50 million times on 1,000 shapes held as Vec<Box<dyn Shape>>, which forces dynamic dispatch. Fyra swapped in an enum with match and #[inline(always)]. On the first Xeon run the original Rust took 298.2 ms, Tov 52.4 ms and the rewrite 48.8 ms.

1. Original Rust298.2 ms
2. Tov52.4 ms
3. Fyra's Rust rewrite48.8 ms

Source: Fyra Labs, Debunking 'Faster than Rust', Oct. 22, 2026

The map_insert test inserts 2 million string keys and looks each up. The original used std::collections::HashMap, which Fyra says resists HashDoS attacks and so runs slower. Swapping in ahash took the first Xeon run from 1.705 seconds to 482.5 ms, against Tov's 600.9 ms.

The bigint_fib test went the other way. Tov's figures were 168 ms for Tov and 501 ms for Rust. Fyra measured Tov at 451.3 ms and Rust at 336.6 ms on the first Xeon run, a 1.34 times lead for Rust.

The claim underneath

Fyra's argument is structural. Tov emits C and Rust performs about like C, so a Tov win means one C-speed program beat another. The post calls the benchmarks "maliciously crafted to slow Rust down," a motive Fyra has no document to prove. The Terminal did not run the code, and the figures here are Tov's and Fyra's own.

Tov's README says the language is early and changing daily. Fyra's post carries no reply from Tov's developers, and the next README table will show whether the Rust rewrites are adopted.

Benchmark claims from a vendor deserve the same treatment as the ones in Alibaba's Qwen3.8-27B release, where Artificial Analysis supplied the independent figure. Self-published numbers on agent tooling are also the subject of our look at Cloudflare's security-audit skill.