List of videos

Rust is fundamentally designed to be a safe programming language. While most code can be written safely, there are occasions when using unsafe code is necessary. The goal of this talk is to encourage you to write only safe Rust code. However, in the rare event that you absolutely need to use unsafe Rust, we will discuss strategies to help you maintain Rust's safety guarantees. This can be achieved by employing the right tools, techniques, and best practices.

You’re in an all-out war for attention from your users and customers. Creating meaningful, personalised experiences is critical to give your website or app the best chance to capture the interest of visitors. However - optimising machine learning models and scaling your infrastructure to support this is difficult and can be very costly. What if we reimagined content recommendation using the web technology we have available today? In this talk, we will explore the power of moving logic to the edge, demonstrating a unique implementation of content recommendation which would not be possible without the performance and reliability guarantees of Rust.

Rust developers are well-acquainted with fearless concurrency, which is helpful for efficient servers and I/O-bound applications. However, there's another facet to Rust – parallelism. In this talk, we will demonstrate how parallel programming in Rust is not only accessible but also could make your programs blazingly fast. We will explore the most popular parallel programming libraries and techniques, how to overcome common challenges with parallel data processing, and how Rust solves them safely and efficiently. You will learn how to utilize hardware parallelism with SIMD instructions and how to make your programs aware of varying hardware capabilities at runtime. Finally, we will touch on the evolving state of GPU programming with Rust.

Web development has coalesced around a handful of JavaScript frameworks that make it possible to render an application to HTML on the server, then convert it into an interactive app in the browser. But JavaScript is not the only way to run interactive code in the browser. The last few years have seen the rise of a small number of Rust web frameworks that are near feature parity with their JS equivalents, allowing users to write entire applications without leaving Rust. In some areas, Rust frameworks perform identically with their JS cousins. In others, like server performance, they have always excelled. Some features like bundle splitting and lazy loading have been missing from the Rust picture for years—but are now on the verge of complete implementations This talk will consider the cutting edge of frontend web framework development, in JavaScript and in Rust. Focusing especially on the work done in building recent versions of Leptos and Dioxus, we'll consider: Is there a realistic future for web applications written end to end in Rust?

In 2024, Rust decided to make Rust in the Linux Kernel one of the three flagship goals of the Rust project. It is now 2025 and we’ve reached the conclusion of the goal. How did it go? In this talk, you will hear about which features we stabilized, but also about what it takes to stabilize a feature in the Rust language. You’ll also hear about how we are now doing some things better than the C compilers, and how this has helped our perception in the Linux Kernel community.

This talk will present how Rust’s lack of a standard Application Binary Interface (ABI) can be solved. The lack of a standard ABI in Rust means that the whole source code has to be available to the compiler. While this is less of a problem for applications, it makes writing shared libraries in Rust impossible, unless they expose items through the Foreign Function Interface (FFI) or, in other words, the C ABI. This renders Rust's type and memory model useless. This talk will explore the ways in which WebAssembly Components can be used to build extension libraries in Rust avoiding the FFI and exposing rich data types and provide a safe memory mode. It will provide insights into several ways in which widely used Rust projects, such as Zed and Zellij have implemented extensions.

2024 shone an even brighter spotlight on the issue of supply chain security. Understanding the dependencies that we build on top of is crucial when building software that is both secure and trustworthy.In this talk, I'll discuss the tools and techniques that are available to Rustaceans to understand their dependencies, evaluate them both from security and sustainability perspectives, and make informed decisions when building with Rust. I'll also touch on work that is taking place — across many organisations, including the Rust project itself, the Rust Foundation, OpenSSF, and the broader FOSS ecosystem — that is helping here, both for Rust specifically and more broadly for all users of FOSS.

Realising the full potential for Rust/Python interop is an always-evolving research adventure. I'll share some favourite things I've learned while contributing to PyO3: Rust techniques and proc-macro dark magics for building user-focussed APIs without compromising on performance. We'll close with challenges of Rust/Python interop and possible future solutions.

Gartner stated that by 2030, synthetic data will completely overshadow real data in AI models. But how about other applications? Synthetic data can be generated either by rules and statistics or AI. This talk will start by outlining the main challenges facing big data, collection size, bias, processing and storage etc, with examples from the fields of medicine and biology. All these problems create overwhelm for people and resources. One clear factor is the inefficiency of repetition. We should focus on valuable data, clean data, and find relevant data, focus on key data. Synthetic data can help us with data privacy, GDPR, ethics and bias. There is a potential to create clear cost and performance savings. Synthetic data could even have the potential to store data in a way that as much as you like can be generated on the fly, you only need to store and secure the model. Synthetic data has Speed – rapidly prototype without waiting for real data, Security – safeguard sensitive information and Scalability – scale effortlessly. Rust’s ecosystem can complement the development and use of synthetic data in varied applications. Let’s focus big data on what matters.