Tootfinder

Announcing #Rust 1.88.0
https://blog.rust-lang.org/2025/06/26/Rust-1.88.0/

Securing Mixed Rust with Hardware Capabilities
Jason Zhijingcheng Yu, Fangqi Han, Kaustab Choudhury, Trevor E. Carlson, Prateek Saxena
https://arxiv.org/abs/2507.03344

Securing Mixed Rust with Hardware Capabilities
The Rust programming language enforces three basic Rust principles, namely ownership, borrowing, and AXM (Aliasing Xor Mutability) to prevent security bugs such as memory safety violations and data races. However, Rust projects often have mixed code, i.e., code that also uses unsafe Rust, FFI (Foreign Function Interfaces), and inline assembly for low-level control. The Rust compiler is unable to statically enforce Rust principles in mixed Rust code which can lead to many security vulnerabilitie…

15 #rust #cli tools that will make you abandon bash scripts forever
https://

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.

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…

Async Rust: When to Use It and When to Avoid It
“Asynchronous” (often abbreviated as “async”) is a widely used term in computer science, but its meaning varies depending on the context. […]
🦀 https://fmoya.dev/posts/async-rust/

from my link log —
Exploring ways to make async Rust easier.
https://carllerche.com/2021/06/17/six-ways-to-make-async-rust-easier/
saved 2021-06-17

How to deal with (Rust) dependencies
https://notgull.net/rust-dependencies/

Asterinas: A Linux ABI-Compatible, Rust-Based Framekernel OS with a Small and Sound TCB
Yuke Peng, Hongliang Tian, Zhang Junyang, Ruihan Li, Chengjun Chen, Jianfeng Jiang, Jinyi Xian, Xiaolin Wang, Chenren Xu, Diyu Zhou, Yingwei Luo, Shoumeng Yan, Yinqian Zhang
https://arxiv.org/abs/2506.03876

Asterinas: A Linux ABI-Compatible, Rust-Based Framekernel OS with a Small and Sound TCB
How can one build a feature-rich, general-purpose, Rust-based operating system (OS) with a minimal and sound Trusted Computing Base (TCB) for memory safety? Existing Rust-based OSes fall short due to their improper use of unsafe Rust in kernel development. To address this challenge, we propose a novel OS architecture called framekernel that realizes Rust's full potential to achieve intra-kernel privilege separation, ensuring TCB minimality and soundness. We present OSTD, a streamlined framework…

This https://arxiv.org/abs/2410.18042 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csPL_…

Charon: An Analysis Framework for Rust
With the explosion in popularity of the Rust programming language, a wealth of tools have recently been developed to analyze, verify, and test Rust programs. Alas, the Rust ecosystem remains relatively young, meaning that every one of these tools has had to re-implement difficult, time-consuming machinery to interface with the Rust compiler and its cargo build system, to hook into the Rust compiler's internal representation, and to expose an abstract syntax tree (AST) that is suitable for analy…

from my link log —
10 years of stable Rust: an infrastructure story.
https://rustfoundation.org/media/10-years-of-stable-rust-an-infrastructure-story/
saved 2025-05-15

10 Years of Stable Rust: An Infrastructure Story - The Rust Foundation
A note from the Rust Foundation: Today, May 15, 2025, marks 10 years since the first stable release of Rust. To commemorate this milestone, we are excited to share the following guest blog contributed by Graydon Hoare, initial author of the Rust programming language.   Rust turns 10 today, or at…

»6 Fehler, die sich Rust-Devs sparen sollten:
Wenn Sie Rust-Code schreiben, sollten Sie dieses halbe Dutzend Verfehlungen tunlichst vermeiden.«
Das Programmieren in Rust auch nicht an einem Wochenende gelernt ist, wie viele Scriptsprachen, ist klar. Durch deren Präzision aber auch sehr sicher (Fehler sind überall von Menschen einfließbar) und schnell, auch per WASM im Webbrowser.
🦀

6 Fehler, die sich Rust-Devs sparen sollten
Wenn Sie Rust-Code schreiben, sollten Sie dieses halbe Dutzend Verfehlungen tunlichst vermeiden.

💼 #OpenAI actively hiring #Rust developers for #codex-cli team expansion

