Performance and systems infrastructure
Benchmarks and profiling alongside Rust implementations of proxies, databases, operating systems, virtual machines, and game servers.
36%
Best tweets about Rust
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.
Original Xholic analysis
In this sample, Rust discussion emphasizes systems projects, crates, and practical learning. Project announcements account for 74% of tweets. Posts describe benefits from ownership and concurrency alongside self-referential-data limitations and workload-specific performance tradeoffs.
70% of posts
All-time engagement
74% of posts
Published in 90 days
Conversation map
Benchmarks and profiling alongside Rust implementations of proxies, databases, operating systems, virtual machines, and game servers.
36%
Open-source libraries, Cargo utilities, security analysis, framework integrations, and Rust working with Python, PHP, or PostgreSQL.
32%
Memory-safety motivations, C/C++ migration research, AI-assisted coding, and debate over when Rust’s guarantees justify its complexity.
28%
Rust inference engines, agents, world-model libraries, computer-vision applications, document parsing for AI, and GPU kernels.
22%
Tokio and event-driven I/O, race-free parallelism, linearizability checking, and formal verification.
22%
Books, exercises, backend roadmaps, and lessons on testing, deployment, and maintainable Rust projects.
20%
Borrowing, lifetimes, traits, type-driven correctness, self-referential data, and borrow-checker developments.
20%
Tauri desktop alternatives, terminal libraries and TUIs, creative software, and embedded projects.
18%
Tone and stance
Performance benchmark
Posts with media make up 56% of this collection. Their median all-time score is 9.07, compared with 3.40 for text-only posts.
Format mix
Consensus and debate
Shared view
The Ladybird developer says confidence about races makes parallel JS parsing easier. A separate post describes a Rust linearizability-checker port with a formal specification and tests. Both discuss correctness in concrete engineering work.
Shared view
Posts highlight a libghostty wrapper, a PostgreSQL extension built with pgrx, and a tutorial calling Rust from Python. These examples show Rust being used alongside existing ecosystems.
Open debate
An adoption critique argues that side projects need not start with production-grade guarantees, while another developer calls idiomatic self-referential structs a major limitation. A separate post values Rust’s race-related confidence in browser work.
Open debate
A Pake post contrasts packaged desktop-app sizes, while an Enigma benchmark post reports a performance gap when Rust bounds checking remains enabled. These concern different workloads and measures, not a general verdict on Rust performance.
What performs
Deterministic analytics give async, concurrency, and correctness a median all-time score of 22.147, versus 6.11 overall. The Ladybird parallel-parsing post and linearizability-checker port illustrate the topic.
The Pake post has an all-time score of 2589.37, or 423.79 times the supplied median. Across the sample, media posts have a median score of 9.07 versus 3.4 for text posts. These figures do not establish why either performed better.
Statistical standouts
Creator landscape
The five most represented creators account for 20% of the selected posts.
1. Vaishnavi
@_vmlops
2 posts
2. flux
@0xfluxsec
2 posts
3. divyansh tiwari
@DivyanshT91162
2 posts
4. Francesco Ciulla
@FrancescoCiull4
2 posts
5. GitHub Projects Community
@GithubProjects
2 posts
6. Can Vardar
@icanvardar
2 posts
Analytics list 39 creators across 50 tweets. Among repeat posters, _vmlops shares Rust books and Pingora, while GithubProjects shares exercises and a GPU-codegen project; each has two tweets in the sample.
Insharamin documents ownership while learning structs; jyobo10 shares a minimal gRPC example and a first PostgreSQL extension. These posts provide concrete examples of learning and experimenting with Rust.
Since the previous snapshot
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
Ranked 01–50
@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)

@mitchellh ·
libghostty for Rust! Some Ghostty maintainers came together and made a really high quality Rust crate in front of libghostty-vt. The repo includes a full port of Ghostling (full terminal in a single Rust file!). The API is beautiful. https://t.co/6sdTkjG24V

@_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

@deedydas ·
I just "vibecoded" a Chess master (~2250 ELO) from scratch that runs locally on a Mac in Rust. I used to play chess semi-competitively, and I'm flabbergasted that you can just speak a 98% percentile chess engine into existence.
@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

@0xfluxsec ·
New post! Crimes against NTDLL - Implementing Early Cascade Injection in Rust: https://t.co/KXnEnEY0j2 Original research by @OutflankNL


