Rust Search

In this talk I share the motivation, goals, and architecture of my new project Aurae. Informed by my experience of operating large production platforms I discuss my thesis of how bringing deliberate runtime controls to a node will unlock a new generation of higher order distributed systems. The audience walks away with an in-depth understanding of the current state of affairs Rust and the Aurae runtime project. We learn about my journey to Rust from working with Go in Kubernetes. I am an accomplished Go engineer who has made the jump into Rust and I believe my story is worth compiling and sharing with FOSDEM. I believe there will be many like me in the future.

Follow me as I walk through my journey of building lnx, a distributed search engine written in Rust akin to Elasticsearch or Algolia that aims to be faster and more efficient using tantivy. I cover the challenges and solutions I encountered while developing lnx over the last year, the tradeoffs made and how you can build your own search engine using the tools the Rust ecosystem provides.

Quickwit is an opensource distributed search engine. The most challenging component of a search engine is its indexing pipeline. It takes a stream of JSON documents, processes them in batches, and emits index artefacts we call splits. We needed our implementation to be robust, testable, observable, and efficient... But even more importantly, our code had to be easy to work with. I will explain why we chose to develop our own actor framework and discuss the unique features of our implementation.

In this talk, I will present zbus, a D-Bus crate written from scratch. D-Bus is an inter-process communication mechanism, available and used on almost all modern Linux desktops and many embedded systems. I will start with why I felt the need to take this huge undertaking on my shoulders, followed by the design goals, the challenges faced and how I overcame them during the development.

TLDR: Even though VM Introspection has lots of applicable areas, it has not gained it's full potential yet, due to a fragmented ecosystem. This talk will quickly review the state of the technology and we will present our solution: a Rust library aiming at solving the issue mentionned before, in order to make VMI a commodity in the future for apps developers, enabling them to do: Advanced Malware Analysis Live-Memory Analysis Complex debugging OS Hardening Snapshot-based fuzzing Targeting any VMI compatible hypervisor or emulator. From stealth malware analysis to OS hardening through fuzzing, virtual machine introspection is expanding the possibilities offered by our hypervisors, shifting our view of virtual machines, from opaques containers to fully transparent and instrumentable systems. Today the VMI ecosystem is made of a multitude of applications, targeting one hypervisor or emulator, with their own semantic library. (Examples includes Drakvuf, PANDA, PyREBox, icebox, etc...). If we want to make the most out of VMI in the future, we need to build the libraries that will unify this ecosystem and let the developers focus on what matters: building quality VMI apps. This is where libmicrovmi comes into play. It aims to solve this problem, by providing a core, foundation library, written in Rust, to be cross-platform, hypervisor-agnostic and emulator-agnostic, on top of which higher-level libraries and apps can rebase. Rust makes a lot of sense for VMI for 2 main reasons: Rust is safe: considering that we are processing untrusted input from virtual machines, we cannot allow any crash or exploitation in the introspection agent. Also one of our use case is OS hardening, which needs an excellent level of trust Rust is fast: processing an event requires to pause the VCPU. The longer the pause, the more delayed the guest execution will be, and when scaling to thousands of events per second this can dramatically influence how many breakpoints you are willing to put, especially on production systems. Speed matters. Therefore Rust is the de facto choice for VMI apps in the future, and we are building it today, by providing libmicrovmi, a new foundation for VMI. Libmicrovmi has drivers for: Xen KVM Hyper-V (in progress)

There was a huge progress in Rust tools for WebAssembly in the last year. Let's review some of the most noticeable changes. The talk is mostly about wasm-bindgen.

WebGPU is a new graphics and compute API designed from the ground up by a W3C community group. It's a successor to WebGL, which also has a chance to become a standard on native platforms. We are going to talk about the API itself as well as our Rust-based implementation "wgpu".

The Mercurial version control system now has an option for running Rust code to improve performance. In this talk we will explore the challenges of using Rust efficiently inside a performance-sensitive Python project with more than 10 years of backwards compatiblity.

Over the last decade, Redis has become one of the most popular NoSQL DBs delivering on the promise of high throughput and low latency. What started as a pure C code base is gradually being augmented with Rust due to the trifecta of safety, concurrency, and speed. A primary example is thre RedisJSON module which turns Redis into a document DB. The talk outlines the principal architecture of the re-implementation of RedisJSON, the challenges encountered and the solutions for these. The focus is on the practical aspects rather than conveying theoretical knowledge. A comparison with other open source document DB concludes this presentation, concentrating on latency and throughput aspects.