🇺🇦 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

MAGA Antitrust Agenda Under Siege by Lobbyists Close to Trump (Wall Street Journal)
https://www.wsj.com/us-news/law/maga-antitrust-agenda-under-siege-by-lobbyists-close-to-trump-18558898
http://www.memeorandum.com/250806/p141#a250806p141

Faced with US heat waves, the Navajo push for power—and A/C
#energy

Faced with US heat waves, the Navajo push for power -- and A/C
Workmen plant electricity poles in the rust-orange earth of the Navajo Nation and run cables to Christine Shorty's house -- finally giving her power against ...

Ubuntu 25.10 Switches to Rust-based Sudo
https://www.omgubuntu.co.uk/2025/05/ubuntu-25-10-rust-sudo-rs-change

Forcrat: Automatic I/O API Translation from C to Rust via Origin and Capability Analysis
Jaemin Hong, Sukyoung Ryu
https://arxiv.org/abs/2506.01427 https:/…

Forcrat: Automatic I/O API Translation from C to Rust via Origin and Capability Analysis
Translating C to Rust is a promising way to enhance the reliability of legacy system programs. Although the industry has developed an automatic C-to-Rust translator, C2Rust, its translation remains unsatisfactory. One major reason is that C2Rust retains C standard library (libc) function calls instead of replacing them with functions from the Rust standard library (Rust std). However, little work has been done on replacing library functions in C2Rust-generated code. In this work, we focus on re…

Rust Implementation of Finite Element Exterior Calculus on Coordinate-Free Simplicial Complexes
Luis Wirth
https://arxiv.org/abs/2506.02429 https://…

Rust Implementation of Finite Element Exterior Calculus on Coordinate-Free Simplicial Complexes
This thesis presents the development of a novel finite element library in Rust based on the principles of Finite Element Exterior Calculus (FEEC). The library solves partial differential equations formulated using differential forms on abstract, coordinate-free simplicial complexes in arbitrary dimensions, employing an intrinsic Riemannian metric derived from edge lengths via Regge Calculus. We focus on solving elliptic Hodge-Laplace eigenvalue and source problems on the nD de Rham complex. We …

Best comment ever below this post:
"You know what else is unsafe? Life, yet we do it all the time.
I don’t care about rust and it’s artistic fanatics doing artistic screeching every time some C programmer uses a pointer."
👏🏻😂🙏😬🫣😳
https://hackaday.com/2025/08/04/a-gent

A Gentle Introduction To Fortran
Originally known as FORTRAN, but written in lower case since the 1990s with Fortran 90, this language was developed initially by John Backus as a way to make writing programs for the IBM 704 mainfr…

@… That's because Rust Never Sleeps, as Neil Young told us.

Rust vs. C for Python Libraries: Evaluating Rust-Compatible Bindings Toolchains
Isabella Basso do Amaral (University of S\~ao Paulo), Renato Cordeiro Ferreira (University of S\~ao Paulo, Jheronimus Academy of Data Science, Technical University of Eindhoven, Tilburg University), Alfredo Goldman (University of S\~ao Paulo)
https://

Rust vs. C for Python Libraries: Evaluating Rust-Compatible Bindings Toolchains
The Python programming language is best known for its syntax and scientific libraries, but it is also notorious for its slow interpreter. Optimizing critical sections in Python entails special knowledge of the binary interactions between programming languages, and can be cumbersome to interface manually, with implementers often resorting to convoluted third-party libraries. This comparative study evaluates the performance and ease of use of the PyO3 Python bindings toolchain for Rust against ct…

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.

Weird expressions in rust
```info
Note that these are not bugs, but rather extreme cases of rust features like loops, expressions, coercion and so on.
```
🦀 https://www.wakunguma.com/blog/rust-weird-expr

Weird expressions in rust
Explore weird quirks of rusts type system

A blog post summarizing our latest work: a static analyzer that leverages Rust in a non-trivial way!
https://blog.brownplt.org/2025/08/03/paralegal.html

