Tootfinder

Cross-Plattform-Applikationen mit Rust 1: Langlebig und flexibel
Die plattformübergreifende Entwicklung ohne Framework hat einige Vorteile, und die Programmiersprache Rust eignet sich gut für die Umsetzung.
🦀 https://www.heise.de/hintergrund/Cr…

Cross-Plattform-Applikationen mit Rust 1: Langlebig und flexibel
Die plattformübergreifende Entwicklung ohne Framework hat einige Vorteile, und die Programmiersprache Rust eignet sich gut für die Umsetzung.

Let's write a #macro in #Rust - Part 1
https://hackeryarn.com/post/rust-macros-1/

»Schwachstelle in Rust-Library für tar-Archive entdeckt:
Die Library async-tar und ihre Forks enthalten eine als TARmageddon benannte Schwachstelle. Der am weitesten verbreitete Fork tokio-tar bekommt keinen Patch.«
Nun gut, dann schaue ich mal nach in welchen Rust-Libs die ich nutze dies evt. verwendet wird. Schwachstellen gibt es in jeglichen Code doch je nach dem wird es behoben.
🦀

Schwachstelle in Rust-Library für tar-Archive entdeckt
Die Library async-tar und ihre Forks enthalten eine als TARmageddon benannte Schwachstelle. Der am weitesten verbreitete Fork tokio-tar bekommt keinen Patch.

from my link log —
Upcoming Rust language features for kernel development.
https://lwn.net/Articles/1039073/
saved 2025-10-20 https://dotat.at/:/J064N…

🇺🇦 Auf radioeins läuft...
Ben Böhmer:
🎵 Rust (Radio Edit)
#NowPlaying #BenBöhmer
https://benbohmer.bandcamp.com/track/rust
https://open.spotify.com/track/1c0gopa3ANBpKL59SKU3EZ

just found https://crates.io/crates/cargo_toml today and the pic is just awesome lol

crates.io: Rust Package Registry

In other news, I am evaluating restic vs rustic right now for backups. rustic is a Rust reimplementation of restic, which is a Go app.
I REALLY want to love rustic. It;'s easier to deploy, has a nicer user interface. It might be slightly faster and have slightly less memory usage. It does one thing I really love which is that it supports relative paths.
Let me explain…
(1/8)

from my link log —
foldhash: A fast, non-cryptographic, minimally DoS-resistant hashing algorithm for Rust.
https://github.com/orlp/foldhash
saved 2025-09-14 https://…

GitHub - orlp/foldhash: A fast, non-cryptographic, minimally DoS-resistant hashing algorithm for Rust.
A fast, non-cryptographic, minimally DoS-resistant hashing algorithm for Rust. - orlp/foldhash

Under the hood: Vec<T>
Let's look at Vec<T> to get a better understanding of its inner structure.
🦀 #rust

Under the hood: Vec
Let's look at Vec to get a better understanding of its inner structure.

#running slow is hard but my fitness is such that it requires a rebuild of the foundation. Trying to stay in HR2 means a decent amount of walking interspersed. I don’t love it, but it’s necessary.
I have a much more open schedule now, so I should be able to get out and run regularly. The trick will be staying patient and trusting the process.

Is Dak Prescott playing today vs Falcons? Injury news update for Cowboys QB https://cowboyswire.usatoday.com/story/sports/nfl/cowboys/2025/08/22/dak-prescott-injury-status-cowboys-falcons-preseason/85782070007/

It looks like we're going to have some more fun with Rust soon!
🦀🦀

New #Rust Client Enables Building Safe, High-Performance Apps with #Aerospike
https://www.infoq.com/news/2025/08/…

Project-Level C-to-Rust Translation via Synergistic Integration of Knowledge Graphs and Large Language Models
Zhiqiang Yuan, Wenjun Mao, Zhuo Chen, Xiyue Shang, Chong Wang, Yiling Lou, Xin Peng
https://arxiv.org/abs/2510.10956

