Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
Discover how the Rust programming language and the ROS 2 framework are transforming robotics development in this talk. Everything can be found in this repository: https://github.com/roboticswithjulia/ros2_rust_workshop. Participants will dive into the fundamentals of the ROS2 Rust package: https://github.com/ros2-rust/ros2_rust. The session will highlight Rust's performance and safety benefits, its integration with ROS 2 for robotic systems, and practical implementation techniques. Through guided exercises, attendees will learn how to program and control a quadruped robot using Rust within the ROS 2 framework, gaining insights into the challenges of robotic systems and how this powerful combination addresses them effectively. This talk is ideal for developers looking to enhance their robotics expertise using a modern programming language and a robust middleware. Whether you're new to Rust, ROS 2, or seeking to deepen your robotics knowledge, this session offers a unique opportunity to build robust and efficient systems for the robots of tomorrow.
Rewrite it in Rust has been a theme (and meme) for almost as long as Rust exists. But what actually makes a rewrite work? At first glance you would think that just making a memory safe implementation of a protocol, library or program should be enough. But in practice there are many factors that make an implementation work. Our work on, among others, ntpd-rs, zlib-rs and sudo-rs gave us some insight into that. Both from outside the Rust community: How to identify projects that could benefit from a rewrite? What do you need to do to get your Rust project accepted in a wider community? How do you get your project known? How do I get my project distributed? But also from inside the Rust community: Which crates do can I use as dependencies? What if my preferred crate name is already in use? Should I publish on crates.io? Do I offer a Rust interface for my crate?
PostgreSQL's extensibility is legendary, and a revolution is brewing: Rust is emerging as the new gold standard for writing robust, performant database extensions, with the promise to make them safer, faster, and more maintainable than ever before. In this hands-on session, we'll discover the PGRX framework through 4 practical examples showcasing: Memory safety guarantees A fully managed development environment Access to Rust's vast ecosystem of libraries Seamless PostgreSQL integration Based on my experience rewriting the PostgreSQL Anonymizer extension from C to Rust, I'll share the lessons learned along the way. Whether you're a seasoned C developer, a rustacean, or a new to PostgreSQL extension writing, this talk will equip you with the knowledge to leverage Rust's powerful features in your next database projects.
In the realm of operating systems, the heart of performance lies in the CPU scheduler: a critical component responsible for managing the execution of tasks on a system. Exploring and customizing CPU scheduling policies has long been the realm of few highly specialized kernel developers, leaving most developers and researchers without the tools to tailor system performance to their unique needs. What if we could unlock this potential and make it accessible to a wider audience, from game developers, cloud service providers to AI researchers and performance engineers? With sched-ext [1], eBPF and Rust, this vision can become a reality, enabling the development of multiple dynamic specialized schedulers, tailored to specific system workloads and architectural topologies, that can be loaded and managed as regular user-space programs [2]. [1] https://sched-ext.com/ [2] https://github.com/sched-ext/scx/tree/main/rust/scx_rustland_core
In 2023 a small set of developers set out to work on a Rust-based framework for Arch Linux Package Management (ALPM) - see talks from FrOSCon 2023 and All Systems Go! 2023. After months spent on securing funding for the work ahead, in late 2024 the project has picked up work again in an extended capacity. In this talk we will explore the technical challenges this project seeks to overcome and provide an overview of the work ahead. This will cover topics such as the writing of specifications for custom file types, dedicated metadata file parsers and writers, the design of libraries for package handling, the more generic verification of digital signatures for distribution artifacts and the integration with existing and upcoming package building and package management infrastructure.
FOSDEM 2025 is over ...but not quite! The treasure hunt still lies unsolved so why not give it a try now online? Feedback Please let us know about your FOSDEM experience at feedback@fosdem.org. All your feedback, good or bad, and suggestion...
This work is licensed under the Creative Commons Attribution 2.0 Belgium Licence. To view a copy of this licence, visit http://creativecommons.org/licenses/by/2.0/be/deed.en or send a letter to Creative Commons, 444 Castro Street, Suite 900...
In theory, semantic versioning (SemVer) is simple: breaking changes require major versions. SemVer rules do not change over time. Crates always adhere to SemVer. Careful coding is enough to avoid accidental breaking changes. None of those statements are true! In practice, SemVer is complex and accidental breakage is common: 1 in 6 of the top 1000 Rust crates has violated semantic versioning at least once, frustrating both users and maintainers alike. If you write Rust but don't have the time for a PhD in SemVer, this talk is for you. We'll take a practical look at SemVer in Rust: what it buys us, how Rust's features lead to strange SemVer edge cases, and how we can prevent accidental breakage using a SemVer linter called cargo-semver-checks.
This talk will show you how to write your own rust linter using the rustc_tools crate which allows you to have access to the rust compiler API. It can be quite useful if you need specific lints for a project and cannot add them to clippy. It will explain how the compiler API works and give a small example at the end showing it in action.
gccrs is an alternative implementation of a Rust compiler currently being developed. It aims to become a fully fledged Rust compiler, and hopes to share as much code as possible with the official Rust compiler in order to guarantee correctness and avoid damage on the Rust ecosystem. But how do we plan to integrate Rust components to the GCC codebase, and what sort of components will we reuse? This talk will explore the future of the project, as well as some of the challenges surrounding compilers, and the very silly sounding but real problems of bootstrapping and dogfooding. We will explore the stack of rustc crates that we leverage, how we use them together, and how they will play a part once the compiler has advanced further.
This talk presents a case study in taking a security-focused application to the next level by modifying the Rust compiler to target a capability-based architecture. We will discuss CHERI, a system that enables hardware enforcement of safety constraints at runtime using capabilities, and how we have added support for CHERI to the Rust compiler in order to improve the security of CyberHive Connect, an application that implements an end-to-end encrypted mesh network. Connect can already boast a very high level of security when we consider the protocols it uses, and we can argue that the application itself has many potential vulnerabilities eliminated by being written in Rust. However, just like most real world applications, Connect needs to make use of unsafe code in areas such as the interface with the underlying operating system. This exposes an attack surface in the form of code that the compiler can't guarantee will be safe at runtime. If, however, we make modifications to the Rust compiler to support transferring knowledge about pointer provenance, bounds and other access restrictions to CHERI's capability-based runtime enforcement, then in many cases we should be able to eliminate the potential for unsafe situations to occur. This talk will demonstrate what we have managed to achieve in terms of producing a modified Rust compiler that can target CHERI architectures. We will give an overview of what problems were solved by doing this and how we worked towards getting our real world Rust application running on CHERI.
Software engineers choose Rust for its safety and performance baseline. Wizards use Rust's dark arts to improve performance by chanting cursed unsafe-yet-sound expressions. Whether you’re an engineer or a wizard, this talk will give you the tools and best practices to correctly measure and explore Rust’s performance claims against your projects. And wizards will learn when the performance benefits are worth risking nasal demons with unsafe code.
Rust provides unsafe language features to interact with hardware or call into non-Rust libraries. However, this shifts responsibility for ensuring memory safety to the developer. Failing to do so may lead to memory-safety violations in unsafe code, which can violate the safety of the entire application. In this talk, we explore in-process isolation with Memory Protection Keys as a mechanism to shield safe program sections from safety violations that may happen in unsafe sections. Our approach is easy to use and comprehensive, as it prevents heap and stack-based violations. We further compare process-based and in-process isolation mechanisms and the necessary requirements for data serialization, communication, and context switching. We specifically explored various Rust serialization crates such as Abomonation and bincode. Our results show that in-process isolation can be effective and efficient, permits for a high degree of automation, and also enables a notion of application rewinding where the safe program section may detect and safely handle violations in unsafe code. However, even for modestly sized arguments, the context switch cost starts to get dominated by the cost of data transfer between domains. Here, the Rust data serialization method used can significantly impact performance and thus, it is crucial to optimize it for the use case at hand. We open-source our prototype and experimental evaluation data under a BSD license on GitHub: https://secure-rewind-and-discard.github.io/
In the right hands, Rust is an exceptionally powerful language. Yet, I frequently observe similar mistakes in Rust programming: treating it like C or Java and not fully utilizing its unique features. I've concluded that poor Rust coding often falls into a few distinct categories, which I've termed the '4 Horsemen of Bad Rust Code': Overengineering, Simplistic Design, Premature Optimization, and Neglect of Documentation and Testing. This talk will delve into these antipatterns and offer strategies to avoid them, aiming to share practical tips for writing more ergonomic and effective Rust code. During the talk, we will gradually refactor a Rust code example, transforming it from a less optimal version to a more idiomatic and efficient one.
Have you ever wondered how terminal user interface applications are built? Join me in this talk as we explore Ratatui which aims to provide a wide range of widgets to make it possible to design beautiful interfaces and push the limits of the terminal using Rust.
I wrote my first emulator while learning Rust. Then, I wanted to make it available on the universal platform, the web. Using WASM, we'll see how to port a desktop app in pure Rust to a webapp using WASM. We'll survey the WASM ecosystem: tools, crates, and share tips and hurdles found along the way. Most native languages nowadays can be compiled to WASM, and Rust is no exception. Using an emulator written in pure Rust, we'll explore the challenges of porting a desktop Linux app to the web platform. How hard can it be ? Following through the outline of the emulator, we'll go step by step, and expose which crates make that easy, discover how mature is the Rust WASM ecosystem and tools we need to use to port an app.
Tower is a crate of “modular and reusable components for building robust networking clients and servers” widely used in prominent projects within the Rust ecosystem, including Hyper*, Axum, or Tonic. This ubiquity means Rust developers invariably engage with the Service trait, Tower's core abstraction, while working with these libraries. Despite its conciseness, reading and understanding code that abstracts over the Service trait proves challenging because of the heavy use of generics and intricacies of implementing non-boxed futures. This complexity raises the learning curve for beginner and intermediate Rust developers to become proficient in their favorite frameworks. In this talk, we will demystify the Service trait, explore practical examples from real-world codebases, and construct increasingly complex Tower layers from scratch. *Hyper actually relies on its own very similar hyper::Service trait.
Servo project have got a renewed activity since 2023 after a few slow years. One of the goals for this year has been making Servo a practical embeddable rendering engine, making easier to embed it in Rust projects. We’ve already come a long way in this area. A key achievement is our development of a minibrowser, which showcases how the Servo engine can be integrated. In this talk, the main focus will be on the embedding of Servo. We will dive into the technical aspects of the minibrowser, demonstrating how our developments have streamlined the process of embedding Servo, the challenges we’ve faced, and the solutions we’ve developed. Additionally, we will also talk about the future direction of Servo embedding in Rust projects.
Thunderbird has gone through a lot of changes recently, notably through the Supernova release, which was published in the summer of 2023, and is still rapidly evolving. Part of the work we have been doing in the background to enable this evolution is adding support for Rust to the Thunderbird code base. In this talk, we'll tell the story of how we achieved this and what lessons we learned along the way. We’ll also show how we’re using Rust to both improve the existing code architecture, and build new features for Thunderbird such as support for Microsoft Exchange.
Biospecimens and high-quality clinical data are essential for cancer research. At the same time, health data is highly sensitive with regards to data protection, hence, instead of centralizing all the data, federated information systems enable researchers to locate and work with data/biospecimens having certain characteristics, e.g. specimen type, diagnosis, and molecular markers, across hospitals, countries, or even continents. At the German Cancer Research Center (DKFZ), Germany’s largest biomedical research center, we develop, operate, and maintain such national infrastructures in hospitals and biobanks around Germany, Europe and the world, using 100% FLOSS. Recently, we have re-implemented and open-sourced key components in Rust with great benefits towards stability, safety and performance. In particular, we report on Beam, a distributed task broker for efficient communication across strict network environments, and Focus, a federated query dispatcher protecting patient privacy using differential privacy.
"References are a sharp tool and there are roughly three different approaches to sharp tools.
1. Don't give programmers sharp tools. They may make mis..."