I am at the same position as this post lines out. I’m neither hard core pro or anti LLMs. I think they are useful in specific contexts e.g. distilling and querying big chunks of text based information. They are not a hail mary solution to every problem.
„A lot of people like Rust and hate Go, and a lot of people like Go and hate Rust. That’s fine. That doesn’t bother me. But there’s something different about [AI discourse] that is driving me up a wall.“

Why Use Structured #Errors in #Rust Applications?
https://home.expurple.me/posts/why-use…

Rust's Stable MIR project is being slept on. It's pitched as a tool for formal verification, but it's more general than that. Once stabilized, it will almost be a stable compiler plugin API!
It doesn't just include what you get from `--emit=mir` (IR for each function), but also has full type and trait information, and will likely even support interactive queries like "does type implement trait”.
In short, it'll be perfect for metaprogramming!
[1/2]…

from my link log —
Behind the scenes of Rust string formatting and format_args!().
https://blog.m-ou.se/format-args/
saved 2023-12-05 https://

»Programmiersprache – Rust 2024 ist die bisher umfangreichste Edition:
Die jüngste Rust-Edition bringt große Neuerungen unter anderem für das Ownership-Modell, Unsafe Rust und Slices.«
Nun gut, dann gibt es mehr zu lernen und dies positiev.
🦀 https://www.…

Programmiersprache: Rust 2024 ist die bisher umfangreichste Edition
Die jüngste Rust-Edition bringt große Neuerungen unter anderem für das Ownership-Modell, Unsafe Rust und Slices.

`scx_bpfland` works really well as scheduler, I can compile Zed which mostly maxes out my CPU and still browse the web comfortably in Firefox.
https://github.com/sched-ext/scx/tree/main/scheds/rust/scx_bpfland

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

Now playing Castlevania: Bloodlines on the Mega Drive 🦇 Time to shake off the rust before going for that 1cc run! Been a while... #megadrive

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

Wooo, first Rust macro written...things continue to progress. Still need to figure out exactly how I want to represent the `F` register though.
#rust #z80 #emulation

I was asked if I could send a screenshot of my Rust learning project to possibly help to be installed. A server that deals with binary encryption, among other things, is not so simply clear to see 😅🤷‍♂️
(This is now in the INFO login, it's just for showing the request as a demo and doesn't make sense)
#rust

Pyrefly vs. ty: Comparing Python’s Two New Rust-Based Type Checkers
#types

@… Thanks, those are great! I’ve been eyeing Rust, enjoying the really well thought out support it has on STM32. I’m a C guy and wrapping my head around Rust is a whole other project. I’d really love it if there was something as clear as your series but using arm-gcc!

"For the 6 months or so I’ve been quietly porting tmux from C to Rust. I’ve recently reached a big milestone: the code base is now 100% (unsafe) Rust."
https://richardscollin.github.io/tmux-rs/

This https://arxiv.org/abs/2505.21323 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

A first look at ROS~2 applications written in asynchronous Rust
The increasing popularity of the Rust programming language in building robotic applications using the Robot Operating System (ROS~2) raises questions about its real-time execution capabilities, particularly when employing asynchronous programming. Existing real-time scheduling and response-time analysis techniques for ROS~2 focus on applications written in C++ and do not address the unique execution models and challenges presented by Rust's asynchronous programming paradigm. In this paper, we a…

TIL Enarx has a nice flags crate!
https://github.com/enarx/flagset
just used it already
https://

GitHub - enarx/flagset: Rust data types and a macro for generating enumeration-based bit flags
Rust data types and a macro for generating enumeration-based bit flags - enarx/flagset

vitalics/rslike: Rust-like but for TypeScript/JavaScript
https://github.com/vitalics/rslike

Python is also the most desired programming language in the Stack Overflow developer survey, while Rust remains the most admired: https://survey.stackoverflow.co/2025/technology#2-programming-scripting-and-markup-languages

This https://arxiv.org/abs/2504.09642 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_ees…

HBS -- Hardware Build System: A Tcl-based, minimal common abstraction approach for build system for hardware designs
Build systems become an indispensable part of the software implementation and deployment process. New programming languages are released with the build system integrated into the language tools, for example, Go, Rust, or Zig. However, in the hardware description domain, no official build systems have been released with the predominant Hardware Description Languages (HDL) such as VHDL or SystemVerilog. Moreover, hardware design projects are often multilanguage. The paper proposes a new build s…