@awesomekling ·
Nice thing about using Rust in @ladybirdbrowser: it becomes significantly easier to parallelize things when you have confidence that they're not racy! Here's what it looks like when we distribute JS parsing to a thread pool instead of parsing synchronously on the main thread:

@AbdelStark ·
I wanted to understand world models from first principles, so I built JEPA primitives in Rust with Burn. LLMs are a thing of the past already, the future is World Models ? I don't know yet. But I like learning by building. Lately I’ve been getting increasingly interested in world models (yes mostly beause of all the noise on @amilabs), so instead of only reading papers and hot takes, I built jepa-rs: a Joint Embedding Predictive Architecture library for World Models, written in Rust. It provides modular, backend-agnostic building blocks for I-JEPA (images), V-JEPA (video), and hierarchical world models, built on top of the burn deep learning framework. It includes a CLI and interactive TUI dashboard, safetensors checkpoint loading, ONNX metadata inspection, and a pretrained model registry for Meta Research models. Repo: https://t.co/GCID2Kj3YU For people not familiar with World Models: An LLM predicts the next token in text. A world model tries to predict the latent state and dynamics of an environment (similar to an animal or us as babies). Text is one domain. The world is another. A world model learns abstract representations that capture what matters and ignore what doesn't. A world model doesn't need to predict every leaf on a tree. It needs to understand that trees sway in wind. This is what AMI Labs mean when they say: "Real intelligence does not start in language. It starts in the world." World models are not a replacement for what LLMs are good at. For text, coding and many other things LLMs are amazing and won't be replaced by World Models. But there are many areas where World Models can bring interesting applications, robotics being obviously one of them. I have a strong intuition there may be an interesting bridge between world models, safety, and verifiable computation. One new area where I can explore the use of STARK technology ;)
@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
@panditdhamdhere ·
Just built NetScope - A real-time network connection visualizer built with Rust 🦀and Tauri. It discovers every TCP/UDP connection on your machine, maps them to processes, resolves remote hosts, and renders an interactive force-directed graph. Tech Stack Backend - Rust, tokio, sysinfo, netstat2, pnet Desktop - Tauri v2 Frontend - React, TypeScript, React Flow API - WebSocket (Axum) + Tauri commands Repo link - below
@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?

@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.
@ryangjchandler ·
Always nice to see people still exploring the world of Rust + PHP working together. This new language server running on top of Mago looks very promising. https://t.co/qxpOpCBAch
@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.

@quant_arb ·
Rust is very good for use with LLMs. Checks a lot of errors naturally in the compiler and very token efficient as a language. An effective choice if you need to vibe code something which is performant.
@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👇

@orhundev ·
New blog post! 📢🎉 "Building a guitar trainer with embedded Rust" 🦀🎸 The story of me trying to learn guitar... and ending up building a DIY kit for it 🐁 🔗 Read here: https://t.co/0LFvTDMNZZ #rustlang #embedded #esp32 #ratatui #tui #devtools #opensource #blog

@SahilPanhotra ·
Firecrawl just open-sourced a tiny tool every AI developer should know 😳 AnyDoc turns: PDFs DOCX PPTX XLSX CSV EPUB RTF and more into clean, LLM-ready Markdown. no API. no GPU. no LLM. just Rust running locally and they're reporting ~4.7ms median parsing time. this is exactly the kind of boring infrastructure AI apps need
@larry0x ·
My favorite piece of code in @dango's upcoming perp DEX is how we incorporate dimensional analysis in the Rust type system. A challenge in programming complex financial apps is sometimes you lose track of what a number mean. Does this "123.456" mean 123.456 USD or 123.456 USDC (too very different things)? If it's USDC, is it the human unit or the base unit (1e-6 USDC)? In this code snippet, we encapsulate the three dimensions: asset quantity, dollar value, and time duration, in the Number type itself as a zero-cost abstraction. The Rust compiler ensure at compile time that a function always takes in and outputs exactly the right thing it's intended to.