Project-Level C-to-Rust Translation via Synergistic Integration of Knowledge Graphs and Large Language Models
Translating C code into safe Rust is an effective way to ensure its memory safety. Compared to rule-based translation which produces Rust code that remains largely unsafe, LLM-based methods can generate more idiomatic and safer Rust code because LLMs have been trained on vast amount of human-written idiomatic code. Although promising, existing LLM-based methods still struggle with project-level C-to-Rust translation. They typically partition a C project into smaller units (\eg{} functions) base…

from my link log —
Faster Rust builds on Mac.
https://nnethercote.github.io/2025/09/04/faster-rust-builds-on-mac.html
saved 2025-09-04

@… binge watching 🦀🦀
https://youtube.com/@oxidizeconf 👀

Oxidize Conference
The Oxidize Conference is the event for applied Rust. We don't just talk about how to use Rust, but we're looking at where Rust is being used. From embedded technology in IoT medical devices to critical safety applications to vehicular dashboards written in Ferrocene – our speakers and workshops are about taking Rust to new levels.

(2)
Als u bedenkt dat zij tot hun 21e levensjaar een kinderloon krijgen, is dat ook niet raar. Dat zult u vast begrijpen. Jongeren moeten twee keer zo veel werken om hetzelfde te verdienen als iemand van 21 jaar of ouder.

De volgende partijen stemden voor de motie van Volt:
GroenLinks-PvdA, D66, DENK, SP, Partij voor de Dieren, ChristenUnie en de PVV.

Zij hebben samen 87 zetels. Uw Kabinet rust op nog maar 32 zetels.

🍎 Faster Rust builds on Mac
... been having this problem on Windows ever since there was Windows Defender!
https://nnethercote.github.io/2025/09/04/faster-rust-builds-on-mac.html

Nessie: A Rust-Powered, Fast, Flexible, and Generalized Friends-of-Friends Galaxy-Group Finder in R and Python
Trystan S. Lambert, A. S. G. Robotham, M. Bravo, C. del P. Lagos, R. Tobar, S. Driver, A. Aufan Stoffels d'Hautefort
https://arxiv.org/abs/2509.13647

Nessie: A Rust-Powered, Fast, Flexible, and Generalized Friends-of-Friends Galaxy-Group Finder in R and Python
We introduce Nessie, a galaxy group finder implemented in Rust and distributed as both a Python and R package. Nessie employs the friends-of-friends (FoF) algorithm and requires only on-sky position and redshift as input, making it immediately applicable to surveys that lack a well-defined luminosity function. We implement several algorithmic optimizations including binary search and k-d tree pre-selection that significantly improve performance by reducing unnecessary galaxy pair checks. To val…

"How to Optimize Rust for Slowness" – Carl Kadie
#rustlang

Enhancing Type Safety in MPI with Rust: A Statically Verified Approach for RSMPI
Nafees Iqbal, Jed Brown
https://arxiv.org/abs/2509.10803 https://arxiv.org…

Enhancing Type Safety in MPI with Rust: A Statically Verified Approach for RSMPI
The Message Passing Interface (MPI) is a fundamental tool for building high-performance computing (HPC) applications, enabling efficient communication across distributed systems. Despite its widespread adoption, MPI's low-level interface and lack of built-in type safety make it prone to runtime errors, undefined behavior, and debugging challenges, especially in large-scale applications. Rust, a modern systems programming language, offers a compelling solution with its strong type system, which …

@… I really appreciated how Java would make me jump through a few hoops to set a private variable in an object controlled by a dependency, but it would absolutely do it. It’s something I definitely miss when writing Rust.
In JavaScript, you can make objects via classes/prototypes, or by closing over local variables. The latter hides them because there’s no way to re…

Proactive security communication is a sign of a healthy community: https://github.com/rust-lang/crates.io/discussions/11889
via @……

