The open source Rust ecosystem: what runs in production

I put this survey together with the research templates for agents, to decide what to bet on in my Rust projects. The first version had a good rule, "a benchmark number only goes in with a source", that it did not follow itself: several sources were just a site's home page, with no article, and the stars came rounded from third-party rankings.

All stars below were read from the GitHub API on 13 October 2026.

The core, by stars

Repositories with more than 20 thousand stars where Rust is the main language, according to GitHub. Where a description carries a performance number, it is what the project itself claims in its README.

By domain

Command-line tools

The ripgrep, fd, bat, delta and just tools are already in the core. Below them:

Git, build and binary size

Runtimes and platforms

Deno, Bun, Tauri, pnpm and tokio are in the core. The smaller async runtimes and the WebAssembly platforms:

Infrastructure, databases and search

Meilisearch, Qdrant, InfluxDB, SurrealDB, Polars and SpacetimeDB are in the core.

Web and APIs

Axum, Actix Web and Rocket are in the core.

Security and cryptography

Vaultwarden is in the core.

AI, ML and LLM infrastructure

Qdrant, Chroma, Polars and Tabby are in the core.

Embedded and low-level systems

Outside GitHub, Ferrocene is a Rust compiler qualified for safety-critical software, such as automotive.

Graphics, GUI, games and audio

Bevy, egui, iced and Slint are in the core. The physics in rapier is the same idea of simulation that shows up, at another scale, in the Z machine.

Blockchain and zero-knowledge proofs

Sway is in the core.

Benchmarks with a source

