Extend the reach of your Rust code to web browsers and to tiny, embedded devices. The key? A combination of WASM (WebAssembly) and “no_std” environments. This transition initially requires limiting use of Rust’s comprehensive standard library; however, we will discover strategies to reintegrate many standard features and ensure consistent functionality across all platforms. With Rust, the same code can run on the most powerful servers, on phone web browsers, and on small, embedded devices.

Participants will learn how to adapt and develop Rust applications for WASM and no_std environments, enabling their code to run on both web browsers and embedded devices. They will also master techniques to reintegrate essential library features, ensuring functionality and performance across all platforms. Register for this workshop while capacity remains!

It’s highly probable that you’ve heard about the importance of unit testing your code. You may already know the theory and you would want to give it a try, beyond testing a function that adds two numbers. But it is hard to walk this path alone, since the first tests are also the hardest.

This hands-on workshop takes a different approach. We will use a REST API implemented with Axum that stores data and talks to the network.

Learn the concepts and use the de-facto standard tools and crates to write actual tests for a realistic application. Reach the top of the Unit Test Mountain. Register for this workshop while capacity remains!

Rust’s learning curve has a reputation for being intimidating – but the rules are there for good reasons; in this workshop you’ll learn to divide workloads between CPUs, asynchronously talk to other systems and unleash the power of your computer. You’ll also learn WHY Rust makes you jump through some hoops, and how it’s really saving you from horror-stories from that past. Register for this workshop while capacity remains!

Open source software is used across every critical infrastructure sector and throughout the United States government. With cybersecurity a topic of national concern, can we make open source more secure by design and by default?

8-minute lightning talk delivered by RustConf’s 2024 Diamond Sponsor: Devolutions. Speaker: Marc-Andre Moreau — Chief Technology Officer of Devolutions.

How does Rustfmt work? How could it work better? Or worse? How did we persuade the Rust community to stop arguing about tabs vs spaces (and other more contentious topics) and start using a consistent code style across nearly every crate in the ecosystem? In this talk, you’ll find answers to these questions and more.

Since Rust’s inception, mem::transmute has been the poster-dragon of unsafe code, but its reign of error is coming to an end! In this talk, you’ll learn how Rust is poised to become the first systems programming language with transmutation safety, and how safe transmute is already being put to use to build next-gen systems.

In this talk, you’ll learn about the experiences of Rust India — a community of Rustaceans who gather in various cities in India to connect over their interest in Rust. Through this, you’ll get to explore the positive impact of including underrepresented Rust communities around the world in important conversations within our shared ecosystem.

Let’s explore the journey of going from a language-agnostic specification for a database command interface to designing and implementing an idiomatic API in the MongoDB Rust driver, highlighting the challenges faced and key learnings that developers can apply in designing their Rust APIs.

As Rust becomes more widely used, compilation performance becomes more important. The speaker, a Rust compiler contributor, will describe the current state of Rust’s compilation performance and the various areas of development that can be expected.

Creating a game in Rust should take weeks or months, right? No! Let’s livecode a real, shooting star-themed, playable multiplayer game with graphics and sound effects and then play it live on stage with Xbox controllers — all in under 30 minutes.

This talk will show how actors can be constructed into a concurrent processing pool, called a factory, for failure protected, concurrent processing and providing safety from system overload.

rkyv, a zero-copy deserialization framework, is a complex project that David made a lot of mistakes on while developing. In this talk, he reviews the “many bad decisions made over the past three years” and how he addressed them over time.

We track millions of public transport trips a week and process them into a global routing engine and distributed data analyser using Rust. We’ll discuss how to process and analyse complex realtime public transport data across a distributed system, and how to develop complex graph algorithms in Rust.

Zoo.dev has built a new programming language for 3D manufacturing and design. The language’s compiler and parser are built in Rust — don’t miss this talk to learn how you can build your own new programming language in Rust, too!

cargo-mutants highlights gaps in your crate’s tests, helping you improve your program’s reliability. We’ll explore how and where to use it for best results, and show how Rust’s ecosystem made it surprisingly easy and fun to build.

Three five-minute lightning talks delivered by RustConf Gold sponsors.

In this block:

1. Andrew Burkhart, Senior Rust Developer, 1Password.
2. David Sankel, Principal Scientist, Adobe.
3. JF Bastien, Distinguished Engineer, Woven by Toyota.

The Rust project has grown both in members and in structure over the past years. This keynote aims to give a bird’s eye view of the teams and structure of the people that make up the Rust Project today, how the teams communicate and make collaborative decisions, and how new people and groups can get involved.

Rust is growing within Linux. Learn how Rust is used in the kernel, the challenges we are facing, and how both Rust for Linux and the Rust project are collaborating to address the kernel needs.

