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?

PRESENTED BY

Aeva Black

Open Source Security Lead, CISA

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.

PRESENTED BY

Miguel Ojeda

Software Engineer, Maintainer of the Rust For Linux Project

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

PRESENTED BY

Nicholas Matsakis

Co-Lead Rust Language Design Team, Amazon Sr. Principal Eng.

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.

PRESENTED BY

Joannah Nanjekye

Postdoctoral Fellow/Carnegie Melon University

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!

PRESENTED BY

Predrag Gruevski

Author of Trustfall and cargo-semver-checks

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

PRESENTED BY

Michael Gattozzi

Senior Software Engineer at InfluxData

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.

PRESENTED BY

Marc-Andre Giroux

Senior Software Developer @ Netflix

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.

PRESENTED BY

Angus Morrison

Space & Finance Industry Expert | How To Code It Founder

This 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.

PRESENTED BY

Pallavi Thukral

Software Developer at Bank of New York Mellon (BNY Mellon)

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.

PRESENTED BY

David Koloski

Senior Software Engineer at Google

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.

PRESENTED BY

Pedro Rittner & Sean Lawlor

Meta Platforms Inc.

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.

PRESENTED BY

Chris Biscardi

Independent Educator and Engineer

In this talk, you’ll learn how to process and analyze complex realtime public transport data across a distributed system, and how to develop complex graph algorithms in Rust.

PRESENTED BY

Kyler Chin

Director & Computer Scientist - Catenary Transit Initiatives

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.

PRESENTED BY

Sparrow Li

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.

PRESENTED BY

Martin Pool

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

PRESENTED BY

Jonathan Pallant

Senior Engineer at Ferrous Systems

Zoo.dev has built a new programming language for 3D manufacturing and design. The language’s compiler and parser are built in Rust — see how you can build your own new programming language in Rust too!

PRESENTED BY

Adam Chalmers

Systems engineer at Zoo.dev

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.

PRESENTED BY

Isabel Atkinson

Software Engineer at MongoDB

This talk will explore PGOs and why we need them, PGO performance benefits in practice, pros and cons with multiple PGO approaches, the PGO state in the Rust ecosystem (compilers, build systems, community tooling,) and much more. After the talk, you will be much more aware of advanced optimization techniques like Post-Link Optimization (PLO), ML-based compiler optimization and other interesting topics from the optimization field.

PRESENTED BY

Alex Zaitsau

Solution Architect

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.

PRESENTED BY

Jacob Pratt

Senior Software Engineer

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.

PRESENTED BY

Jack Wrenn

Senior Software Engineer

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.

PRESENTED BY

Joshua Liebow-Feeser

Software Engineer, Fuchsia Security, Google

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.

PRESENTED BY

Nathan Stocks

Rust Instructor, Senior Software Engineer, GitHub

In this talk, we’ll explore Rust logic in Go environments using uniffi-bindgen-go. The goal of this talk is to equip you with the tools to walk away with the ability to write a package once and reuse it in any environment like Go, Rust, IOS, or even Andriod!

PRESENTED BY

Pratim Bhosale

Developer Advocate

How does Rustfmt work? How could it work better? (Demonstrated by a working prototype). 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?

PRESENTED BY

Nick Cameron

Consultant, Engineer, and Educator

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.

PRESENTED BY

Rohit Dandamudi

MSc Computer Science @UBC, Rust Foundation Fellow

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 organization with more than 1000 people.

PRESENTED BY

Ed Jones

Lead Rust Advocate, Office of the CTO, Canonical

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

PRESENTED BY

Martin Geisler

Senior Engineer at Google

Ampere (Renault Group), a French carmaker dedicated to Electric Vehicles, 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

Frédéric Ameye

Tech Lead at Ampere (Renault Group)

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.

PRESENTED BY

Quanyi Ma

Principle Engineer at Huawei, Member of Governing Board, Web3 Infrastructure Foundation

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.

>> Learn More & Register

PRESENTED BY

Herbert Wolverson

Rust Trainer, Ardan Labs

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.

At each step, you’ll explore porting and writing real code. You’ll also learn about tools, debugging, and testing.

>> Learn More & Register

PRESENTED BY

Carl Kadie

Ph.D., Volunteer, open-source projects related to ML, Genomics, Rust, and Python

You’ve probably 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!

>> Learn More & Register

PRESENTED BY

Jorge Ortiz Fuentes

Developer Advocate at MongoDB