@orhundev ·
Finally I can **actually** know why a thread is slow 👀 📈tsastat — A high-resolution Linux thread profiling TUI ⚡ Talks directly to the kernel via Generic Netlink 💯 Extracts microsecond-precision Delay Accounting metrics 🦀 Written in Rust & built with @ratatui_rs ⭐ GitHub: https://t.co/oV0SP2z4fW #rustlang #ratatui #tui #linux #performance #profiling #systems #kernel #terminal
@neogoose_btw ·
Not being able to express self referential structs in rust is actually one of the biggest limitation of rust. E.g. I want to pull out a buffer of strings into one continuous deduped arena and store it next to list of items referencing them so I can drop them together which is safe - but I can't express this in "idiomatic" rust like at all
@rodarmor ·
I wrote a small program which makes coding agents dramatically better at finding Rust documentation. https://t.co/DrHDEpDx5j It's called `cargo-path`, and it takes a dependency name and prints the path to the local copy of the source code. 🧵
@_vmlops ·
CLOUDFLARE BUILT THEIR OWN NGINX IN RUST AND OPEN-SOURCED IT pingora is cloudflare's internal proxy framework, now available for anyone to use it handles 40M+ internet requests per second in production here's what makes it different: ▫️ written in async rust memory safe, no c/c++ footguns ▫️ full HTTP/1 and HTTP/2 end-to-end proxying ▫️ tls via openssl, boringssl, rustls, or s2n-tls ▫️ grpc + websocket proxying built in ▫️ graceful reload without dropping connections ▫️ pluggable load balancing + failover logic ▫️ prometheus + observability integrations out of the box the modular crate structure means you can pull in only what you need: pingora-proxy → http proxy logic pingora-cache → caching layer pingora-load-balancing → lb algorithms tinyufo → the caching algorithm powering it all nginx has been the default for years pingora is what happens when you outgrow it at cloudflare scale 26.8k stars on github https://t.co/sXmfuqJ7eW
@jyobo10 ·
Wrote my first postgres extension in Rust using pgrx. The setup was simpler than I thought. I already have some ideas on more complex pg extensions I can create that'll be more helpful


@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.

@sigp_io ·
Rust's security reputation comes from its tooling, not just the language itself. Here's a rundown of the static analysis tools we use to catch vulnerabilities before they reach production 👇

@ThePracticalDev ·
Can you build a performant, IO-heavy app without async Rust? This dev explores epoll directly, then rewrites the result using Mio — achieving single-threaded, non-blocking networking with time-based triggers and no busy waiting. { author: @Szymongib } https://t.co/PiBQMHu0ej
@RealTjDunham ·
hey friends, been working on something. built an inference engine in Rust that runs any open source model across multiple devices at once. macbook holds some layers, a gpu holds others, a phone picks up the rest. all computing in parallel, output identical to running the full model on one machine. you might have seen mesh-llm from Dorsey's team doing something similar. their approach gives each node a subset of experts and skips the missing ones. their own testing showed 4-node splits "produced garbage." they trade model quality for speed. mine keeps every parameter, every expert, every time. the engine is pure integer math so every device produces the same output bit for bit. i believe this can empower our community and anyone to be able to run and own sota open source models without the api costs
@mitsuhiko ·
Do people still care about Open Source libraries? I finally took the time to make a major update of my "similar" Rust diffing library. Fixed bugs, added histogram/hunt diffs, semantic fixes for inline diffs, no_std support and perf fixes.
@0xfluxsec ·
Currently building the Redox-OS from source, the Rust based Operating System. Lets do some malware research on it 👿 Redox MITRE page when??! I am also hoping to start contributing soon, there is a issue open to implement ASLR and a few other things which could be fun!


@mrdoornbos ·
Update to my Index of Coincidence "Modern Computer" testing with some other languages. Brute-forced Enigma rotor settings in C, Rust, Swift, and Metal on an M4. Single-threaded, Rust and Swift both land within 6-9% of C when you disable bounds checking. Leave the safety on, and there's a performance gap. Turns out billions of array lookups add up. The Metal GPU completed the entire 5.9 million-candidate search in 27 milliseconds. 67x faster than single-threaded C and 2.5 days faster than my beloved Commodore 64.


@smratitiwa86867 ·
Adobe spent years locking photographers into subscriptions. Then an 18-year-old from Switzerland built a free alternative in Rust. It’s called RapidRAW. A lightweight RAW editor that runs on Windows, Mac, Linux, and even Android. No Adobe account. No cloud sync. No monthly bill. No “AI features” nobody asked for. Lightroom vs RapidRAW: • $143.88/year → Free forever • Multi-GB install → Under 20MB • Forced updates → Update when you want • Adobe cloud storage → Your files stay on your drive • Windows + Mac → Windows, Mac, Linux, Android And it’s not some toy project either. RapidRAW already supports: → Non-destructive RAW editing → GPU-accelerated performance → Real-time sliders on low-end laptops → Masks, curves, presets, EXIF editing → Noise reduction with separate luma/color controls → Custom shortcuts + touchscreen support Built with Rust + Tauri + WGPU. That’s why it feels ridiculously fast. The craziest part? Timon Käch started it as a personal challenge to learn Rust and shader programming. No startup. No investors. No giant team. Just one teenager building what photographers actually wanted. 6,800+ GitHub stars in less than a year. And unlike most “free” software: • No Pro plan • No ads • No watermark • No telemetry drama It’s open-source under AGPL-3.0. This is exactly the kind of project that reminds you how powerful indie developers have become.

