Best of Rust — December 2025

1
Article
Rust·17w
What do people love about Rust?
Rust users consistently cite reliability, efficiency, low-level control, supportive tooling, and extensibility as key strengths. The language's real power comes from achieving all these attributes simultaneously, creating a trusted, versatile tool that empowers developers to tackle new domains and problems they couldn't approach before. However, balance is crucial: complex type systems, async Rust's steep learning curve, and crates.io's overwhelming choice can undermine supportiveness. The Rust team recommends enumerating design goals, doubling down on extensibility (especially for diagnostics and build integration), and helping users navigate the ecosystem.
133
10
2
Video
ForrestKnight·19w
Why Rust Changed the Way I Think About Programming
Learning Rust fundamentally changed how the author approaches programming in other languages. Rust's ownership model, borrow checker, and strict compiler forced explicit thinking about memory management, mutability, error handling, and concurrency. These lessons translated into writing more intentional code in Java and TypeScript—using immutability by default, treating the compiler as a collaborator, making error paths explicit, and thinking carefully about data ownership even with garbage collection. While Rust's strictness can be demanding, its principles help developers write safer, more maintainable code across any language.
110
7
3
Article
It's Foss·17w
Easier Than Nano! Fresh is a Fresh New Rust-based Terminal Editor for Linux
Fresh is a new Rust-based terminal text editor that uses familiar GUI-style keyboard shortcuts (Ctrl+S, Ctrl+F, Ctrl+Z) instead of modal editing or complex keybindings. It features full mouse support, a command palette, built-in file explorer, LSP integration, plugin support via TypeScript/Deno, and can handle files over 10 GB. The editor aims to lower the learning curve for beginners while providing modern features like split-pane layouts, embedded terminal, and markdown preview.
95
7
4
Article
Zed·18w
How We Rebuilt Settings in Zed — Zed's Blog
The Zed team rebuilt their settings editor from scratch, moving from a distributed, macro-based architecture to a centralized, strongly-typed model. The refactoring consolidated scattered settings definitions into UserSettings and ProjectSettings types, treating configuration files as the organizing principle rather than implementation details. They enhanced their GPUI framework with automated focus handling through tab groups and local state management similar to React's useState. The project revealed architectural weaknesses (including an auto-update bug) but resulted in a cleaner foundation for future features.
94
2
5
Video
YouTube·17w
Is Golang still a growing programming language?
Go remains a stable, growing language in 2024-2025, ranking 4th in JetBrains' promise index and 3rd in GitHub open-source growth. Primary use cases include cloud infrastructure, API/RPC services, and CLI tools. While it dropped from 7th to 11th in TIOBE rankings, GitHub activity shows consistent upward trends. Go developers earn competitive salaries ($76k-$500k), though job postings often emphasize infrastructure roles over explicit Go positions. The language excels at building AI infrastructure but lacks native ML capabilities. Adoption is steady rather than explosive, with professional developers favoring it more than learners.
80
6
6
Article
It's Foss·18w
The Tor Project is Now Rewritten in Rust Instead of C
Arti 1.8.0, the Rust rewrite of Tor, introduces circuit timeout improvements that replace predictable timing patterns with randomized intervals to reduce fingerprinting risks. The release includes an experimental command for migrating onion service client authorization keys from C-based Tor to Arti's keystore, plus enhancements to routing architecture and protocol implementation. The rewrite addresses memory safety vulnerabilities inherent in the original C codebase, including buffer overflows and use-after-free bugs.
70
3
7
Video
Let's Get Rusty·16w
I’m a Rust developer, here’s what I’d do if I had to start over
Three key strategies for learning Rust more effectively: focus on domain-specific knowledge rather than trying to master every feature, maintain consistent progress through community support and mentorship instead of repeatedly restarting, and learn with the goal of becoming job-market ready to ensure practical skill development. The approach emphasizes learning only the 20% of Rust needed for your specific use case, whether backend services, embedded systems, or blockchain development.
70
3
8
Article
Hacker News·19w
Why We Built Lightpanda in Zig - Blog
Lightpanda chose Zig over C++ and Rust to build their browser engine, prioritizing simplicity and explicit control. The team values Zig's straightforward syntax, compile-time metaprogramming, explicit allocator model for fine-grained memory management, and seamless C interoperability for integrating with V8. While Zig is pre-1.0 with a smaller ecosystem, its arena allocators enable efficient per-page memory handling, comptime features reduce boilerplate when bridging JavaScript, and fast compilation times maintain developer productivity. The decision reflects a pragmatic choice for a small team building performance-critical infrastructure without the complexity of C++ templates or Rust's borrow checker.
68
9
Article
Sutter's Mill·15w
Software taketh away faster than hardware giveth: Why C++ programmers keep growing fast despite competition, safety, and AI
C++ and Rust are the fastest-growing major programming languages from 2022 to 2025, driven by computing demand consistently outpacing hardware supply. Power and chips are the two biggest constraints on computing growth, making performance-per-watt efficiency critical. C++ continues evolving with C++26 adding significant security improvements including bounds-checking in the standard library, elimination of undefined behavior from uninitialized variables, and functional safety via contracts. Despite concerns about safety and AI replacing programmers, the global developer population grew 50% to 47 million, with C++ adding roughly as many developers in one year as Rust has total worldwide. AI serves as an accelerator tool rather than replacement, with major tech companies continuing to aggressively hire human programmers.
53
5
10
Article
InfoWorld·16w
Microsoft is not rewriting Windows in Rust
Microsoft Distinguished Engineer Galen Hunt clarified that his LinkedIn post about eliminating C and C++ code by 2030 was a personal research goal, not a corporate strategy. His team is developing AI-powered tools to automate code translation between languages at scale, aiming for "1 engineer, 1 month, 1 million lines of code." The research project uses Rust as a demonstration target but isn't specifically focused on rewriting Windows. While pressure exists to adopt memory-safe languages due to security vulnerabilities, research shows AI-generated code typically contains more issues than human-written code.
45
11
11
Video
Awesome·15w
One MILLION lines of code every month
Microsoft posted a job seeking an engineer to output 1 million lines of code monthly using AI to replace C/C++ with Rust by 2030. This represents a problematic industry trend of measuring software quality by lines of code rather than actual value. The expectation that one person could meaningfully review 65 lines per minute is unrealistic. Industry leaders are promoting AI-assisted junior developers over experienced seniors for cost savings, despite evidence that many companies laying off workers end up increasing expenses and rehiring later. The push treats software development as industrialized manufacturing rather than skilled problem-solving work.
44
4
12
Article
Steve Klabnik·16w
Thirteen years of Rust and the birth of Rue
Steve Klabnik reflects on 13 years of using Rust and announces Rue, a new programming language he's building as a hobby project. He discusses how AI tools like Claude have made solo language development more feasible without large teams or funding. The project is in early stages and intentionally kept as a personal endeavor rather than a community-driven effort.
44
3
13
Article
fasterthanli.me·17w
My gift to the rustdoc team
Arborium is a new open-source project that brings tree-sitter-based syntax highlighting to Rust documentation. It bundles 96 language grammars into Rust crates that compile to both native and WebAssembly targets. The project offers three integration approaches: a JavaScript/WASM script for immediate use on docs.rs, a rustdoc PR to add native highlighting support, and a post-processor that adds highlighting to existing HTML documentation with minimal size overhead. The solution addresses long-standing limitations in docs.rs by providing accurate, comprehensive syntax highlighting without requiring full documentation rebuilds.
43
1
14
Article
Vercel·18w
Rust runtime now in public beta for Vercel Functions
Vercel has launched public beta support for Rust runtime in Vercel Functions, powered by Fluid compute. The native runtime includes HTTP response streaming, Active CPU pricing, increased environment variable limits (64KB vs 6KB), and automatic integration with Vercel's logging and monitoring systems. Developers can get started using Cargo.toml configuration and the vercel_runtime crate, with starter templates available for basic and Axum-based deployments.
43
15
Video
Awesome·16w
The 2025 tech review
A comprehensive retrospective of 2025's major tech developments, covering AI investment trends and market saturation, frontend framework evolution (Angular, Vue, React 19), JavaScript runtime competition (Node, Bun, Deno), browser market shifts including Chrome's antitrust issues and Arc's pivot, major cloud outages from Google, AWS, and Cloudflare, and programming language updates in Go, Rust, and PHP. The year saw industry fatigue with AI hype, continued layoffs, and consolidation around common frontend patterns like signals-based reactivity and server-side rendering.
36
3
16
Article
InfoQ·16w
Cloudflare Open Sources tokio‑quiche, Promising Easier QUIC and HTTP/3 in Rust
Cloudflare released tokio-quiche, an open-source Rust library that wraps their quiche QUIC/HTTP/3 implementation with Tokio's async runtime. The library simplifies building high-performance QUIC applications by handling UDP I/O, connection management, and event loops automatically. It uses an actor model internally and exposes an ApplicationOverQuic trait for protocol abstraction. Cloudflare uses it in production for edge services, HTTP proxies, and MASQUE-based tunnels in their WARP client, handling millions of requests per second. The library is available on crates.io as a foundational building block, with plans to release higher-level HTTP client/server abstractions.
34
1
17
Article
HelixML·17w
We Mass-Deployed 15-Year-Old Screen Sharing Technology and It's Actually Better
A team built a sophisticated H.264 video streaming pipeline over WebSockets for their AI coding platform, only to discover that simple JPEG screenshot polling works better on unreliable networks. The article details their journey from WebRTC (blocked by enterprise firewalls) to a custom 60fps H.264 solution (failed on poor connections) to a hybrid approach that adaptively switches between high-quality video streaming and stateless JPEG screenshots based on network conditions. The key insight: stateless JPEGs (100-150KB each) provide better reliability and lower bandwidth than stateful video codecs when network quality degrades, while maintaining responsive keyboard/mouse input over WebSockets.
35
2
18
Article
JetBrains·16w
Advent of Code in Rust: Winners and Highlights
JetBrains announced the winners of their Advent of Code 2025 Rust competition, with 71 participants competing on leaderboards. Duro took first place for the second consecutive year with a score of 2017, followed by four other top performers. Five additional winners were randomly selected. The post includes links to Rust learning resources, including a guide on using AI responsibly for AoC challenges and a RustRover Advent Calendar featuring daily IDE tips.
34
19
Article
DEV·17w
My OSS Stalled for 3 Months Because of Misguided Vibe Coding—This Is the Full Reboot Story
A developer shares their experience recovering from a 3-month project stall on diffx, a structured-data diff tool. The root causes included monorepo complexity, over-sharing CI/CD infrastructure across multiple projects, premature multilingual documentation, and quality issues from AI-assisted "vibe coding" without proper verification. The recovery process involved quarantining existing code, manually verifying functionality, writing specs from scratch, rebuilding tests based on specs rather than implementation, and splitting the monorepo into separate language-specific repositories. Key lessons include the importance of spec-driven development with AI, two-stage release workflows, and having the courage to delete broken artifacts rather than clinging to sunk costs.
32
1
20
Video
Low Level Learning·17w
i didn't expect to see this...
A CVE was discovered in Rust code within the Linux kernel's Android Binder driver, marking the first security vulnerability in kernel Rust code. The bug is a race condition in an unsafe block that handles doubly linked list operations for tracking node deaths. The vulnerability occurred because the code moved list items to a local stack copy and dropped the lock prematurely, allowing two threads to simultaneously access and modify the same list structure. This led to memory corruption and kernel crashes. The fix involved iterating over the list with proper locking instead of creating a local copy, demonstrating that even memory-safe languages require careful handling of concurrent operations in kernel code.
30
6
21
Article
vLLM·17w
Token-Level Truth: Real-Time Hallucination Detection for Production LLMs
HaluGate is a real-time hallucination detection system for production LLMs that identifies when models generate claims contradicting provided context. It uses a two-stage pipeline: first classifying whether queries need fact-checking (96.4% accuracy, 12ms latency), then performing token-level detection with NLI explanation for factual queries (76-162ms overhead). Built with ModernBERT and native Rust/Candle integration, it runs without Python dependencies, adding negligible latency compared to LLM generation times. The system integrates with vLLM's Signal-Decision Architecture, exposing results via HTTP headers for downstream policy enforcement. Unlike LLM-as-judge approaches, HaluGate provides explainable, consistent verification specifically for extrinsic hallucinations where tool/RAG context exists.
27
1
22
Video
Let's Get Rusty·18w
2026 Will Make or Break Rust
Rust stands at a critical juncture in 2026, positioned to either cross into mainstream adoption or fade into niche use. Major tech companies like AWS, Google, and Microsoft are already using Rust for critical infrastructure, and the language excels in tooling with Cargo and mature frameworks. However, the talent pool remains limited, with companies struggling to find competent Rust developers. The bull case centers on Rust's unique ability to provide memory safety without sacrificing performance, making it essential for critical systems. The bear case argues that most companies don't need Rust's guarantees and that developer productivity matters more. With growing demand in AI infrastructure, robotics, and embedded systems, learning Rust now could position developers advantageously before the talent market becomes saturated.
27
3
23
Article
Oxide·18w
A disappearing Service Processor
A Service Processor on Oxide's Cosmo sled would intermittently disappear from the network, appearing completely dead. After weeks of debugging with limited access, the root cause was traced to mismatched memory attributes between privileged and unprivileged modes when accessing an FPGA via the STM32H7's Flexible Memory Controller. The CPU's cache was treating the FMC bus as Normal Cached memory in kernel mode but Device Memory in task mode, causing the bus to hang when stores from unprivileged tasks hit the cache during interrupts. Moving the FMC base address to a memory region with consistent Device Memory attributes resolved the issue.
26
1
24
Article
InfoWorld·17w
Python type checker ty now in beta
Astral's ty, a Rust-based Python type checker, has entered beta with extremely fast incremental updates. It can be installed via uv or as a VS Code extension, with a stable release planned for 2026. Built around incrementality, ty selectively re-runs computations when code changes, making live updates significantly faster than alternatives like Mypy, Pyright, and Pylance. The tool features Rust-inspired diagnostic messages that provide context across multiple files and can run orders of magnitude faster than other Rust-based language servers on large projects.
25
25
Article
Bytes by ui.dev·18w
Pimp my Bundler: Vite edition
Vite 8 beta introduces Rolldown, a Rust-based bundler that replaces the dual esbuild/Rollup pipeline. Rolldown offers native speed (10-30× faster than Rollup), Rollup plugin compatibility, and advanced features like module federation. This gives the Vite team full control over their toolchain (Vite, Rolldown, Oxc) for a more cohesive developer experience. The newsletter also covers React RSC security vulnerabilities, TypeScript 7 progress, JavaScript's 30th anniversary, and various ecosystem updates.
25
1

See all Rust archives