Rust Nation UK 2025
19 - 20 Feb 2025 at The Brewery

Rust plays nicely with others. In this workshop, you will: Write C libraries and call them from Rust Write Rust code and call it from C Automate binding generation Connect to other languages (e.g. Go) Pitfalls of a lifetime: borrow-checking and avoiding footguns Connect C++ classes with Rust Strategies for code migration and testing

Abstract Python has served you well: you spun up a prototype and iterated quickly, keeping up with the evolving requirements of a successful product. Nonetheless, as time goes on, cracks are starting to show up: an endpoint is slower than it needs to be, a data processing job that took seconds now takes almost an hour, and your infrastructure bill is growing too fast compared to the size of your user base. Engineers are starting to whisper: is it time for a rewrite? Should we pause feature development to rebuild everything on more solid foundations? That's an option, but it's expensive. There's another path: rather than throwing away your entire Python codebase to start over, you analyse your application and isolate the performance-critical bits—the so-called "hot modules" where your application spends most of its time. You will rewrite those in Rust and package them as a Python native extension. This workshop will teach you how. We will cover the pyo3 crate, the subtleties of Python's Global interpreter lock, and typical examples that may arise in your daily Rust-Python interoperability work. By the end of the session, you will be well-equipped to seamlessly replace your slow Python modules with easy-to-use and blazingly fast Rust modules.

Getting started with async Rust is simple. Sprinkle some async here and .await there; it usually compiles and works. However, eventually, you will run into scenarios where you want more concurrent control to unlock more performance from your applications. In this workshop, you will learn the core primitives of concurrent behaviours in async Rust and how to combine them for more complex emergent behaviours, such as graceful cancellation, stream processing, actor models, and more. Armed with these tools, you'll be able to design your own concurrent systems. This will not only reduce latencies but also allow you to fully utilize your network and CPU bandwidth, thereby increasing the parallelism of your applications.

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, personalized 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.

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?

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.

Releasing a new version of a Rust crate is tedious and error-prone, just like most IT manual tasks. For every package you want to release, you need to: Check for breaking changes and increase the `Cargo.toml` version accordingly. Update the changelog. Publish to [crates.io](https://crates.io). Create and push the git tag. Meet release-plz, a Rust open-source project that automates these tasks. It allows maintainers to release Rust packages from CI, saving valuable time and removing the fear of making typos and other careless mistakes typical of manual releases from the terminal. Release-plz makes releasing Rust packages as easy as clicking the pull request 'merge' button. In this talk, I will show: How release-plz works. Why using release-plz (convenience, security, and API breaking change detection) How you can integrate release-plz in your project. How you can configure release-plz to fit your use case (e.g., cargo workspaces and build artifacts)

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.

Dive into this interactive tutorial and create blazing-fast web user interfaces with Rust, WebAssembly, and the Leptos framework! You’ll build a full-stack application, writing both backend services and a high-performance front-end. Learn optimization strategies, explore best practices for integrating Wasm into web projects, and leverage Leptos for a smooth user experience. Bring your laptop and follow along as we code together!

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.

Learn about Ephemerista, a next-generation, open-source space mission simulator funded by the European Space Agency. In this talk, Rustaceans will discover how they can use Rust’s type system to model concepts as complex as spacetime itself. No PhD required!

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.

In this talk, we explore the intersection of functional programming and Rust, providing a practical perspective for everyday Rustaceans. We begin by discussing the modern understanding of functional programming, stripping it of language-specific nuances to focus on its core principles: immutability, higher-order functions, pure functions, leveraging types, etc. We then look at how Rust supports these principles, aligning them with the idiomatic practices that define the language. Through examples, we highlight where Rust excels in adopting a functional style and where it diverges, addressing potential issues and gaps that may arise. We honestly assess whether these gaps present significant problems for Rust developers or if they are merely theoretical concerns. Building on this, we propose a concept of 'reasonable functional programming in Rust,' advocating for a balanced approach that leverages Rust's strengths without forcing concepts that don't fit naturally. Finally, we conclude with actionable insights on how to pragmatically integrate functional programming concepts into daily Rust development, empowering Rustaceans to write more expressive, maintainable code without compromising Rust’s unique advantages.

This session will take you through the development of Moshi, the first open-source speech-to-speech model, highlighting the crucial role Rust played in its success. While the primary training loop was built in Python, Rust was instrumental in optimizing the entire pipeline—handling data pre-processing, data loading, and powering the entire inference stack. We'll explore key decisions, including the shift from traditional frameworks like PyTorch to Rust/Candle for inference, and how we benefited from this choice, allowing us to serve over 500'000 Moshi sessions last summer on a low-cost GPU cluster.

Is ABI merely an artifact of implementation in native programming languages or should it be considered part of their design? Some programming languages avoid this commitment, while others are still trying to figure out a path forward. No, this is not an “ABI - Now or Never” talk. We’re taking a different route, by following the design and evolution of the Swift ABI model and seeing what we can learn from it. From ABI stability & dynamic linking to designing for ABI resilience - a journey through resilient type layout, reabstraction & materialization, resilience in library evolution and (opt-out) performance costs. What can we learn from Swift’s ABI resilience? How does C++ navigate on this journey? Can Rust be liberated from the ABI conundrum?

In this talk I will introduce you to 'Graviola', which is a new cryptography crate for Rust. Graviola heavily reuses formally verified assembly from the AWS s2n-bignum project -- giving excellent performance and assurance. I'll talk about what that means, why it is important for cryptography, and how Graviola compares to other Rust cryptography crates. I'll cover some of the more unique technical aspects, such as the workflow for consuming stand-alone assembly in Rust in a portable and readable way, and why it is completely OK to have 1500 macros in a crate.

The embedded touchscreen hardware in this talk sits in the twilight zone between a microprocessor (like a raspberri pi, laptop, pc or smartphone) and a microcontroller (like something that powers a washing machine or a microwave oven). High powered microcontrollers can have features from their microprocessor cousins and this talk will cover why these features make embedded rust development that little bit more difficult than it already is. I left the job market two years ago to work on various personal projects. The first one was to build an open source hearing aid in Rust which was presented at Rust Nation 2024 (“What’s that behind your ear? An open source hearing aid in Rust”). The second was to try to build a commercially viable physical product where I would use Rust for the embedded software. This talk should be of interest to anyone who would like to go on the same journey or is just curious about what it takes to build an embedded product in Rust. Topics include writing an LCD display driver for the Embassy Async runtime and how cooperative multitasking though async is a viable alternative to using an operating system with threads. Additionally, how a high performance microcontroller works with external RAM and flash storage. I also intend to cover the hardware design and manufacturing process from the perspective of a software engineer rather than an electrical engineer.

Microsoft’s journey with Rust reflects a commitment to building safer and more efficient software. In this closing keynote, we’ll explore how Microsoft drives change by adopting Rust across key products and platforms. From security improvements to integration challenges, we’ll share insights, lessons learned, and what’s next as Microsoft continues to evolve with Rust.