TIL: #UV
#Python

GitHub - astral-sh/uv: An extremely fast Python package and project manager, written in Rust.
An extremely fast Python package and project manager, written in Rust. - astral-sh/uv

Waiting for issues (read them :-) to be resolved in 0.2.1 before I curl | sudo sh
https://unix.family/@farrokhi/114584340700417951

Kiedy piszesz bibliotekę w #RustLang, bo chcesz bezpiecznego kodu, a zamiast tego dostajesz jakiś paskudny #heisenbug z przekłamaniem danych.
https://…

from my link log —
Simple and fast derived traits in Rust using rules_derive.
https://matx.com/about
saved 2025-07-29 https://dotat.at/:/5O…

@… Have you seen this yet as a Mac person? https://oldbytes.space/@smallsco/114747196289375530

A very simple code to describe emotions or how does this work in real life?!?? ;)
```rust
#[allow(warnings)]
fn main() {
let mut emo: &str;
match 1 1 == 0b10 {
true => emo = "🤓",
_ => emo = "😵‍💫",
};
println!("Perception: {}", emo);
}
```
Play 🦀:

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…

deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses
Georgios Androutsopoulos, Antonio Bianchi
https://arxiv.org/abs/2506.15648

deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses
Although Rust ensures memory safety by default, it also permits the use of unsafe code, which can introduce memory safety vulnerabilities if misused. Unfortunately, existing tools for detecting memory bugs in Rust typically exhibit limited detection capabilities, inadequately handle Rust-specific types, or rely heavily on manual intervention. To address these limitations, we present deepSURF, a tool that integrates static analysis with Large Language Model (LLM)-guided fuzzing harness generat…

I've finally finished the #rustlings #rust challenge! :ablobcheer:

Brian Schottenheimer: Knock the Rust Off | Dallas Cowboys 2025 https://www.youtube.com/watch?v=DjmXqj9X4S0

Ik moest maar weer eens van de (betrekkelijke, want Randstedelijke) rust in mijn stadstuin gaan genieten. Dat schijnt vandaag te kunnen, ondanks de volgens sommigen koude, natte, zomer.

Don't Unwrap Options: There Are Better Ways #Rust
https://corrode.dev/blog/rust-option-handling-best-practices/

Rust brings day-to-day happiness. 🥰 🦀
https://www.infoq.com/news/2025/07/meta-rust-dx/

From C to Rust: inside Meta’s Developer-Led Messaging Migration
Meta has begun rewriting its mobile messaging infrastructure in Rust, gradually replacing a legacy C codebase that engineers say had become increasingly difficult to maintain and frustrating to work w

from my link log —
Pattern matching and exhaustiveness checking algorithms implemented in Rust.
https://github.com/yorickpeterse/pattern-matching-in-rust
saved 2025-06-02

#Rust offers different ways to initialize compile time-initialized variables. Recently, I had to create a runtime-initialized variable: existing approaches don’t work in this case. I want to describe multiple ways to achieve it in this post.
http…

#Rust is mummy's new favorite, hm? 🤔
Ubuntu 25.10 Replaces sudo With a Rust-Based Equivalent
https://thenewstack.io/ubuntu-25-10-replaces-su…

from my link log —
Bringing runtime index checks to compile time in Rust.
https://ktkaufman03.github.io/blog/2023/04/20/rust-compile-time-checks/
saved 2023-04-27

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

Beyond C/C : Probabilistic and LLM Methods for Next-Generation Software Reverse Engineering
Zhuo Zhuo, Xiangyu Zhang
https://arxiv.org/abs/2506.03504 http…

Beyond C/C++: Probabilistic and LLM Methods for Next-Generation Software Reverse Engineering
This proposal discusses the growing challenges in reverse engineering modern software binaries, particularly those compiled from newer system programming languages such as Rust, Go, and Mojo. Traditional reverse engineering techniques, developed with a focus on C and C++, fall short when applied to these newer languages due to their reliance on outdated heuristics and failure to fully utilize the rich semantic information embedded in binary programs. These challenges are exacerbated by the limi…

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

