20 Mar

Registration and Refreshments

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.

Ensuring Rust Safety: Strategies for Managing Unsafe Rust

Refreshment break

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.

Rust At The Edge

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 implementationsThis 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?

The Future of Rust Web Applications

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.

Parallel Programming in Rust: Techniques for Blazing Speed

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:<ul> <li>Check for breaking changes and increase the `Cargo.toml` version accordingly.</li><li>Update the changelog.</li><li>Publish to [crates.io](https://crates.io).</li><li>Create and push the git tag.</li></ul> Meet <a href="https://github.com/MarcoIeni/release-plz">release-plz</a>, 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:<ul><li>How release-plz works.</li><li>Why using release-plz (convenience, security, and API breaking change detection)</li><li>How you can integrate release-plz in your project.</li><li>How you can configure release-plz to fit your use case (e.g., cargo workspaces and build artifacts)</li></ul>

Automating Rust Releases with Release-plz

Room change

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.

Rust project goals 2024: Stabilizing Rust in the Linux Kernel

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.

Building Software Extensions in Rust using WebAssembly Components

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.

Crate security in 2025

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!

Fast & Fun: building web apps with Rust, WASM, and Leptos in the Full-Stack Era

Lunch

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.

Techniques learned from five years finding the way for Rust in Python

 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!

Rust in Space! How Rust is Powering Next-Generation Space Mission Simulators

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.

Digital Decluttering

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.

Functional Programming For The Working Rustacean

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.

How Rust helped us building and deploying Moshi, a state-of-the-art speech model.

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?

ABI Resilience

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.

Graviola: fast, high-assurance cryptography for Rust

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.

From Electron to bare metal GUIs in no easy steps

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.

Conference Schedule

Proudly sponsored by

Conference Schedule

Proudly sponsored by

Stay updated with Rust Nation UK news

Stay updated with
Rust Nation UK news