Discover the talks and workshops you have to look forward to at RustConf 2024. Learn more about our speakers here.

 

Keynotes

Keynotes will open and close both main conference days at RustConf. Additional keynote speakers to be announced soon!

  • “Making Open Source Secure by Design”

    PRESENTED BY
    “Making Open Source Secure by Design”

    Aeva Black

    Open Source Security Lead, CISA

  • “Rust for Linux”
    PRESENTED BY
    “Rust for Linux”

    Miguel Ojeda

    Software Engineer, Maintainer of the Rust For Linux Project

  • “Project Goals: Rust Roadmap 2.0”
    PRESENTED BY
    “Project Goals: Rust Roadmap 2.0”

    Nicholas Matsakis

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

RustConf

RustConf will feature speakers across a variety of topics and be tailored to audiences with various levels of familiarity with the Rust programming language.

  • “Rust/C++ Interop: Memory Safety Across Foreign Function Boundaries”

    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
    “Rust/C++ Interop: Memory Safety Across Foreign Function Boundaries”

    Joannah Nanjekye

    Postdoctoral Fellow/Carnegie Melon University

  • “Putting an End to Accidental SemVer-Breaking Changes”

    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
    “Putting an End to Accidental SemVer-Breaking Changes”

    Predrag Gruevski

    Author of Trustfall and cargo-semver-checks

  • “What Happens When You Run Cargo Build?”

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

    PRESENTED BY
    “What Happens When You Run Cargo Build?”

    Michael Gattozzi

    Senior Software Engineer at InfluxData

  • “Low-Overhead Observability in High-RPS Servers with the Tracing Crate”

    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
    “Low-Overhead Observability in High-RPS Servers with the Tracing Crate”

    Marc-Andre Giroux

    Senior Software Developer @ Netflix

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

    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
    “Rust in Space! How Rust is Powering Next-Generation Space Mission Simulators”

    Angus Morrison

    Space & Finance Industry Expert | How To Code It Founder

  • “Rust in Motion: Building Reliable and Performant Robotics Systems”

    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
    “Rust in Motion: Building Reliable and Performant Robotics Systems”

    Pallavi Thukral

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

  • “The (Many) Mistakes I Made in rkyv”

    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
    “The (Many) Mistakes I Made in rkyv”

    David Koloski

    Senior Software Engineer at Google

  • “Actors and Factories in Rust: Distributed Processing Overload Protection”

    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
    “Actors and Factories in Rust: Distributed Processing Overload Protection”

    Pedro Rittner & Sean Lawlor

    Meta Platforms Inc.

  • “Web Sites, Web Apps, and Web Assembly”

    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
    “Web Sites, Web Apps, and Web Assembly”

    Chris Biscardi

    Independent Educator and Engineer

  • “How We Built a Rust-y Real-Time Public Transport Map”

    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
    “How We Built a Rust-y Real-Time Public Transport Map”

    Kyler Chin

    Director & Computer Scientist - Catenary Transit Initiatives

  • “The Current State and Future of Rust Compiler Performance”

    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
  • “Finding Bugs with cargo-Mutants”

    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
  • “Six Clock Cycle per Pixel – Graphics on the Neotron Pico”

    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
    “Six Clock Cycle per Pixel – Graphics on the Neotron Pico”

    Jonathan Pallant

    Senior Engineer at Ferrous Systems

  • “Making a Programming Language for 3D Design”

    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
    “Making a Programming Language for 3D Design”

    Adam Chalmers

    Systems engineer at Zoo.dev

  • “Rustify Your API: A Journey from Specification to Implementation”

    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
    “Rustify Your API: A Journey from Specification to Implementation”

    Isabel Atkinson

    Software Engineer at MongoDB

  • “Profile-Guided Optimization (PGO) in Rust: Unknown Parts”

    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
    “Profile-Guided Optimization (PGO) in Rust: Unknown Parts”

    Alex Zaitsau

    Solution Architect

  • “Compiler Driven Development: Making Rust Work for You”

    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
    “Compiler Driven Development: Making Rust Work for You”

    Jacob Pratt

    Senior Software Engineer

  • “Safety Goggles for Alchemists”

    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
    “Safety Goggles for Alchemists”

    Jack Wrenn

    Senior Software Engineer

  • “Safety in an Unsafe World”

    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
    “Safety in an Unsafe World”

    Joshua Liebow-Feeser

    Software Engineer, Fuchsia Security, Google

  • “Shooting Stars! Livecode a Game in 30 Minutes”

    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
    “Shooting Stars! Livecode a Game in 30 Minutes”

    Nathan Stocks

    Rust Instructor, Senior Software Engineer, GitHub

  • “Making Go Talk to Rust: Simplifying Cross-Language Communication with UniFFI”

    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
    “Making Go Talk to Rust: Simplifying Cross-Language Communication with UniFFI”

    Pratim Bhosale

    Developer Advocate

  • “Eternal Sunshine of the Rustfmt’ed Mind”

    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
    “Eternal Sunshine of the Rustfmt’ed Mind”

    Nick Cameron

    Consultant, Engineer, and Educator

  • “Widening the Ferris Net”

    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
    “Widening the Ferris Net”

    Rohit Dandamudi

    MSc Computer Science @UBC, Rust Foundation Fellow

Rust Global

Rust Global is a Rust Foundation-hosted half-day event taking place on Friday, September 13. It will feature content about the professional use of Rust in global leadership settings. Rust Global is open to "Industry/Government" ticket holders while capacity remains.

  • “Fearless Refactoring and the Art of Argument-Free Rust”

    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
    “Fearless Refactoring and the Art of Argument-Free Rust”

    Ed Jones

    Lead Rust Advocate, Office of the CTO, Canonical

  • “Rust Training at Scale”

    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
    “Rust Training at Scale”

    Martin Geisler

    Senior Engineer at Google

  • “Rust in Legacy Regulated Industries? The Example of a Carmaker.”

    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
    “Rust in Legacy Regulated Industries? The Example of a Carmaker.”

    Frédéric Ameye

    Tech Lead at Ampere (Renault Group)

  • “Reimagining Rust-Powered Git – Embracing Monorepo and LLM Evolution.”

    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
    “Reimagining Rust-Powered Git – Embracing Monorepo and LLM Evolution.”

    Quanyi Ma

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

Workshops

RustConf will feature three optional, hands-on workshops on Tuesday, September 10. Learn more and secure your workshop spot during registration while capacity remains!

  • “Unleash Your Computer’s Power with Rust – Safely”

    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
    “Unleash Your Computer’s Power with Rust – Safely”

    Herbert Wolverson

    Rust Trainer, Ardan Labs

  • “Run Your Rust Code on Embedded and the Web”

    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
    “Run Your Rust Code on Embedded and the Web”

    Carl Kadie

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

  • “Real World Testing in Rust”

    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
    “Real World Testing in Rust”

    Jorge Ortiz Fuentes

    Developer Advocate at MongoDB