So, making slow progress as I learn `rust` things. Instead of going with my usual `union`/`struct` combination in C, I'm resorting to not overflowing/underflowing primitive types and doing things more safely. This snippet of code took far longer than it should've, but it gets the job done.
#programming

Design and Reliability of a User Space Write-Ahead Log in Rust
Vitor K. F. Pellegatti, Gustavo M. D. Vieira
https://arxiv.org/abs/2507.13062 https://arxiv.…

Design and Reliability of a User Space Write-Ahead Log in Rust
Write-ahead logs (WALs) are a fundamental fault-tolerance technique found in many areas of computer science. WALs must be reliable while maintaining high performance, because all operations will be written to the WAL to ensure their stability. Without reliability a WAL is useless, because its utility is tied to its ability to recover data after a failure. In this paper we describe our experience creating a prototype user space WAL in Rust. We observed that Rust is easy to use, compact and has 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

from my link log —
Some pitfalls of safe Rust.
https://corrode.dev/blog/pitfalls-of-safe-rust/
saved 2025-04-04 https://

Pitfalls of Safe Rust | corrode Rust Consulting
When people say Rust is a “safe language”, they often mean memory safety. And while memory safety is a great start, it’s far from all it takes to build robust applications. Memory safety is important but not sufficient for overall r…

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 —
Thoughts on hashing in Rust.
https://purplesyringa.moe/blog/thoughts-on-rust-hashing/
saved 2024-12-13

Thoughts on Rust hashing
In languages like Python, Java, or C++, values are hashed by calling a “hash me” method on them, implemented by the type author. This fixed-hash size is then immediately used by the hash table or what have you. This design suffers from some obvious problems, like: How do you hash an integer? If you use a no-op hasher (booo), DoS attacks on hash tables are inevitable. If you hash it thoroughly, consumers that only cache hashes to optimize equality checks lose out of performance.

#OpenAI #Codex CLI Goes Native with #Rust Rewrite 🚀
⚡ Rewritten from #TypeScript to

CISA just published Thorium - and it's written in Rust. 🥳✨🦀
https://github.com/cisagov/thorium

GitHub - cisagov/thorium: A scalable file analysis and data generation platform that allows users to easily orchestrate arbitrary docker/vm/shell tools at scale.
A scalable file analysis and data generation platform that allows users to easily orchestrate arbitrary docker/vm/shell tools at scale. - cisagov/thorium

🇺🇦 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

Okay, not 100% satisfied over the Z80 flags implementation, but works perfectly well and mirrors what the CPU is doing. Used `mem::swap` to switch between the normal and "prime" set of flags and works exactly as expected. Things progress...
#rust #z80

from my link log —
Type-level bounded recursion in Rust.
https://catgirl.ai/log/typelevel-bounded-recursion/
saved 2025-05-26

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

from my link log —
Adding lookbehinds to Rust’s regex crate.
https://systemf.epfl.ch/blog/rust-regex-lookbehinds/
saved 2025-07-15

Adding lookbehinds to rust-lang/regex – SYSTEMF @ EPFL
An annotated guide to adding captureless lookbehinds to the Rust linear-time regex engine.

🎛️ Custom Controllers: Nuclear option for completely different workflows
while keeping shared business logic
🔧 Pattern works across languages - #Go #Rust #PHP all support interface-based customiz…

from my link log —
Lock-free Rust: how to build a rollercoaster while it’s on fire.
https://yeet.cx/blog/lock-free-rust/
saved 2025-05-16 https://

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Place Capability Graphs: A General-Purpose Model of Rust's Ownership and Borrowing Guarantees
Grannan, B\'il\'y, Fiala, Geer, de Medeiros, M\"uller, Summers

from my link log —
Diagnosing a double-free concurrency bug in Rust's unbounded channels.
https://materialize.com/blog/rust-concurrency-bug-unbounded-channels/
saved 2025-05-15

Diagnosing a Double-Free Concurrency Bug in Rust's Unbounded Channels
Explore how Materialize engineers diagnosed and resolved a rare concurrency bug in Rust's unbounded channels that led to undefined behavior through double-free memory errors.