sled is an embedded database that takes advantage of modern lock-free indexing and flash-friendly storage. rio is a pure-rust io_uring library unlocking the linux kernel's new asynchronous IO interface. This short talk will cover techniques that have been used to take advantage of modern hardware and kernels while optimizing for long term developer happiness in a complex, correctness-critical Rust codebase.

rav1e is a fast AV1 encoder written in rust (and plenty of assembly), released monthly. Since the 0.1.0 release we try to make sure we provide an adequate speed or quality boost compared to the previous. This talk is about what tools are available in the rust ecosystem and what are the practices that worked best for us.

This talk will introduce the Muses project, which applies programming language theory and practice, physical computing, networking, and musicial theory to design and implementation of Digital Musical Instruments. Rust is a key ingredient in the Muses project, providing a robust and performant foundation for cross platform, desktop, and embedded system development. The talk will give a brief introdution to Muses project as a whole and then focus on the use of Rust in developing a selection of very different components in the system and its benefits for these wildy varing use cases. Demos of the Digitial Musical Instruments with Rust at their heart will shown through out the talk.

Rust compiler comes with a few tools, rustdoc is one of them. It is THE standard rust tool to generate documentation for your crates.

Rust is a language with a healthy ecosystem and a strong developer base. With built-in dependency management it's easy to build and install new programs even for those who have never used the language. But how is its adoption among Linux distros? Come with me as we figure out how best to package rust libraries and binaries in Linux distributions which demand total control over dependency management.

A talk about cargo-deny, why we created it, and how it helps us manage our dependencies in the long term.

Complying with license obligations can incur a lot of hurdles. This results in developers skipping compliance or failing to achieve correct compliance. To compound this, package authors sometimes fail to describe the license of their package clearly or omit license information of included files. ClearlyDefined is a community curated repository of discovered license information for Crates packages, among other types. This talk will cover: the importance of the license obligations of the dependencies of your Rust package, tool, or application. How to discover the license information of those packages. And demonstrate some Cargo compatible tooling that allows automated license recordkeeping and notice file generation as a part of your CI system.

This talk is an experience report on my safe rust wrapper for a c++ RDMA library^1. RDMA enables the network hardware to directly read and write to memory, without the cpu's involvement. My rust implementation ensures that memory regions are exclusively either owned by client code, or enqueued for use by the underlying RDMA stack. This makes sure that data cannot be changed by hardware while owned by safe rust code, and that user logic cannot mutate data while it is being read by the card. In this talk, I'll go over the design of the library and how it embraces rust's ownership transfer semantics. In rust's safe/unsafe model, the burden of upholding safety guarantees at the unsafe boundary is entirely up to the programmer who's writing the wrappers. These guarantees are not formally specified, which makes it harder to reason about the safety of the wrapped unsafe logic; this issue is compounded by the fact that undefined behaviour can seep into safe rust from unsafe code that doesn't match rust's expected semantics. I'll discuss how this improves ergonomics in safe code, but requires careful engineering of unsafe code because it doesn't allow the programmer to reason locally.

There is a lot of existing code and libraries written in C++. The cpp crates allow to embed easily C++ within your rust code so you can call interoperate with the existing C++ code. In this talk, we will see how to use this create and how it works behind the scenes. As an example, we will look at the qmetaobject which expose Qt api to Rust.

Many commonly used libraries from other languages, especially GUI toolkits, make use of Object Oriented Programming (OOP). While Rust has support for many of the OOP concepts in one way or another, there is no easy way for implementing subclassing or inheritance. The topic of this talk will be how to implement subclassing and inheritance in safe Rust, based on the GObject C library. The GObject library is providing Java/ObjectiveC-style OOP features to C. It is used by the GTK+ UI toolkit, the GStreamer multimedia framework and various GNOME libraries. Apart from reasons why you would want to do this in Rust, this talk will cover the new implementation for subclassing that was recently integrated into the existing GLib/GObject, GTK+ and GStreamer bindings. These bindings allowed usage of existing GObject types before, but didn't provide any features to create new GObject types. In addition to usage of the subclassing implementation, a couple of details about the implementation will also be explained. Last but not least, an outlook in the future will be given for how one can take this even one step further with procedural macros to allow writing code that looks very close to Java or C#. This talk will not only be interesting for those who want to make use of GTK+ or GStreamer and extend those libraries, but will also cover various aspects about safely interfacing with C libraries from Rust and all kinds of type tricks to teach the Rust type-system about subclassing and making use of the type-system for enforcing various invariants at compile-time.

A tour on newest and future developments for gtk-rs, the Rust bindings to GTK+.