@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.”

@RoundtableSpace ·
Firecrawl just shipped a Rust-based PDF parser & it's not close. - 5x faster PDF to markdown conversion - Extracts full tables and preserves formulas - Zero config required PDF parsing has been a pain point for AI pipelines. This might actually fix it.
@DivyanshT91162 ·
Someone rebuilt a Minecraft server in Rust... And it's insanely fast. Meet Pumpkin: • Multi-threaded for maximum performance • Vanilla-compatible gameplay • Java Edition support (Bedrock WIP) • Secure by design • Highly configurable • Plugin-ready architecture It already supports: → Chunk loading & generation → World saving & lighting → Redstone & liquid physics → Inventory, combat & experience → RCON, permissions & commands → Bungeecord & Velocity support Still under heavy development, but it's already one of the most ambitious Minecraft server projects. • 100% Open Source • GPL Licensed Bookmark this for later. Repo👇


@chaaai ·
Claude Code skill to formally verify your Rust code > npx skills add workersio/spec A good way to check for unexpected behavior in the critical parts of your code is by model-checking it. Kani helps you check the safety and correctness properties of your Rust code. A few devs wrote their very first proof harness using this skill and are now unstoppable

@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.

@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.
@panditdhamdhere ·
Everyone is obsessed with Python. Use Rust for AI agents if you need ✅ High-concurrency tool execution. ✅ Long-running, reliable agent processes. ✅ Edge / WASM deployment. ✅ Single-binary ops simplicity. ✅ Memory-safe shared state. Rust for production. 🦀
@jyobo10 ·
Building a Rust experiments repo so I can code out concepts quickly and reference them later. I added an example of a minimal gRPC server with tonic/prost today. https://t.co/tEGVu7FHsf
@subinium ·
⚡SuperLightTUI Built a Rust TUI framework that works like an actual UI framework. Flexbox layout every frame. Widgets own their interaction. Styling chains like Tailwind. Pure Rust. Link in thread👇

@FrancescoCiull4 ·
Have you tried Tailwind CSS in a Rust project? I tested Topcoat’s integration, including the Cargo build workflow, hot reload, assets, icons and fonts. I’m curious how it compares with your experience using Dioxus, Tauri or other Rust frameworks: https://t.co/r1P6Fmi2wS
@AprilNEA ·
Built my first deep learning project entirely in Rust — a real-time exit intent detection system. It watches a camera feed, runs YOLO11 + ByteTrack + ArcFace through ONNX Runtime (CoreML on Apple Silicon), figures out when someone is walking toward a door, and auto-unlocks it via UniFi Access API. No Python in the inference loop. No dependency hell. No virtualenv juggling. Just cargo build and it works. ~3k lines of Rust, runs 24/7 on a Mac mini. Honestly one of the smoothest dev experiences I've had with ML. https://t.co/2Di7yhFDuV
@icanvardar ·
rust is incredible for the problems it was designed to solve but it also made a lot of developers believe every side project needs production grade guarantees before it even has users
@hackernoon ·
How I forced an old 2013 laptop to render 13,000 active 3D entities at 60 FPS using Rust and OpenGL. No LOD, no culling—just pure data-oriented architecture. #gamedev #rust...Show more

@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
@icanvardar ·
the peak rust hype era was weird js developers were getting bullied just for writing javascript, as if every crud app suddenly needed to be rewritten in rust
@FrancescoCiull4 ·
🔴 LIVE NOW! I’m testing Rust’s new Polonius Alpha borrow checker. Same safe code: ❌ Fails on stable ✅ Compiles on nightly https://t.co/3Lhio44IQI
@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
@TDataScience ·
Python or Rust? For @taupirho, the answer is "why not both!" His latest tutorial walks us through the process of calling Rust from Python, combining the languages' respective strengths into one workflow. https://t.co/HoulNETF6H
Best Rust tweets
Xholic studies what works in your niche, drafts posts in your voice and schedules them for the hours your audience is online.
$0 today · Cancel anytime
Browse all tweet collectionsKeep exploring