A Trace-based Approach for Code Safety Analysis
Hui Xu
https://arxiv.org/abs/2510.10410 https://arxiv.org/pdf/2510.10410

A Trace-based Approach for Code Safety Analysis
Rust is a memory-safe programming language that disallows undefined behavior. Its safety guarantees have been extensively examined by the community through empirical studies, which has led to its remarkable success. However, unsafe code remains a critical concern in Rust. By reviewing the safety design of Rust and analyzing real-world Rust projects, this paper establishes a systematic framework for understanding unsafe code and undefined behavior, and summarizes the soundness criteria for Rust …

from my link log —
rust-parallel: Run commands in parallel and aggregate outputs, like GNU parallel.
https://github.com/aaronriekenberg/rust-parallel
saved 2025-08-03

GitHub - aaronriekenberg/rust-parallel: Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs plus useful features. Listed in Awesome Rust utilities.
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs plus useful features. Listed in Awesome Rust utilities. - aaronriekenberg/rust-parallel

Niet De Speld, gewoon oer Hollandse onverdraagzaamheid van de dikke portemonnee: Woede in wijk over nieuwe speeltuin: ‘Koop je een huis van bijna 1 miljoen, krijg je een speelplek in je achtertuin’ https://www.ad.n…

Woede in wijk over nieuwe speeltuin: ‘Koop je een huis van bijna 1 miljoen, krijg je een speelplek in je achtertuin’
Een groep bewoners van Boveneind is woest over de plannen voor een nieuwe speelplaats in de wijk. Ze vrezen herrie, hangjongeren en het verlies van ‘hun’ hondenlosloopgebied. Bovendien zijn er al genoeg speeltuinen in de buurt, klinkt het. „Hiervoor woonden we nabij een schoolplein, we kwamen juist hierheen voor onze rust.”

https://github.com/rust-lang/libc/blob/61b722e2517775cea98428702710ee9ef00f02a0/src/unix/linux_like/linux/gnu/b32/arm/mod.rs#L743
oh no :3

libc/src/unix/linux_like/linux/gnu/b32/arm/mod.rs at 61b722e2517775cea98428702710ee9ef00f02a0 · rust-lang/libc
Raw bindings to platform APIs for Rust. Contribute to rust-lang/libc development by creating an account on GitHub.

The Hidden Rules Behind Rust Functions & Closures
Demystifying fn, Fn, FnMut, and FnOnce from everyday usage to compiler magic under the hood
🦀 https://blog.cuongle.dev/p/the-hidden-rules-behind-rust-functions

The Hidden Rules Behind Rust Functions & Closures
Demystifying fn, Fn, FnMut, and FnOnce from everyday usage to compiler magic under the hood

YOU DON'T HAVE TO DO IT
/١٠١١٠٠٠
IT WILL KILL!

Are you writing high-level #embedded Rust code that makes uses of the embedded-io crate? Do you think anything is amiss there that can *not* be added later by semver compatible updates? Then please write about it in https://…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Yubo Bai, Tapti Palit
https://arxiv.org/abs/2510.07604 https://arxiv.org/pdf/25…

RustAssure: Differential Symbolic Testing for LLM-Transpiled C-to-Rust Code
Rust is a memory-safe programming language that significantly improves software security. Existing codebases written in unsafe memory languages, such as C, must first be transpiled to Rust to take advantage of Rust's improved safety guarantees. RustAssure presents a system that uses Large Language Models (LLMs) to automatically transpile existing C codebases to Rust. RustAssure uses prompt engineering techniques to maximize the chances of the LLM generating idiomatic and safe Rust code. Moreove…

Elements of #Rust – Core Types and Traits
https://rustcurious.com/elements/

For shits and giggles I decided to ssh upgrade my FreeBSD 15 to KDE 6.4.5, by using the latest ports. Let me say the process (git pulling the latest ports, portmastering et al) does certainly work. Five and a half hours later I'm happy to be not on the premises to hear my 2018 NUC take off. Rust, llvm, you get it.
Shits and giggles indeed 🤣
#freebsd

