Cloudflare Makes Open-Source The Rust Code To Tokio-Quiche
Cloudflare announced today they have open-sourced the code to Tokio-Quiche as their async QUIC library that combines their previously-open-sourced Quiche QUIC implementation with Rust’s Tokio async runtime… ⌘ Read more
NVIDIA Preparing For Hopper & Blackwell GPU Support With Open-Source Nova Driver
NVIDIA engineers continue working a lot on the open-source and upstream Nova driver for the Linux kernel. This modern, Rust-written open-source NVIDIA driver is still taking shape as an alternative to NVIDIA’s official downstream open-source driver and the aging and reverse-engineered Nouveau driver. Out on the horizon for Nova is Hopper and Blackwell GPU support… ⌘ Read more
Rust Foundation Maintainers Fund Announced For Long-Term Support To Rust Developers
The Rust Foundation announced today the creation of the Rust Foundation Maintainers Fund as a new means of providing consistent, transparent, and long-term support for developers that make the Rust programming language possible… ⌘ Read more
Debian Adding “Hard Dependency” on Rust, May Abandon Some PC Architectures
APT, Debian’s package manager also used by Ubuntu, to have a hard Rust requirement. ⌘ Read more
Debian to add hard Rust dependency to APT
It seems like a number of Debian ports are going to face difficult times over the coming months. Debian developer Julian Andres Klode has sent a message to the Debian mailing lists that APT will very soon start requiring Rust. I plan to introduce hard Rust dependencies and Rust code into APT, no earlier than May 2026. This extends at first to the Rust compiler and standard library, and the Sequoia ecosystem. In particular, our code to parse .deb, . … ⌘ Read more
↳
In-reply-to
»
There are no really good GUI toolkits for Linux, are there?
⤋ Read More
@lyse@lyse.isobeef.org Hmmmmmmmmmmmm … guess I should take a look at Qt. 🤔 That’s the one popular toolkit that I’ve never really tried for some reason. I really don’t like C++ (might as well use Rust), so I’ll also use Python.
Tag proposal: conflicts
Given that we’ve recently been flooded with posts about conflicts in relation to Ruby Central, DHH, Omarchy, Rust in Linux, and now Freedesktop, can we have a tag for this kind of thing? I accept that it’s important and on topic but I’d like to be able to take a break. ⌘ Read more
Rust Clone of Core Utils Breaks Ubuntu Updates
Ubuntu 25.10 dropped the battle tested GNU Core Utils, in favor of the untested, incomplete “uutils”. ⌘ Read more
Create Your Own AI Voice Agent Using EchoKit, ESP32, and Rust
Step-by-step tutorial for EchoKit, a DIY AI voice agent (fully open source) I’ve been working on.
🔹 Hardware: An easy-to-assemble ESP32-S3 board (EchoKit). 🔹 Server: A high-performance server built entirely in Rust to manage the ASR -> LLM -> TTS pipeline. 🔹 AI Models: Fully customizable, using Groq’s APIs (Whisper, Llama 3, PlayAI-TTS) in the guide for near-instant responses.
This project is perfect for:
Developers wantin … ⌘ Read more
Rust Changes from “Master” to “Main”
Two weeks ago, The Lunduke Journal pointed out how many Leftist Open Source organizations (Rust, NixOS, Linux Kernel, etc.) still used the “Master” branch naming (against their “inclusive naming” rules). ⌘ Read more
Servo GTK: a widget to embed Servo in GTK4
Servo, the Rust-based browsing engine spun off from Mozilla, keeps making progress every month, and this made Ignacio Casal Quinteiro wonder: what if we make a GTK widget so we can test Servo and compare it to WebKitGTK? As part of my job at Amazon I started working in a GTK widget which will allow embedding a Servo Webview inside a GTK application. This was mostly a research project just to understand the current state of Servo and whether it was … ⌘ Read more
Linus Says Rust Formatting is “Bass-Ackwards Garbage”
“[Rustfmtcheck] is just ANNOYING. ⌘ Read more
Redox now multithreaded by default
Can these months please stop passing us by this quickly? It seems we’re getting a monthly Redox update every other week now, and that’s not right. Anyway, what have the people behind this Rust-based operating system been up to this past month? One of the biggest changes this month is that Redox is now multithreaded by default, at least on x86 machines. Unsurprisingly, this can enable some serious performance gains. Also contributing to performance improvements t … ⌘ Read more
cargo-subspace: Make rust-analyzer work better with very large cargo workspaces
Let me preface all of this by saying that rust-analyzer is an amazing project, and I am eternally grateful for the many people who contribute to it! It makes developing rust code a breeze, and it has surely significantly contributed to Rust’s widespread adoption.
If you’ve ever worked with a very large cargo workspace (think hundreds of crates), you know that rust-analyzer eagerly builds compile time dependencies (e.g. proc macros) and index … ⌘ Read more
Linux, Rust, & NixOS Use Master Branch, Support Human Slavery
Using the term “Master” in our software projects is racist, right? ⌘ Read more
Ninajirachi’s “I Love My Computer” føles som det rigtige album at skrive embedded rust bluetooth drivere til ⌘ Read more
Ubuntu’s Rust GNU Utils Replacement 17x Slower & Buggy
Canonical plans to replace the battle tested GNU Coreutils with new, untested, Rust-based replacements. ⌘ Read more
Mathieu Pasquet: slixmpp v1.11
This new version includes a few new XEP plugins as well as fixes, notably
for some leftover issues in our rust JID code, as well as one for a bug that
caused issues in Home Assistant.
Thanks to everyone who contributed with code, issues, suggestions, and reviews!
CI and buildNicoco put in a lot of work in order to get all possible wheels built in CI. We now have manylinux and musl builds of everything doable within codeberg,
published to the codeberg pypi repo, and published on pypi. … ⌘ Read more
Okay, now this is a very interesting Rust feature:
https://blog.rust-lang.org/2025/07/03/stabilizing-naked-functions/
This (and inline assembly) makes Rust really interesting for very low-level stuff. 🥳
↳
In-reply-to
»
Okay, here’s a thing I like about Rust: Returning things as
⤋ Read More
Option and error handling. (Or the more complex Result, but it’s easier to explain with Option.)
@lyse@lyse.isobeef.org lol – I explicitly kept them in there so that the code is easier to understand for non-Rust people 🤪😂
Okay, here’s a thing I like about Rust: Returning things as Option and error handling. (Or the more complex Result, but it’s easier to explain with Option.)
fn mydiv(num: f64, denom: f64) -> Option<f64> {
// (Let’s ignore precision issues for a second.)
if denom == 0.0 {
return None;
} else {
return Some(num / denom);
}
}
fn main() {
// Explicit, verbose version:
let num: f64 = 123.0;
let denom: f64 = 456.0;
let wrapped_res = mydiv(num, denom);
if wrapped_res.is_some() {
println!("Unwrapped result: {}", wrapped_res.unwrap());
}
// Shorter version using "if let":
if let Some(res) = mydiv(123.0, 456.0) {
println!("Here’s a result: {}", res);
}
if let Some(res) = mydiv(123.0, 0.0) {
println!("Huh, we divided by zero? This never happens. {}", res);
}
}
You can’t divide by zero, so the function returns an “error” in that case. (Option isn’t really used for errors, IIUC, but the basic idea is the same for Result.)
Option is an enum. It can have the value Some or None. In the case of Some, you can attach additional data to the enum. In this case, we are attaching a floating point value.
The caller then has to decide: Is the value None or Some? Did the function succeed or not? If it is Some, the caller can do .unwrap() on this enum to get the inner value (the floating point value). If you do .unwrap() on a None value, the program will panic and die.
The if let version using destructuring is much shorter and, once you got used to it, actually quite nice.
Now the trick is that you must somehow handle these two cases. You must either call something like .unwrap() or do destructuring or something, otherwise you can’t access the attached value at all. As I understand it, it is impossible to just completely ignore error cases. And the compiler enforces it.
(In case of Result, the compiler would warn you if you ignore the return value entirely. So something like doing write() and then ignoring the return value would be caught as well.)