🇺🇦 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 —
Zero-cost 'tagless initial' in Rust with GADT-style enums.
https://www.inferara.com/en/blog/rust-tagless-final-gadt/
saved 2025-06-03

I just saw someone at Aschaffenburg station with patches on their backpack: the Rust logo and Ferris. 🦀 🎒

from my link log —
faer: a general-purpose linear algebra library for Rust.
https://docs.rs/faer/
saved 2025-03-24 https://dotat.at/:/ILSBW.…

from my link log —
Postgres extensions in Rust.
https://depth-first.com/articles/2021/08/25/postgres-extensions-in-rust/
saved 2021-08-29

Postgres Extensions in Rust
Opening a new path to high-performance, domain-specific database applications.

sad :3 https://github.com/qilingframework/qiling/issues/253
someone's gotta retry ^^

Rewrite in Rust · Issue #253 · qilingframework/qiling
Python is a poor choice for anything remotely complex, especially that affects the execution times like emulation. Projects like Angr and Miasm met a bottleneck of Python, it's slowness, GIL, memor...

from my link log —
Re-implementing the Nix protocol in Rust.
https://tweag.io/blog/2024-04-25-nix-protocol-in-rust/
saved 2024-05-06

Re-implementing the Nix protocol in Rust
We re-implemented the nix remote protocol, declaratively

I just applied for a Rust developer/promoter position at @… - wish me luck y'all! 🥳✨🦀

from my link log —
A Rust API inspired by Python, powered by Serde.
https://ohadravid.github.io/posts/2025-05-serde-reflect/
saved 2025-05-15

A Rust API Inspired by Python, Powered by Serde
Years ago, I worked on reimplementing some Python code in Rust and needed to adapt Python’s dynamic reflection capabilities (aka __getattr__) to the strict and …

Maximize Your #Rust Enums With Strum
https://www.youtube.com/watch?v=NoIqPYLpCFg

»Static Site Generators - Hugo:
Hugo ist einer der beliebtesten Open-Source-Generatoren für statische Websites. Mit seiner erstaunlichen Geschwindigkeit und Flexibilität macht das Erstellen von Websites mit Hugo wieder Spaß.«
Ich pers. bevorzuge Zola, da ich ein Rust Fanboy bin und es extrem schnell ist aber im allgemeinen sind jegliche statische Seiten in den meisten Fällen absolut ausreichend.
🌐

Serie: Static Site Generators - Hugo (Teil 1)
Hugo ist einer der beliebtesten Open-Source-Generatoren für statische Websites. Mit seiner erstaunlichen Geschwindigkeit und Flexibilität macht das Erstellen von Websites mit Hugo wieder Spaß.

from my link log —
comrak: a CommonMark and GFM compatible Markdown parser and renderer in Rust.
https://github.com/kivikakk/comrak
saved 2025-03-31 …

GitHub - kivikakk/comrak: CommonMark + GFM compatible Markdown parser and renderer
CommonMark + GFM compatible Markdown parser and renderer - kivikakk/comrak

from my link log —
Optimizing a simple expression parser in Rust.
https://rpallas92.github.io/math-parser/
saved 2025-07-10 https://

from my link log —
LALRPOP: a parser generator for Rust.
https://smallcultfollowing.com/babysteps/blog/2015/09/14/lalrpop/
saved 2025-03-31

from my link log —
Sneak peek: A new ASN.1 API for Python.
https://blog.trailofbits.com/2025/04/18/sneak-peek-a-new-asn.1-api-for-python/
saved 2025-04-18

Sneak peek: A new ASN.1 API for Python
We’re working on integrating an ASN.1 API into PyCA Cryptography, built on top of the same Rust ASN.1 implementation already used by Cryptography’s X.509 APIs.

from my link log —
A survey of every iterator variant in Rust.
https://blog.yoshuawuyts.com/a-survey-of-every-iterator-variant
saved 2025-02-28

from my link log —
facet: type reflection, serialization, deserialization — know the shape of your types in Rust.
https://github.com/facet-rs/facet
saved 2025-04-09

from my link log —
Towards fearless SIMD in Rust, 7 years later.
https://linebender.org/blog/towards-fearless-simd/
saved 2025-03-30