Ferron - A fast, modern web server written in Rust.
Ferron is a fast web server with automatic TLS certificate management, easy configuration, and rock-solid security — so you can go live in minutes.
⚡ #web

Ferron - a fast, modern web server
Ferron is a high-performance web server with built-in TLS certificate management. Designed for speed, security and ease of configuration.

#TIL about prek, a rewrite of pre-commit written in Rust. And as expected, it is extremely fast: #pre-comm…

If you'd like to know how my day has been, let's just say I had to get a rust app's binary onto someone's 32-bit Debian 7 (wheezy) machine. Kernel 3.2.0. Version of glibc unsupported by any version of rust.
Ended up cross-building it to i686-unknown-linux-musl from a modern amd64 host.

from my link log —
Updating a large codebase to Rust 2024.
https://codeandbitters.com/rust-2024-upgrade/
saved 2025-02-07 https://…

Langtauferer
Today, a year ago, I ventured on a dream trip I'd been researching for a long time, and which ended up being a semi-religious experience, being immersed in (and somewhat overwhelmed by) an actively changing environment, the upheaval and plethora of geological features, structures, unreal colors, layers, textures and the "wounds" exposed by the melting and disappearing glaciers... Countless waterfalls, stunning erosion features, later traversing the glacier ga…

I am having severe issues with LSPs.
Now it is Rust Analyzer.
Before I had OOMs with the Go LSP.
And I am not alone; there are many posts like this.
Regardless of editors.
People report it with VSCode and NeoVim.
I guess I will get back to Zed again for now.
Just the conveniences of auto-complete, going to definitions, keyboard-only use and nice integration with a terminal is what I'm after.
I know that IDEs have terminal panes, but they are cumbe…

Be Simple - Don’t Be Clever - Code Rust
— by @…
🦀 #rust

Be Simple | corrode Rust Consulting
The phone buzzes at 3 AM. You roll out of bed, open your laptop, and see this in the logs: th…

Concentrated N-dimensional AMM with Polar Coordinates in Rust
Vasily Tolstikov, Marcus Wentz, Joseph Schiarizzi, Derek Ding
https://arxiv.org/abs/2510.05428 https://

Concentrated N-dimensional AMM with Polar Coordinates in Rust
We expand on the recent development of n-dimensional automated market makers for stablecoins by showing a way to build concentrated liquidity positions with ticks in polar coordinates in Rust, including the featured ability to skew said concentrated liquidity. We highlight the risk of stacking too many stablecoin pools and how to hedge said risk.

This Send/Sync Secret Separates Professional From Amateur #Rust Developers
https://blog.cuongle.dev/p/this-sendsync-secret-separates-professional-and-amat…

It looks like sunxi SoCs can load either a very small binary (<=4K IIUC), or bigger ones with an eGON header and via sunxi-fel.
Maybe I'll get back to working on the Rust implementation.

Lessons Learned So Far From Verifying the Rust Standard Library (work-in-progress)
Alex Le Blanc, Patrick Lam
https://arxiv.org/abs/2510.01072 https://arxi…

Lessons Learned So Far From Verifying the Rust Standard Library (work-in-progress)
Although Rust primarily intends to be a safe programming language that excludes undefined behaviour, it provides its users with the escape hatch of unsafe Rust, allowing them to circumvent some of its strong compile-time checks. This additional freedom has some advantages, including potentially more efficient code, which is one of the main reasons why unsafe code is used extensively throughout Rust's standard library. However, because unsafe code also re-opens the door to undefined behaviour, A…

🇺🇦 Auf radioeins läuft...
Ben Böhmer:
🎵 Rust (Radio Edit)
#NowPlaying #BenBöhmer
https://benbohmer.bandcamp.com/track/rust
https://open.spotify.com/track/1c0gopa3ANBpKL59SKU3EZ

