Tooling, crates, and developer applications
Cargo workflows, static analysis, CLI tools, terminal applications, language tooling, and notable Rust crates or open-source projects.
42%
Best tweets about Rust
50 Best Tweets About Rust (2026)
Find the best tweets about Rust programming, including ownership, async, performance, tooling, libraries, systems design, releases, and developer experience.
Rust programming language features, systems engineering, ownership, async, performance, crates, tooling, releases, and production lessons.
- Creators
- 40
- Updated
Original Xholic analysis
What 50 top Rust posts reveal
Rust discussion is concentrated in tooling and crates (42%), performance-oriented systems engineering (34%), and adoption or migration (30%). The dataset is predominantly supportive in stance (74%) and positive in sentiment (76%), while major engagement outliers include a Pake case study, a Polymarket Rust CLI announcement, and a Rust learning roadmap.
- Dominant tone
- Positive
- Median score
- 8.01
- Leading format
- Announcement
- Recent posts
- 32%
76% of posts
All-time engagement
58% of posts
Published in 90 days
Conversation map
The themes creators return to
Performance-oriented systems engineering
Low memory use, fast startup and builds, benchmarking, profiling, hardware-aware optimization, and efficient native software.
34%
Rust adoption and migration
Ports and rewrites from C/C++, Zig, Go, JavaScript, and other ecosystems, including AI-assisted migration and ecosystem shifts.
30%
Learning resources and roadmaps
Rust curricula, books, exercises, tutorials, backend learning paths, and practical progression from basics to production.
24%
Production backend engineering
Rust services using Axum, Actix, gRPC, SQLx, PostgreSQL, observability, testing, deployment, and operational reliability.
22%
Rust language fundamentals
Ownership, borrowing, lifetimes, structs, traits, type-system concepts, inheritance alternatives, and learning mental models.
20%
Web, WebAssembly, and language interoperability
Rust with WASM, browser deployment, JavaScript and TypeScript bindings, Python extensions, PHP tooling, and frontend integrations.
20%
Async, parallelism, and concurrent systems
Tokio and async/await, thread pools, channels, non-blocking I/O, Rayon, linearizability, and race-safe parallelization.
18%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 36
- Median reposts
- 3
- Median replies
- 2
- Median views
- 2.5K
Posts with media make up 50% of this collection. Their median all-time score is 15.5, compared with 5.58 for text-only posts.
Format mix
- Announcement 58% · score 11.9
- Case Study 16% · score 8.54
- Opinion 12% · score 1.41
- List 6% · score 210.3
Consensus and debate
Where creators agree, and where they do not
Shared view
Tooling and crates lead the conversation
Tooling, crates, and developer applications are the largest theme, accounting for 42% of tweets (21 posts). Examples include a Rust CLI, an agent-oriented project, and terminal-project curation.
Shared view
Posts present Rust across deployable application contexts
Evidence includes terminal tooling, an agent-oriented project, a Rust backend with shared WASM logic, and a web project using Axum, SQLx, PostgreSQL, and Docker.
Shared view
Learning roadmaps connect fundamentals to applied work
Roadmap and learning posts move from ownership, borrowing, lifetimes, traits, and Cargo toward async services, testing, profiling, and backend or operational tooling.
Shared view
Concurrency and safety appear together in Rust discussions
One browser-development post says Rust makes parallelization easier when developers have confidence code is not racy; other learning resources cover Tokio, async/await, threads, and synchronization primitives.
Open debate
Migration enthusiasm meets caution about mandates
One post characterizes Bun’s move from Zig to Rust as a Rust win. Another distinguishes Microsoft’s AI-assisted migration research from a corporate mandate or a plan to rewrite Windows in Rust.
Open debate
Production-oriented framing versus concerns about overengineering
A post recommends Rust for agent workloads needing concurrency, long-running processes, WASM deployment, and memory-safe shared state. A separate critique warns against assuming every side project needs production-grade guarantees before it has users.
Open debate
Traits remain a learning friction point
Roadmaps place traits among core Rust concepts, while one developer describes Rust traits as a difficult mental model because they combine ownership, dispatch, types, and less-obvious limitations.
What performs
Patterns behind standout posts
Pake case study was the largest engagement outlier
The Pake post had the highest all-time score in the dataset: 3226.4, or 402.8 times the overall median. The post describes Rust-and-Tauri desktop wrappers and cites smaller app-size comparisons.
Announcements were the most common format
Announcements accounted for 58% of tweets and had a median all-time score of 11.892. The Polymarket Rust CLI announcement was an engagement outlier with an all-time score of 1387.51.
Lists had the highest format-level median score
List-format posts represented 6% of the dataset and had the highest format median all-time score, 210.301. Relevant examples include Rust learning roadmaps and a post about free Rust books.
Media-bearing posts had a higher median score than text-only posts
Posts with media made up 50% of the dataset and had a median all-time score of 15.461, compared with 5.583 for text-only posts. This is a dataset-level comparison and does not establish that media caused higher performance.
Statistical standouts
- View standout post 1 Score 3226.4 · 402.8× median
- View standout post 2 Score 1387.5 · 173.22× median
- View standout post 3 Score 461.1 · 57.57× median
- View standout post 4 Score 273.0 · 34.08× median
- View standout post 5 Score 210.3 · 26.25× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 20% of the selected posts.
-
1. Vaishnavi
@_vmlops
2 posts
-
2. flux
@0xfluxsec
2 posts
-
3. Bilgin Ibryam
@bibryam
2 posts
-
4. Francesco Ciulla
@FrancescoCiull4
2 posts
-
5. GitHub Projects Community
@GithubProjects
2 posts
-
6. Insha
@Insharamin
2 posts
Vaishnavi combined learning resources with high median performance
Vaishnavi posted twice and had a median all-time score of 105.42. One cited post highlights Microsoft’s Rust learning books, including material on async Rust and engineering practices.
Orhun Parmaksız covered project discovery and an embedded build story
Orhun Parmaksız’s two posts include a Top 99 Rust terminal-project roundup and a blog post about building a guitar trainer with embedded Rust.
Repeat contributors covered distinct hands-on topics
Flux posted about Rust security research and exploring Redox OS, while Joe Sluis posted about a PostgreSQL extension with pgrx and a minimal gRPC server using tonic/prost.
Since the previous snapshot
What changed since Aug 12, 2026
- 76% of the selected posts remained.
- The creator count changed by 0.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 50-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best Rust tweets
Top Rust tweets from 40 creators
Ranked 01–50
- 01
@heynavtoor ·
A developer in China named tw93 got tired of his laptop dying. He would open Slack and watch 524 megabytes of disk space disappear. He would open Discord and watch another 265. He would open Notion and watch 800 megabytes of RAM evaporate before he had typed a single word. He looked into why. Every "desktop app" on his computer was the same thing. A website wrapped in a full copy of the Chrome browser engine. The framework is called Electron. An empty Electron app starts at 150 megabytes of RAM before you click anything. With twelve of them open, his laptop was running twelve copies of the same browser. He thought there had to be a better way. So in 2022, he started building one. He called it Pake. Two characters in Chinese mean "packaging." He wrote it in Rust on top of a framework called Tauri. The idea was simple. Point Pake at any webpage. Get a desktop app. Without dragging an entire browser engine into the binary. The first version of Slack he wrapped with it was 8 megabytes. Not 524. Eight. That is what 20 times smaller looks like. Four years later, his repo has 50,594 stars. 6,144 forks. The license is MIT. The last commit was yesterday. The bio on his GitHub reads: "Anything added dilutes everything else." Today the Pake releases page contains pre-built apps for ChatGPT, Discord, Gemini, Grok, DeepSeek, Twitter, YouTube, Excalidraw, Flomo, WeChat, and twelve more. All under 10 megabytes. All native. All free. Or you point Pake at any URL you want and it builds one for you in one command. Slack's desktop app: 524 megabytes. Pake-built Slack: 8 megabytes. Discord's desktop app: 265 megabytes. Pake-built Discord: 9 megabytes. ChatGPT for Windows: 260 megabytes. Pake-built ChatGPT: 9 megabytes. tw93 is one person. He has 11,305 followers on GitHub. He runs a blog at https://t.co/WZoyHop8Id. He has shipped 39 public repos. He still pushes commits to Pake every week. He did not start a company. He did not raise money. He did not write a Medium post about how Electron is dead. He just shipped the thing that made it true. (Link in the comments)
- 02
@aiwithmayank ·
🚨BREAKING: Polymarket just open-sourced their official Rust CLI and it gives developers full programmatic access to the entire prediction market browse, trade, manage positions, and pipe live data into scripts and AI agents all from the terminal. Here is what you can do with it right now: → Search and browse every active market instantly with no wallet needed → Check live order books, bid-ask spreads, midpoints, and price history across any time interval → Place limit orders and market orders directly from the command line with a single command → Cancel individual orders, batch orders, or your entire open position in one shot → Check your portfolio value, open positions, closed positions, and full trade history for any wallet address → Pull the monthly and weekly PnL leaderboard with one command → Pipe any output to JSON for scripts and agents with the -o json flag → Split USDC into YES/NO conditional tokens on-chain and redeem winning positions after resolution → Bridge assets in from other chains and check deposit status directly from the CLI → Run an interactive shell with command history for faster research sessions Every read command works with zero wallet setup, so you can start researching and scripting against live market data before you connect a single key. MIT License. 100% Open Source.
- 03
@avrldotdev ·
Step-1: Learn Rust Step-2: Understand ownership, borrowing & lifetimes Step-3: Master memory safety, zero-cost abstractions & type system Step-4: Build a CLI tool using Cargo Step-5: Write a multithreaded server using async Rust with Tokio Step-6: Read the Rust standard library source. question everything Step-7: Build a production-grade backend (REST/gRPC, DB, caching, msging) Step-8: Make it fast & safe (profiling & benchmarking) Step-9: Eliminate bottlenecks with safety Step-10: Ship it
- 04
@techNmak ·
Someone finally built a production-grade Agent OS in pure Rust. OpenFang isn't a Python wrapper or a generic multi-agent orchestrator. Here are the specs: → 137,728 lines of code. → 14 crates. → 1,767+ passing tests. → Zero clippy warnings. Because it's Rust, the performance metrics are insane. Cold starts happen in under 200ms. It uses just 40 MB of idle memory. It includes a SQLite memory backend with vector embeddings and canonical sessions. For me, this is what battle-tested infrastructure actually looks like. GitHub Repo : https://t.co/zX6bTc4vqp
- 05
@_vmlops ·
Microsoft dropped 7 free Rust books on GitHub beginner → expert....all in one repo → Rust for Python/C++/C# devs → Async Rust (Tokio, streams, cancellation) → Rust Patterns (Pin, allocators, lock-free) → Type-Driven Correctness → Rust Engineering Practices (CI/CD, cross-compilation, Miri) https://t.co/0vVmVM9z5M each book has 15-16 chapters, playgrounds, diagrams, and exercises
- 06
@doodlestein ·
I want to crowdsource a list of the very best exemplars of modern, high-performance coding. That is, libraries and projects that are much faster than they have any right to be; that are so much faster than other projects that it leaves you wondering what kind of black magic was used. Ideally, these should be implemented in "next-gen" languages like Rust and Zig, but don't have to be. They should also ideally reflect a deep understanding of modern hardware and what's possible now: massively multi-core processors like the 64-core Threadrippers, what you can do differently if you only target the fastest M.2 NVMe SSDs, what you can do with a giant pile of RAM (say, 256gb+ or 512gb) that would be impossible otherwise, etc. I'll give you one to start: https://t.co/kcKUqsB06i by @neogoose_btw You can get crazy results by just telling Opus 4.6 or GPT 5.4 to clone that to tmp and study it and look for ideas for improving search in your own project. I just did that for my FrankenSearch library which I use in cass, xf, and mcp_agent_mail_rust, and it learned a bunch of clever optimizations it probably wouldn't have thought of on its own. Even though fff is written in Zig and my stuff is all in Rust, it doesn't matter. The models can just instantly understand these things at a higher level of abstraction. So let me know your top choice for various categories.
- 07
- 08
- 09
@GithubProjects ·
Practice Rust with exercises designed to bridge the gap between tutorials and real-world projects. - Three parts per chapter: examples, exercises, and practices - Covers async/await, threads, sync primitives, and standard libraries - Every exercise has a solution; difficulty ranges from easy to super hard - Read, edit, and run all exercises online
- 10
- 11
- 12
- 13
@TrisH0x2A ·
c is still the lowest common denominator for cross-platform portability but these languages are solving its pain points: zig: simpler, explicit, no hidden control flow. if something happens, you wrote it. rust: memory safety without garbage collection. the compiler won't let you shoot yourself in the foot. go: simplicity with built-in concurrency. goroutines just work. each took a different approach to the same problem: making systems programming less painful while keeping performance
- 14
@devXritesh ·
Rust Roadmap for Backend Engineers, Who Want to Ship Fast: 1. Master the Basics : Ownership, borrowing, lifetimes, mutability & Cargo 2. Understand Rust’s Real Power : Structs, Enums, Traits, Generics & Pattern Matching 3. Error Handling Done Right : Result, ? operator, thiserror & anyhow 4. Modules, Crates & Project Structure : Clean architecture from day one 5. Async Rust : tokio, async/await and why it’s the future 6. Build CLI Tools : Use clap, make something actually useful 7. Work with Data : Serde, JSON, YAML, files & HTTP clients 8. Build REST APIs : Axum or Actix-Web + proper middleware & validation 9. Advanced Concurrency : Channels, tokio tasks, parallelism & rate limiting 10. Database Layer : SQLx (async) + PostgreSQL + connection pooling 11. Testing & Quality : Unit tests, integration tests, benchmarks & property-based testing 12. Production Ready : Docker, tracing, logging, graceful shutdown, observability & config Bonus Steps: - Read source code of popular crates (tokio, axum, sqlx) - Build 3 real projects (Auth service, Background worker, API scraper) Stop just “learning Rust” Follow this → become → production dangerous Save it. Follow it. Ship it. Who’s starting this Rust journey in 2026?
- 15
@TheAIWorld22 ·
MICROSOFT JUST OPEN-SOURCED 7 COMPLETE RUST TRAINING BOOKS. FOR FREE coming from python? there's a book for that coming from c++? there's a book for that coming from c#? there's a book for that async rust, advanced patterns, type-driven correctness, engineering practices all covered, all free, all in one repo beginner to expert...15-16 chapters each... mermaid diagrams, interactive playgrounds, exercises, and full-text search this is the rust curriculum that was scattered across blogs, talks, and youtube videos finally organized into one place by microsoft. no excuses left for not learning rust. https://t.co/H4Ys8so0Ql
- 16
- 17
@debasishg ·
A Rust port of porcupine (https://t.co/5Hwgq7Hehd), the fast linearizability checker for concurrent systems. link: https://t.co/wNG3caqCnI Some architectural features of the Rust implementation - 1. Go lineage, Rust performance. The core algorithm - DFS with backtracking, an index-based doubly-linked list, and a bitset-keyed cache - You get Go's proven correctness with Rust's ownership model and zero-cost parallelism via Rayon. 2. Two history representations. Accepts either `Operation`-based histories (call + return timestamps) or raw `Event` streams (interleaved call/return pairs), matching both entry points of the Go API. Histories are optionally split into independent partitions and checked concurrently, one Rayon task per partition. 3. Formal specification as ground truth. The implementation is governed by a Quint model (`tla/Porcupine.qnt`) that encodes seven named invariants - well-formedness, real-time order, minimal-call frontier, soundness, completeness, P-compositionality, and cache soundness. Every invariant is enforced at runtime via `debug_assert!` macros keyed to `INV-*` IDs in `docs/spec.md`, keeping spec and code in lockstep. 4. Exhaustive test suite. 60 unit tests cover the full call graph from entry-sorting and linked-list lift/unlift through cache pruning, timeout semantics, and `CheckResult` priority. Integration tests replay 102 Jepsen traces (etcd, KV store, set model, register) against the Go reference outputs. Property-based tests (proptest) verify compositionality, cache soundness, and sequential linearizability across randomly generated histories. 5. Bounded search with clean timeout API. Both `check_operations` and `check_events` accept an `Option<Duration>` timeout. A cancellable timer thread (backed by a `Condvar`) is woken immediately when the DFS finishes, so threads do not linger for the full deadline. The result is always one of three values: `Ok`, `Illegal`, or `Unknown` - with `Illegal` taking priority even when the clock runs out.
- 18
- 19
- 20
@GithubProjects ·
GPU programming in Rust has always meant one of two things: a DSL that looks like Rust but isn't, or unsafe FFI bindings to C++ CUDA code. cuda-oxide is NVIDIA's answer: a custom rustc codegen backend that compiles standard Rust directly to PTX. Write a kernel the way you'd write any Rust function. Ownership, traits, generics. The compiler handles the rest.
- 21
- 22
@DivyanshT91162 ·
Someone just rebuilt PostgreSQL from the ground up... in Rust. And it already passes 100% of PostgreSQL 18.3's official regression tests. It's called pgrust. Instead of patching a 40-year-old codebase, the team reimplemented PostgreSQL while keeping compatibility with the original. Here's what stands out: → 46,000+ official regression queries passed → 50% faster transaction workloads → ~300× faster analytical workloads → Thread-per-connection architecture → Disk-compatible with PostgreSQL 18.3 → Runs in the browser with WebAssembly → 100% open source This could become one of the most exciting database infrastructure projects of 2026. 100% Open source. Bookmark this if you work with PostgreSQL, Rust, or databases. Repo👇
- 23
- 24
- 25
- 26
- 27
- 28
- 29
@Insharamin ·
Day: 9-10 of learning Rust 🦀 Covered Structs end to end. <impl> is where you attach behaviour to a struct. Logic lives where the data lives. #[derive(Debug)] lets you print the struct directly for inspection. Ownership ties it together - the struct owns its fields, data lives as long as the struct does.
- 30
- 31
- 32
- 33
- 34
@panditdhamdhere ·
Saturday is open source vibe coding Rust day! 🦀 Building - TerminalOS The AI-native terminal for developers. It is a production-grade, cross-platform terminal application built in Rust. It combines a modern terminal emulator, AI assistant, coding agent, Git assistant, workspace manager, and developer dashboard into a single fast, keyboard-driven TUI. https://t.co/a08teirZAq
- 35
@milan_milanovic ·
𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁 𝘄𝗮𝗻𝘁𝘀 𝘁𝗼 𝗺𝗼𝘃𝗲 𝗮𝗹𝗹 𝗖 𝗮𝗻𝗱 𝗖++ 𝗰𝗼𝗱𝗲 𝘁𝗼 𝗥𝘂𝘀𝘁 𝗯𝘆 𝟮𝟬𝟯𝟬 𝘄𝗶𝘁𝗵 𝗔𝗜? A LinkedIn post about Microsoft “eliminating every line of C and C++ by 2030 with AI” sparked a huge wave of speculation. Some took it as a roadmap to rewrite Windows or all core products using AI and Rust. Here’s the real context: Microsoft Distinguished Engineer Galen Hunt’s original post outlined his team’s research, not a corporate mandate or a Windows rewrite. Their mission is to develop tooling and infrastructure to help migrate large existing codebases from one language to another, using a mix of algorithms and AI assistance to scale analysis and transformations. The catchphrase “1 engineer, 1 month, 1 million lines of code” is a North Star metric for tooling capability, not a promise that AI will magically flip Windows into Rust overnight. In a follow-up update, Hunt clarified this isn’t a product strategy or a directive to rip out C/C++ from Windows 11+ or other flagship codebases: this work is experimental research, and the job post was aimed at finding engineers to help build the next phase of this technology. The distinction matters. What’s happening now is: • A research initiative to explore AI-assisted code migration tooling at a massive scale. • Rust is used as a demonstration target because of its memory-safety benefits, not because it’s a corporate edict that all code must end up there. • There is no official plan to rewrite Windows in Rust with AI For engineers and teams, this reflects a broader shift in how tooling could evolve: instead of rewriting by hand over the years, we might see workflows in which AI backends and static analysis do the heavy lifting while humans validate and refine changes. That’s a big difference from “AI replaces developers overnight.”
- 36
@Insharamin ·
Day: 5 of learning Rust 🦀 Covered a lot of ground today. Defining & instantiating structs, field init shorthand, tuple structs, unit-like structs, and ownership of struct data. Ownership inside structs is where it gets interesting. If a struct owns its data, that data lives as long as the struct does. If you want to store references instead, Rust will ask you about lifetimes.
- 37
- 38
- 39
@devabram ·
I was told typeclasses are similiar to traits, but I am still struggling with rust traits, while haskell typeclasses are intuitive to me. The traits mental model is just overloaded with stuff regarding ownership, dispatch, types, and limitations that aren't obvious. It's just a weird place for me to think about this stuff.
- 40
@RoundtableSpace ·
Live-ASCII renders Live2D models directly in your terminal with face tracking support. Upcoming Features: * Separate live2d framework to a crate. * Support processes interaction. * Enable multiply expressions. Built in Rust. One command to run. Open source.
Watch video
- 41
- 42
- 43
- 44
- 45
@ibuildthecloud ·
So I'm writing a coding agent based on WANIX from from @progrium I have to say this is the first time I've been happy the JavaScript echo system has been rewritten in rust. I think I can get a pretty awesome TypeScript coding agent to run fully in the browser, yet still in a fairly native way. Pretty cool, fully develop a web page with an agent, get live preview, and then you theoretically could publish to the web (it's just a collection of files in opfs)
- 46
@JeremyCMorgan ·
A new Rust VMM forks running VMs in under 20ms via copy-on-write, making hardware isolation denser than containers in multi-tenant scenarios. If you're building agent sandboxes or untrusted code execution environments, this is the first serious challenge to the "containers are cheaper" assumption in years. https://t.co/Ug263m8M1O
- 47
- 48
- 49
@ThePracticalDev ·
An MIT-licensed Rust vectorizer with reproducible benchmarks kept getting bounced from the communities most likely to contribute to it, because AI helped build it. This dev argues the filter should be maintained engineering versus generated slop. { author: Christoffer Madsen } https://t.co/zCpSkNRcKi
- 50
Best Tweets by Topic