Rust Search
Find the best content on Rust, curated by the community; a
search engine for Rustaceans.
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.
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
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.
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?
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.
This is a story of how I used a few readily-available Open Source tools to achieve huge optimizations in zbus, a pure Rust D-Bus library. This was long journey but gains were worth the efforts. I will go through each single bottleneck found, how it was found and why it was a bottleneck and how it was optimized away. While attending this talk will by no means make you an expert in optimizations, it is my hope that by you will be able to relate to some of bottlenecks or solutions I will present ("hey", I also do that in my code!") and learn from my experience. Maybe afterwards, you can suggest an even better solution? Moreover, if you don't already have any experience with profiling and optimizations, this talk should be a good introduction for that.
Rust's type system can feel complicated and overwhelming. However, crates like Bevy and Divan take advantage of the advanced features to deliver simpler developer experiences. This talk will demonstrate how to create these easy-to-use APIs by covering advanced techniques like polymorphism, type states, and conditional typing.
Rust's references adhere to a strict "one exclusive XOR many shared" model, which gives the language much of its greatest safety guarantees. Reborrowing is a feature that seems on surface to break this rule: An exclusive reference can be turned into shared references and those shared references can be used together with the exclusive reference as long as these are all used as if they were shared references. Only once the exclusive reference is used as exclusive, all the derived or "reborrowed" shared references are invalidated. The XOR rule is upheld, but in a way that breaks a literal reading of the rule. Usually reborrowing is used temporarily but what if we make it our modus operandi? This talk explores using and slightly abusing reborrowing and comes out the other side with an awkward but functional safepoint garbage collector built upon reborrowing a ZST marker and a whole load of typed indexes. The garbage collector is part of the Nova JavaScript engine. https://trynova.dev/
Everyone loves the terminal! It's simple, efficient, and fast — almost everything the web is not. What if I told you it is possible to build terminal-like web applications with Rust and vice versa? Join me in this talk, where we explore the future of the terminal and the web and how the Ratatui ecosystem is bringing these two worlds together. We will take a look at example Rust projects that achieved this, their implementation, and the challenges that we are facing. Get ready to be visually impressed!
Huge graphs, from billions to trillions of nodes and arcs, are more and more common in modern data-intensive applications. Graph compression techniques allow loading and manipulating such graphs into main memory of either high-end workstations or commercial-grade servers, depending on graph size. In this talk, we report about webgraph-rs, a recent clean-slate Rust re-implementation of WebGraph, a state-of-the-art graph compression framework, formerly implemented in Java. webgraph-rs comes as a series of interconnected Rust crates of general interest, including high-performance bit streams, zero-copy (de)serialization, constant-time measurement of heap size for large data structures, and high-performance implementation of succinct data structures . Using webgraph-rs one can load graphs such as the Software Heritage Merkle DAG (about 0.6 trillion edges ) in less than 200 GiB of RAM and visit it in a few hours with a single core.
I wanted to have a watt-meter that I could plug into my electrical supply to ensure I didn't trip the max rating at my granparents' when charging an EV. I could have bought a "smart-balancing charger" to handle this for me, but I wanted to keep costs low and learn embedded Rust. On this talk I'll go over how to manage side-projects, keep objectives reasonable and the technical details and how easy it is to build an API backend using Rocket, handling serialization and parallelism, as well as using Rust on the embedded device, including flashing, demonstrated how this is all integrated into cargo as a build tool. Wattmeter code: https://github.com/ssaavedra/esp32-amp-sensor Backend: https://github.com/ssaavedra/amp-sensor-backend
augurs is a new library for time series analysis (think forecasting, outlier detection, clustering, and more) written in Rust, with bindings available for Javascript and Python. It includes functionality borrowed from both Python and R libraries, plus some more novel ideas. Come and learn about what it can do, as well as: choices made when porting algorithms from different languages techniques used for profiling and optimizing ML code in Rust tradeoffs when creating Javascript/WebAssembly bindings what kind of performance and usability gains to expect
The latest version of neo4rs—a Rust driver for the Neo4j graph database developed under the "Neo4j Labs" incubator—changes its API for reading data to use serde. Serde is a library for serialization and deserialization of any user-defined type into and from a number of different data formats. Most material about serde focuses on the user-defined types, though for this talk, I want to present the—still ongoing—journey of building a new bolt dataformat for serde. Follow me down the rabbit hole and peek under the hood of serde to show how the various types and traits interact, what gotchas and caveats await and how to craft an API that is more than just 1:1 struct <--> data mapping.
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.
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.
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.
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.
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.
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.
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.
"The major philosophic difference between Rust today and Swift-as-I-envision-it is that Rust forces you to think about ownership everywhere, but Swift-..."