Tootfinder

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…

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.

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…

Have expertise with functional programming, interpreters, and Web technology? Like Rust, wasm, etc.? Looking for a job with a great team? Please see this job ad, and share with others you might know!
https://zoo.dev/jobs/4619187005?gh_src&gh_jid=4619187005

Zoo: Software Engineer, Language Development
A remote position now hiring at Zoo

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 —
Index 1,600,000,000 keys with finite state automata and Rust.
https://blog.burntsushi.net/transducers/
saved 2021-08-21 https://

Rython?
https://www.phoronix.com/news/Proposal-Rust-In-CPython

Python Developers Looking At Introducing The Rust Programming Language In CPython
A proposal has been raised by two CPython core developers to introduce the Rust programming language to CPython

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 …

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…

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

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new
[1/1]:
- Petri Nets-based Methods on Automatically Detecting for Concurrency Bugs in Rust Programs
Kaiwen Zhang, Guanjun Liu

Who would have thought that creating a programming language for rapidly developing, deploying and abandoning lots of packages would have lead to this…
"Forking confusing: Vulnerable Rust crate exposes #uv #Python packager"
#RustLang #security

Beyond Language Barriers: Multi-Agent Coordination for Multi-Language Code Generation
Micheline B\'en\'edicte Moumoula, Serge Lionel Nikiema, Alb\'erick Euraste Djire, Abdoul Kader Kabore, Jacques Klein, Tegawend\'e F. Bissyande
https://arxiv.org/abs/2509.19918

Beyond Language Barriers: Multi-Agent Coordination for Multi-Language Code Generation
Producing high-quality code across multiple programming languages is increasingly important as today's software systems are built on heterogeneous stacks. Large language models (LLMs) have advanced the state of automated programming, yet their proficiency varies sharply between languages, especially those with limited training data such as Rust, Perl, OCaml, and Erlang. Many current solutions including language-specific fine-tuning, multi-agent orchestration, transfer learning, and intermediate…

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 —
A C to Brainfuck compiler written in Rust.
https://iacgm.pages.dev/posts/c2bf/
saved 2025-10-13 https://dotat.at/:/OEPJB.html

Upcoming next week:
3rd European RISC-V #Firmware and #Embedded #Rust #Workshop by EDA Centrum at V…

End-to-end Compositional Verification of Program Safety through Verified and Verifying Compilation
Jinhua Wu, Yuting Wang, Liukun Yu, Linglong Meng
https://arxiv.org/abs/2510.10015

End-to-end Compositional Verification of Program Safety through Verified and Verifying Compilation
Program safety (i.e., absence of undefined behaviors) is critical for correct operation of computer systems. It is usually verified at the source level (e.g., by separation logics) and preserved to the target by verified compilers (e.g., CompCert), thereby achieving end-to-end verification of safety. However, modern safe programming languages like Rust pose new problems in achieving end-to-end safety. Because not all functionalities can be implemented in the safe language, mixing safe and unsaf…