Three five-minute lightning talks delivered by RustConf Gold sponsors.

In this block:

1. Vitaly Bragilevsky, Developer Advocate, JetBrains.
2. Max Brunsfeld & Antonio Scandurra, Co-Founders, Zed Industries.
3. Michael Saqr, Head of Software, K2 Space.

A deep dive on how the Neotron computer generates VGA text and graphics at about 25 million pixels per second, in Rust, using a $1 microcontroller.

This talk will describe how developers can bind, encapsulate, and call foreign functions, and identify disparities between Rust’s memory model and foreign memory models that make these tasks difficult. The talk will also give recommendations on community guidelines and tooling that can make the Rust’s promise of static safety a reality across foreign boundaries.

Rust has a reputation for being a difficult language to learn, but it doesn’t have to be! Learn to use the compiler to guide you towards writing correct code and how to leverage Rust’s world-class diagnostics, tooling, and powerful type system to make your development experience more productive while avoiding common pitfalls, bugs, and unidiomatic code.

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

A deep dive into everything cargo does just to build a singular binary/library.

In this session, we will explore the unique advantages of using Rust for robotics development. Rust’s guarantees of memory safety, concurrency without data races, and zero-cost abstractions make it an ideal choice for building robust and high-performance robotics applications. We will delve into real-world examples, discuss best practices, and demonstrate how Rust can be leveraged to write reliable control software, manage complex sensor data, and ensure system safety in autonomous systems.

In this talk, we’ll dive deep into how Netflix used the `tracing` crate to get as close as possible to this ideal. You should leave the session with a better understanding of the tracing crate, common pitfalls, and techniques for minimizing its overhead.

You ran `cargo update` and now your code has compile errors. Oops! More than 1 in 6 of the top 1000 crates have accidentally shipped breaking changes that could lead to such situations! Why does this keep happening? How does the `cargo-semver-checks` linter prevent such breakage? How is it different from prior attempts at SemVer linting? We want `cargo update` to be fearless — better tooling will pave the way!

With the context of over a decade of experience building web UI in JavaScript, I’ll cover my experience shipping multiple Rust/wasm based sites, why this recently became a viable alternative to modern JS frontend architectures like Vue and Next, and how it became my default choice for new sites.

Rust doesn’t just support memory safety, it supports “X-safety”: The ability to teach Rust about arbitrary safety properties, only permitting X-safe code to compile. This talk will explore how this technique has been used to defend against everything from network protocol bugs to cryptographic vulnerabilities, demonstrate novel results based on Joshua’s research, and argue that if we take this aspect of Rust seriously, we can fundamentally reshape how software is written in safety-critical environments.

Learn about the goals that the Rust project has set for 2024, prospects for 2025, and how the goal selection process works.

The RustConf “UnConf” is a much-loved annual RustConf tradition! Join us for freeform discussions with members of the Rust Project and community. Register for free while spots remain.

The RustConf UnConf will include a morning snack and boxed lunch.

The Rust Foundation’s Executive Director & CEO Dr. Rebecca Rumbul will kick off Rust Global with some opening remarks alongside Rust Global emcee Ernest Kissiedu

At Ampere (Renault Group), a French carmaker dedicated to Electric Vehicles, we developed a strong strategy to rely on the Rust language properties to improve our cars. Let’s explore the journey towards Rust in big ol’ corporations with decades of legacy!

Presented by our exclusive Rust Global sponsor OxidOS.

Version control systems are the bedrock of software development, and Git has undoubtedly become the de facto standard. However, as the industry shifts towards monorepos and decentralized architectures, Git’s original design faces unprecedented challenges. This talk explores how leveraging Rust can revolutionize Git, injecting new vitality into version control systems.

This talk will cover how Android set out to train thousands of engineers in Rust. We developed custom training material as well as tooling to support this. You will learn what worked well and what worked less well. Finally, we will look at where the training is heading at Google.

Large professional codebases naturally form conventions and competing conventions lead to messy code. This talk discusses what we learned from creating standards documents and a hackable linter (in Rust) and applying it to large codebases at an organisation with more than 1000 people.

The Rust Foundation Security Initiative has been gathering analysis and analytics of the crate ecosystem for the past year, bringing a wealth of data to extract insights and help guide priorities. This talk will explore what that infrastructure is and delve into the statistics of externally-linked code across the crates ecosystem. Ever wondered how many vulnerable versions of a library are being built into crates? Whether or not there an average time-to-update for external dependencies? How crate authors are importing and linking these? How much “vendoring” is occurring? We will cover this subject matter and more, while discussing possible areas for improvement.