#RustLang is great and rock solid. That's why when you build the Rust compiler against LLVM with assertions enabled, it crashes on unmet assertions.

A #rust warning just found a mistake I was in the middle of making; I had a match clause like:
(_, Bad) =>
and the warning was that the variable 'Bad' should be lower case; But hang on...that's no variable - that should be an enum member of State::Bad. Which is a nice find.
(Although I can't tell why it didn't figure out it was a member of State automatical…

Should we create a little #ReGIS library in #Rust?
🙂✨🦀✨👩‍💻

from my link log —
rumdl: a Markdown linter written in Rust.
https://github.com/rvben/rumdl
saved 2025-10-14 https://dotat.at/:/OMAR4.html

GitHub - rvben/rumdl: A Markdown Linter written in Rust
A Markdown Linter written in Rust. Contribute to rvben/rumdl development by creating an account on GitHub.

Comparing transitive dependency version resolution in #Rust and #Java
https://blog.frankel.ch/dependency-ver

EVOC2RUST: A Skeleton-guided Framework for Project-Level C-to-Rust Translation
Chaofan Wang, Tingrui Yu, Jie Wang, Dong Chen, Wenrui Zhang, Yuling Shi, Xiaodong Gu, Beijun Shen
https://arxiv.org/abs/2508.04295

EVOC2RUST: A Skeleton-guided Framework for Project-Level C-to-Rust Translation
Rust's compile-time safety guarantees make it ideal for safety-critical systems, creating demand for translating legacy C codebases to Rust. While various approaches have emerged for this task, they face inherent trade-offs: rule-based solutions face challenges in meeting code safety and idiomaticity requirements, while LLM-based solutions often fail to generate semantically equivalent Rust code, due to the heavy dependencies of modules across the entire codebase. Recent studies have revealed t…

»Ubuntu 25.10 — Rust statt C, Wayland statt X11:
Die Linux-Distribution Ubuntu 25.10 nutzt Rust-basierte Systemkomponenten. Der auf Version 49 aktualisierte @… Desktop läuft nur noch auf Wayland.«
Ich pers. bevorzuge @… nicht als Desk…

Ubuntu 25.10: Rust im Userland und Wayland-only
Die Linux-Distribution Ubuntu 25.10 nutzt Rust-basierte Systemkomponenten. Der auf Version 49 aktualisierte GNOME-Desktop läuft nur noch auf Wayland.

@… @… I spent 3 years being really into Rust but the shenanigans they have to get up to in order to make async work are horrifying, both in the language and for the user.
I have now gone back to Haskell.

from my link log —
Find memory errors in unsafe Rust in production with GWP-ASan and the Scudo hardened allocator.
https://blog.colinbreck.com/making-unsafe-rust-a-little-safer-find-memory-errors-in-production-wit…

Making Unsafe Rust a Little Safer: Find Memory Errors in Production with GWP-ASan
GWP-ASan finds rare memory errors in C and C++ called from Rust.

»👨‍💻️ Rust & Co. – sichere moderne Programmiersprachen im Vergleich
(CC2tv Folge 406)«
Für einige ist dieses Video sicherlich sehr trocken über moderne Programmiersprachen doch für mich angenehm ruhig erklärt so wie Informativ obwohl ich schon ein paar Dinge kenne was erklärt wird. Es werden die klaren Strukturierung so wie weitere Vorteile von Rust erläutert.
📺

Some #Rust shilling, retrofitting the "too grumpy to improve" meme, offering a Rust gear instead of the hexagon C wheel (logo).

from my link log —
Snooping on slow builds using syscalls.
https://danielchasehooper.com/posts/syscall-build-snooping/
saved 2025-08-13

I Made A Real-Time C/C++/Rust Build Visualizer
Many software projects take a long time to compile. Sometimes that’s just due to the sheer amount of code, like in the LLVM project. But often a build is slower than it should be for dumb, fixable reasons. I’ve had the suspicion that most builds are doing dumb stuff, but I had no way to see it. So I’ve been working on a cross-platform tool to help speed up builds (you can try it, see below).

Integrating Rules and Semantics for LLM-Based C-to-Rust Translation
Feng Luo, Kexing Ji, Cuiyun Gao, Shuzheng Gao, Jia Feng, Kui Liu, Xin Xia, Michael R. Lyu
https://arxiv.org/abs/2508.06926

Integrating Rules and Semantics for LLM-Based C-to-Rust Translation
Automated translation of legacy C code into Rust aims to ensure memory safety while reducing the burden of manual migration. Early approaches in code translation rely on static rule-based methods, but they suffer from limited coverage due to dependence on predefined rule patterns. Recent works regard the task as a sequence-to-sequence problem by leveraging large language models (LLMs). Although these LLM-based methods are capable of reducing unsafe code blocks, the translated code often exhibit…

🇺🇦 Auf radioeins läuft...
Ben Böhmer:
🎵 Rust (Radio Edit)
#NowPlaying #BenBöhmer
https://benbohmer.bandcamp.com/track/rust
https://open.spotify.com/track/1c0gopa3ANBpKL59SKU3EZ

from my link log —
cargo-crev: A web-of-trust code review system for Rust.
https://github.com/crev-dev/cargo-crev
saved 2025-09-09 https://

GitHub - crev-dev/cargo-crev: A cryptographically verifiable code review system for the cargo (Rust) package manager.
A cryptographically verifiable code review system for the cargo (Rust) package manager. - crev-dev/cargo-crev

Really nice, @… have written about #Rust in their blog, providing 5 good reasons why you should "rewrite everything in Rust":

Rewriting code in Rust
This blog post explains why the system programming language Rust is enjoying growing popularity and why you might want to consider using it.

Decompiling Rust: An Empirical Study of Compiler Optimizations and Reverse Engineering Challenges
Zixu Zhou
https://arxiv.org/abs/2507.18792 https://arxiv.…

Decompiling Rust: An Empirical Study of Compiler Optimizations and Reverse Engineering Challenges
Decompiling Rust binaries is challenging due to the language's rich type system, aggressive compiler optimizations, and widespread use of high-level abstractions. In this work, we conduct a benchmark-driven evaluation of decompilation quality across core Rust features and compiler build modes. Our automated scoring framework shows that generic types, trait methods, and error handling constructs significantly reduce decompilation quality, especially in release builds. Through representative case…

from my link log —
A new packaging model for Rust in Guix.
https://guix.gnu.org/en/blog/2025/a-new-rust-packaging-model/
saved 2025-08-21 …

#Cloudflare just got faster and more secure, powered by #Rust
https://blog.cloudflare.com/20-percent

Oh fun find, there was actually something called Oxide in the history of #Rust already - a formalization attempt:
https://arxiv.org/abs/1903.00982 🦀
cc @…

Oxide: The Essence of Rust
Rust claims to advance industrial programming by bridging the gap between low-level systems programming and high-level application programming. At the heart of the argument that this enables programmers to build more reliable and efficient software is the borrow checker - a novel approach to ownership that aims to balance type system expressivity with usability. And yet, to date there is no core type system that captures Rust's notion of ownership and borrowing, and hence no foundation for rese…

from my link log —
TypePulse: detecting type confusion bugs in Rust programs.
https://dl.acm.org/doi/10.5555/3766078.3766435
saved 2025-09-14 https://

🇺🇦 Auf radioeins läuft...
Ben Böhmer:
🎵 Rust (Radio Edit)
#NowPlaying #BenBöhmer
https://benbohmer.bandcamp.com/track/rust
https://open.spotify.com/track/1c0gopa3ANBpKL59SKU3EZ

Fun fact from France:
The Arc<Triomphe> is thread-safe and immutable.
For reference (hehe):
https://doc.rust-lang.org/std/sync/struct.Arc.html

SandCell: Sandboxing Rust Beyond Unsafe Code
Jialun Zhang, Merve G\"ulmez, Thomas Nyman, Gang Tan
https://arxiv.org/abs/2509.24032 https://arxiv.org/p…

SandCell: Sandboxing Rust Beyond Unsafe Code
Rust is a modern systems programming language that ensures memory safety by enforcing ownership and borrowing rules at compile time. While the unsafe keyword allows programmers to bypass these restrictions, it introduces significant risks. Various approaches for isolating unsafe code to protect safe Rust from vulnerabilities have been proposed, yet these methods provide only fixed isolation boundaries and do not accommodate expressive policies that require sandboxing both safe and unsafe code. …

from my link log —
Speed wins when fuzzing Rust code with #[derive(Arbitrary)].
https://nnethercote.github.io/2025/08/16/speed-wins-when-fuzzing-rust-code-with-derive-arbitrary.html
saved 2025-08-22

Zeroize: The Tiny and Memory-Safe Rust Crate - Sensitive Data in Memory: A Hidden Threat
In a secure environment, one of the most overlooked threats is the presence of sensitive data in memory, such as passwords, tokens, cryptographic keys, or card numbers. Even when using Rust, where we emphasize ownership and thread safety, there's another crucial question to consider: What remains in the heap or stack after we no longer need it?
🛡️

Zeroize: The Tiny and Memory-Safe Rust Crate
Sensitive Data in Memory: A Hidden Threat In a secure environment, one of the most...

from my link log —
Comparing Rust to Carbon.
https://lwn.net/Articles/1036912/
saved 2025-09-29 https://dotat.at/:/E4XQI.html

🇺🇦 Auf radioeins läuft...
Ben Böhmer:
🎵 Rust (Radio Edit)
#NowPlaying #BenBöhmer
https://benbohmer.bandcamp.com/track/rust
https://open.spotify.com/track/1c0gopa3ANBpKL59SKU3EZ

"Bypassing" #specialization in #Rust or How I Learned to Stop Worrying and Love Function Pointers
https://

from my link log —
From Rust through LLVM to asm: the hidden journey of atomic fetch_max.
https://questdb.com/blog/rust-fetch-max-compiler-journey/
saved 2025-09-24

From Rust to Reality: The Hidden Journey of fetch_max | QuestDB
A compiler deep-dive tracing Rust’s AtomicU64

Arguzz: Testing zkVMs for Soundness and Completeness Bugs
Christoph Hochrainer, Valentin W\"ustholz, Maria Christakis
https://arxiv.org/abs/2509.10819 https://

Arguzz: Testing zkVMs for Soundness and Completeness Bugs
Zero-knowledge virtual machines (zkVMs) are increasingly deployed in decentralized applications and blockchain rollups since they enable verifiable off-chain computation. These VMs execute general-purpose programs, frequently written in Rust, and produce succinct cryptographic proofs. However, zkVMs are complex, and bugs in their constraint systems or execution logic can cause critical soundness (accepting invalid executions) or completeness (rejecting valid ones) issues. We present Arguzz, t…

Euphonica is a Rust-Powered MPD Client Heavy on Bling
MPD (Music Player Daemon) is a server-client audio player long popular with Linux users. The headless daemon runs as a background service, typically on a remote audio server. Music is then accessed via a GUI client frontend, which connects to the MPD server to stream content.
🎶

Euphonica is a Rust-Powered MPD Client Heavy on Bling
Euphonica is a new Rust-based MPD frontend for Linux desktops, with 'bling' as a key feature. I showcase its design, features, and current development status.

from my link log —
Wild performance tricks in Rust.
https://davidlattimore.github.io/posts/2025/09/02/rustforge-wild-performance-tricks.html
saved 2025-09-03

from my link log —
Rust ints to enums with fewer instructions.
https://sailor.li/ints-to-enums
saved 2025-08-30 https://dotat.at/:/3I45N.html

RE: https://mastodon.social/@CyReVolt/111023902588872016
Woah that was two years ago...
For context, this is a bare metal demo, written in Rust.
The car media player is based on the Allwinner D1s.
Here is the repo with the code:

from my link log —
Revisiting Loop Recognition in C ... in Rust.
https://blomqu.ist/posts/2025/loop-recognition/
saved 2025-05-30

from my link log —
Dealing with cancel safety in async Rust.
https://rfd.shared.oxide.computer/rfd/400
saved 2025-09-06 https://

»Crate Layout Best Practices: lib.rs, mod.rs, and src/bin«
Slowly, slowly, I'm learning what Rust uses for what in its coding.
🦀 https://dev.to/sgchris/crate-layout-best-practices-librs-modrs-and-srcbin-4abd

Crate Layout Best Practices: lib.rs, mod.rs, and src/bin
Crate Layout Best Practices: lib.rs, mod.rs, and src/bin Rust has rapidly become one of...

It would be a shame if someone wanted to write a #Linux #driver in #Rust and only resorted to C because the subsystem maintainer doesn't want Rust (yet).
So here is my call:
Push for it! If you…

It would be a shame if someone wanted to write a #Linux #driver in #Rust and only resorted to C because the subsystem maintainer doesn't want Rust (yet).
So here is my call:
Push for it! If you…

from my link log —
Writing into uninitialized buffers in Rust.
https://blog.sunfishcode.online/writingintouninitializedbuffersinrust/
saved 2025-05-21

I've sent out a funding application to OSFF for Intel ME tooling.
🥳
I had started an Intel ME file system parser for recent and current versions:
https://github.com/fiedka/me_fs_rs 👈🧐
Then I realized how much overlap there is between this, MEAnalyzer, the long unmaintained me_clean…

GitHub - fiedka/me_fs_rs: Intel ME filesystem parser written in Rust :crab:
Intel ME filesystem parser written in Rust :crab:. Contribute to fiedka/me_fs_rs development by creating an account on GitHub.

from my link log —
A C to Brainfuck compiler written in Rust.
https://iacgm.pages.dev/posts/c2bf/
saved 2025-10-13 https://dotat.at/:/OEPJB.html

What I really like about Rust is how much it feels like the code is practically writing itself thanks to all the excellent crates out there.
Once again, I am making great use of the zerocopy crate, specifically Ref:
https://docs.rs/zerocopy/latest/zerocopy/struct.Ref.html

Who'd follow a Rust rewrite of Sigrok? 🦀
https://sourceforge.net/p/sigrok/mailman/message/59244441/

from my link log —
Trying to get error backtraces in Rust libraries right.
https://www.iroh.computer/blog/error-handling-in-iroh
saved 2025-08-26

Trying to get error backtraces in rust libraries right
Read about iroh's approach to error handling

from my link log —
Fast UDP I/O for QUIC in Firefox in Rust.
https://max-inden.de/post/fast-udp-io-in-firefox/
saved 2025-09-26 https://

Writing tests in #Rust is really nice.
I am enjoying it right now while working on the @… flash layout and boot flow library.

from my link log —
A proposed Handle trait for Rust.
https://smallcultfollowing.com/babysteps/blog/2025/10/07/the-handle-trait/#fnref:3
saved 2025-10-07

Writing tests in #Rust is really nice.
I am enjoying it right now while working on the @… flash layout and boot flow library.

from my link log —
Emulating aarch64 in software using JIT compilation and Rust.
https://pitsidianak.is/blog/posts/2025-08-25_emulating_aarch64_in_software_using_JIT_compilation.html
saved 2025-08-26

I got Misc 8 right! lol
https://this.quiz.is.fckn.gay/
(that's how far I got for now)