I kept only the benchmarks with a primary source, code or methodology. Out went the async runtime ones (a post with no code or raw data), the WebAssembly runtime ones (the repository itself marked the numbers as placeholders), and the gitoxide and Redis-style server ones (the sources were only a site's home page, or a site that is down).

Ripgrep versus grep and friends

The ripgrep README has tables measured by the author on an Intel i9-12900K. Searching for [A-Z]+_SUSPEND as a word in the Linux kernel source:

Ignoring .gitignore and filtering by file type, ripgrep takes 0.063 s and GNU grep 0.674 s. On a single file of about 13 GB already cached, the search Sherlock [A-Z]\w+ takes 1.042 s in ripgrep, 1.339 s in ugrep and 6.577 s in GNU grep. The same README shows the limits: on a pattern with no literal, like [A-Za-z]{30}, the lead over GNU grep drops to about 2x, and there are patterns where another tool falls off a cliff and ripgrep does not. The first version of this post cited these numbers from ripgrep.dev, which is an unofficial site.

Web frameworks

Sharkbench measures concurrent requests with I/O and JSON on an Intel Core Ultra 5 325 running Linux. The page was updated on 5 October 2026:

Two caveats. The order changes between updates: in the first version of this post, with numbers from another run, Actix was first. And the page does not describe the load generator or concurrency, so Gin behind Express is a result I would not take as a rule without reading the test code.

JavaScript runtimes

I removed the Bun, Deno and Node numbers: the sources were author profile pages, with no article. What stays is the warning that applies to any comparison of this kind. In a discussion in the Deno repository, Luca Casonato, from the Deno team, answers that you cannot compare two systems with a single HTTP benchmark, because that test does no routing, serves no static files and ignores the rest of what a server does.

Pingora versus NGINX, in production

In Cloudflare's September 2022 post, Pingora serves more than a trillion requests a day and, under the same load, uses about 70% less CPU and 67% less memory than the previous NGINX-based service. Median TTFB dropped by 5 ms and p95 by 80 ms. For one large customer, the connection reuse ratio went from 87.1% to 99.92%, which cut new connections to the origin by 160 times. Much of the gain comes from sharing the connection pool across threads, which NGINX's process model does not allow.

Polars, pandas and plain Rust

Haixuan Tao compared the three on a 4.2 GB dataset from Stack Overflow, on an Intel i7-8750H with 12 threads, with open code:

Leaving out reading the file, multithreaded Rust takes 1.7 s against 40 s for pandas, about 23x. His advice: Polars for the API and for merges and group-bys, pandas when performance and memory do not matter.

WebAssembly runtimes

I found no reproducible, current comparison. If you want to go through the literature, Hockley and Williamson measured scripting performance in Wasmer at the ICPE 2022 conference.

Who uses it in production

Only the cases with a source from the company itself stayed:

• VS Code search switched to ripgrep in version 1.11, in 2017
• Cloudflare replaced NGINX with Pingora in the proxy that connects its network to the internet
• Firecracker runs AWS Lambda and AWS Fargate, according to its README
• Discord moved its Read States service from Go to Rust in 2020, because of latency spikes from Go's garbage collector
• Vercel finished porting Turborepo from Go to Rust

The first version had more cases and a list of market statistics, such as "45% of the Fortune 500 run Rust", taken from blogs with no source. I removed everything I could not tie to a primary source, including "Discord cut memory by 8 times", which Discord's post does not say.

What I take from it

Most of the top is developer tooling: search, terminals, shells, editors, package managers. It makes sense, because the first Rust adopters were developers writing tools for themselves, where speed, resource use and the command-line experience decide. Right behind come infrastructure and data: proxies, vector databases, search, time series, DataFrames.

The technical patterns repeat. Servers are async on tokio. The most common shape is a single binary configured by file or command line. WebAssembly plugins show up where cheap runtime extension is wanted, as in Zellij. And the foundation is almost always the same: serde, clap, anyhow and thiserror, rayon, reqwest, hyper.

Where there is a serious benchmark, the advantage holds, but with limits. On the Linux kernel, ripgrep is 3 to 11 times ahead of the other tools, and loses its margin on patterns with no literal. Pingora shows a production gain, with CPU and memory measured by the operator itself. Outside those cases, the gain over optimized C or Go is often small, and what weighs in the choice is memory safety, the type system and tooling.

The gaps I see: a full-stack web framework with a plugin ecosystem at the level of Django or Rails, a complete data engineering stack at the level of Spark and Airflow, GUI that competes with Electron and Qt, and native ML that competes with PyTorch. Burn and Candle exist, but are still smaller.

Rust and WebAssembly books and resources

The starting point changed in 2025: the rustwasm organization on GitHub was sunset, and "The Rust and WebAssembly Book" was frozen. wasm-bindgen and wasm-pack moved to a new organization, wasm-bindgen. The old book is still good as an introduction, it just stopped in time.

Rust foundations

WebAssembly demands ownership and borrowing (there is no garbage collector in the browser), interop with JavaScript, async and no_std, because many environments do not have the full standard library.

Rust and WebAssembly

Watch out for the flood of AI-generated self-published books since 2023, with titles like "Rust for WebAssembly" and authors with dozens of books a year. Before buying, it is worth checking the publisher and whether the author has public code.

WebAssembly in general

In Portuguese

The only Brazilian book on WebAssembly with Rust I found is Desmistificando WebAssembly, by Raphael Amorim, from Casa do Código, with examples on GitHub. For Rust in general, there is the translation of the 2nd edition of Programming Rust, from Novatec in 2023, and Primeiros Passos com a Linguagem Rust, by José Augusto Manzano, also from Novatec, from 2018. The community maintains a translation of the official book. The rest depends on English.

Documentation with the depth of a book

There is still no book on WASI 0.2 and the component model (only the Bytecode Alliance documentation), on the new frameworks like Leptos and Dioxus, or on security and fuzzing of WebAssembly modules, which today lives in academic papers, like this one from 2024.

People and visualization projects in Rust and WebAssembly

People

The first version had each person's country and role, and errors: it attributed wgpu to two people as if they were one, gave another the wrong name, and listed two profiles that do not exist. I removed the country, which is personal data and which the source itself contradicted. I also removed the role, because what can be checked without depending on anyone's word is the contribution. In the table, each project was checked against the GitHub contributor list. Anyone with no confirmed link was left out.

Graph, chart and visualization projects

The projects on GitHub, with stars from the API. Renamed ones already show their new name.

Outside GitHub, as crates: forge-charts makes interactive SVG charts for Leptos without JavaScript; mermaid-rs-renderer renders Mermaid diagrams in pure Rust and claims to be 100 to 1,400 times faster than mermaid-cli; dagre ports dagre's Sugiyama layout; and web-sys and js-sys are the bindings for web APIs and JavaScript objects, maintained inside wasm-bindgen. On the commercial side, Ogma, from Linkurious, is a WebGL graph engine.

What I take from it

Visualization in Rust and WebAssembly splits into four groups. GPU rendering: wgpu, vello, three-d, bevy. Charts and dashboards tied to web frameworks: plotters, plotlars, charming, leptos-chartistry. Graphs: petgraph, egui_graphs, fdg, dagre. And scientific visualization: rerun, resvg, tiny-skia.

Graphs are the weakest group. There is no mature equivalent of networkx or d3-force in Rust with WebAssembly, and advanced layout, hierarchical or Sugiyama, is still rare. For large, dynamic graphs in the browser, JavaScript is still ahead with sigma.js and cytoscape.js. And there is little material in Portuguese linking Rust and WebAssembly to data visualization. A Portuguese-speaking community exists, like the Rust Brasil group on Telegram, but I found no Brazilian visualization project with international traction.