Production applications and tooling
Rust in production services, web backends, CLIs, databases, terminals, desktop apps, and developer tooling.
38%
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
- 43
- Updated
Original Xholic analysis
What 50 top Rust posts reveal
Rust conversation was predominantly supportive (62%) and centered on production applications and tooling (38%), performance and systems engineering (34%), language fundamentals and safety (26%), and learning resources (16%). The most visible engagement outliers were concrete project stories and practical learning guidance, while cautionary posts questioned performance-first rewrite narratives, broad migration claims, and the cost of Rust’s rigor.
- Dominant tone
- Positive
- Median score
- 6.58
- Leading format
- Other
- Recent posts
- 40%
64% of posts
All-time engagement
100% of posts
Published in 90 days
Conversation map
The themes creators return to
Performance and systems engineering
Performance-focused Rust rewrites, low memory use, fast startup, benchmarking, profiling, and systems efficiency.
34%
Language fundamentals and safety
Rust ownership, borrowing, lifetimes, traits, type-system concepts, and memory-safety mental models.
26%
Open-source ecosystem and projects},{
Open-source Rust projects, project launches, GitHub traction, licenses, and building in public.
24%
Security and reliability
Security engineering through memory safety, static analysis, vulnerability reduction, malware research, and isolation.
22%
AI and agent infrastructure
AI agents, local AI infrastructure, agent operating systems, automation, sandboxes, and AI-assisted development in Rust.
20%
Concurrency and async systems
Async Rust, threading, synchronization, lock-free designs, parallelism, and high-concurrency networking.
20%
Learning resources and practice
Learning paths, books, exercises, tutorials, beginner progress, and practical Rust education.
16%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 23
- Median reposts
- 2
- Median replies
- 2
- Median views
- 1.7K
Posts with media make up 60% of this collection. Their median all-time score is 8.38, compared with 3.18 for text-only posts.
Format mix
- Other 100% · score 6.58
Consensus and debate
Where creators agree, and where they do not
Shared view
Rust is framed through practical applications and tooling
The conversation frequently focuses on applied Rust: desktop packaging, an open-source CLI, a learning-to-production roadmap, and a TypeScript framework powered by Rust.
Shared view
Safety is presented as an engineering capability
Posts associate Rust with memory safety without garbage collection, ownership-based concurrency confidence, static-analysis tooling, and parallel checking. These are presented as engineering advantages rather than as guarantees for every use case.
Shared view
Learning content follows a build-oriented path
Learning material spans fundamentals and hands-on practice, including ownership and borrowing, async and synchronization, exercises, books, Cargo, profiling, and backend-building guidance.
Open debate
Performance enthusiasm meets scope caution
Some posts argue against treating Rust primarily as a performance rewrite target, criticize aspects of its language-design trade-offs, or warn against applying production-grade guarantees to every side project.
Open debate
Migration narratives require careful qualification
One post makes a broad claim that Microsoft is rewriting Windows in Rust. Another says the underlying work is experimental AI-assisted migration-tooling research, not an official Windows rewrite plan.
Open debate
Rust’s rigor can be a learning and tooling hurdle
Learners describe ownership, the compiler, and traits as difficult mental models. A separate post also reports that LLMs struggle more with Rust codebases; this is an individual observation, not a benchmark result.
What performs
Patterns behind standout posts
Concrete projects and practical guidance led the outliers
The five supplied engagement outliers are the Pake packaging story (3,226.4 all-time score), Polymarket’s Rust CLI (1,387.51), a Rust learning roadmap (461.1), OpenFang (272.99), and an agent-OS open-source story (222.4). Pake is the top outlier.
Systems and concurrency themes had the strongest theme medians
Concurrency and async systems had the highest theme median all-time score at 15.32; performance and systems engineering followed at 14.415. The cited posts discuss packaging footprint, startup and memory claims, parallel parsing, and database-performance claims.
Media was associated with higher median scores
Posts with media had a median all-time score of 8.38, versus 3.18 for text posts. All 50 items were classified as OTHER format, so the supplied format data cannot identify a better-performing post structure.
Statistical standouts
- View standout post 1 Score 3226.4 · 490.33× median
- View standout post 2 Score 1387.5 · 210.87× median
- View standout post 3 Score 461.1 · 70.08× median
- View standout post 4 Score 273.0 · 41.49× median
- View standout post 5 Score 222.4 · 33.8× 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. GitHub Projects Community
@GithubProjects
2 posts
-
4. Insha
@Insharamin
2 posts
-
5. Joe Sluis
@jyobo10
2 posts
-
6. Pandit | Ξ🦇🔊
@panditdhamdhere
2 posts
Recurring creators contribute varied Rust material
Among recurring creators, the cited posts cover Rust books and exercises, a Linux 0.11 rewrite, security research, Redox OS exploration, and practice material. The available creator data shows no single recurring creator with more than two tweets.
Practitioners share incremental building lessons
Individual practitioners document early ownership learning, compiler friction, a first Postgres extension using pgrx, and a Rust experiments repository containing a minimal gRPC example.
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 43 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
@Akashi203 ·
we built an agent OS in rust 10,000 github stars in 5 days here's what nobody tells you about open source we spent 6 pivots trying to sell GPU dev tools, sending cold emails, making pitch decks, hearing "we'll get back to you" over and over then we just built an open sourced os for agents and in 5 days more people found us than in an entire year of selling the lesson is stupidly simple, stop hoarding your best work because the internet rewards builders who ship in public open source is the most underrated growth strategy in tech https://t.co/DZjYu8yd0B
- 06
@_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
- 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
@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.
- 15
@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.
- 16
- 17
@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👇
- 18
- 19
- 20
- 21
- 22
- 23
- 24
@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.
- 25
- 26
- 27
- 28
@ttunguz ·
I needed AI-powered automation that could actually keep up with my day. Existing tools were too slow, too error-prone. So I rewrote everything in Rust — 45+ APIs that Claude Code uses to run my VC workflow end-to-end. I'm presenting the architecture & live demo at @SFAIEngineers on April 1: https://t.co/FKzNJy83gC
- 29
- 30
@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
- 31
@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.”
- 32
@subinium ·
1/3 Introducing https://t.co/Dos0NpoX95 - a visual editor for Rust terminal UIs. Drag widgets onto a canvas, set properties in an inspector, export working Rust code. No coordinate math, no recompile loops.
Watch video
- 33
@Insharamin ·
Day 2–3 of learning Rust 🦀 Missed yesterday. Coupling both days into one update. Spent the time on fundamentals - Data types, functions, control flow. Ownership and borrowing are conceptually clean but the moment you sit down to write code, the compiler humbles you fast. I'm starting to respect it.
- 34
- 35
@DAIEvolutionHub ·
Screenpipe is climbing GitHub's trending charts for Rust, and it's easy to see why. It continuously captures activity on your computer, turning it into searchable long-term memory for AI. Everything runs locally, so your data stays on your device. Already crossed 20K+ GitHub stars. Repo: https://t.co/FDSNmns71D
- 36
- 37
- 38
@dev_ilyesbacha ·
Day 21 of Rust. No I didn't abandon Rust, I've just been busy with 5 other projects. Mostly double checking stuff up, learning a bit more about the locks, and seeing how I can do dynamic server registry. I don't want to do config based dynamic server registry because I think there is less to learn there compared to using axum. any suggestion about the dynamic server registry is welcome.
- 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
- 41
- 42
- 43
- 44
- 45
@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
- 46
@katibmoe ·
@posthog writes their core services in Rust. So do we. Next Thursday we're sharing a stage in NYC to get into why. At a billion requests an hour, Python falls over. Rust holds at a sub-100ms floor. We spent six months building the Rust core before a single action hit production. It now runs 400+ integrations, 70,000+ verified agentic actions, and hundreds of millions of transactions. What we'll cover with PostHog: - Where Rust earns its place in production - Why we moved from TypeScript to Rust - How much latency we pulled out, and what it cost to get there We'll close the night with live demos from the NYC Rust community. June 11, 6pm. Betaworks, NYC. Food, drinks, and merch are on us. If you write Rust, or just want to argue about it, come through! Link in the comments 👇
- 47
@shawnchauhan1 ·
Microsoft is rewriting Windows in Rust to eliminate 70% of its historic vulnerabilities. This is a confession: 40 years of "better developer training" didn't work. You can't train humans out of memory safety bugs when the language permits them by design. Discipline can't fix what syntax allows. The answer was always architectural, not educational.
- 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