Schedule

Microsoft’s journey with Rust reflects a commitment to building safer and more efficient software. In this keynote, we’ll explore how Microsoft is driving 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.

This talk will compare and contrast some of the interesting differences in the approaches taken in Rust and what we’re exploring in the Carbon Language experiment. Carbon was created to find out what a maximally incremental path to evolve and migrate off of C++ and onto a programming language with memory safety might look like, and whether it would be an effective way to bring memory safety to the largest-scale and most-brownfield of C++ software ecosystems.

This talk brings Rust to one of its most high-stakes, underrepresented domains: forensic software for anti-human trafficking work. It’s a technical case study in how to build secure, no-dependency binaries for machines that don’t tolerate failure—and how Rust’s design enables it.

Built and maintained by a solo dev who is also a trafficking survivor, this talk highlights Rust’s power to serve nontraditional teams solving real-world problems. It’s a story of both technical ingenuity and personal mission.

Over the last five years, thousands of developers and hundreds of teams have gone from zero-to-Rust at Amazon. What can we learn from those diverse experiences to help other organizations adopt Rust? This is a blueprint for bootstrapping Rust adoption. We will talk about strategies that work well for bringing Rust into organizations, and strategies that don’t. Domains where Rust is likely to succeed, and areas where it is still a work in progress. This talk is intended for anyone who wants to bring (or increase) adoption of Rust in their organization.

In this talk, you’ll learn about an experience porting a battle-tested C TrieMap implementation to Rust, as part of a larger C-to-Rust migration of Redis’ search capabilities. We’ll walk through the missteps, the initial design we implemented and then discarded, the profiling rabbit holes, and the eventual breakthroughs that led us to a Rust version that not only matched but outperformed the original, without compromising safety and memory usage. Along the way, we’ll cover design tradeoffs, lessons in data layout, and how custom DSTs and a deep understanding of Rust’s memory model helped one team turn a rewrite into a real upgrade. If you’ve ever been tempted to replace C with Rust (or you’re planning to), this talk is for you.

Rust is gaining traction across industries—but can it become a cornerstone of automotive development? This talk explores Rust’s potential across embedded systems, infotainment, cloud services, and factory tools. How do C/C++ developers feel about Rust transition, what gaps remain in the ecosystem, and how to tackle both technical and organizational resistance. This session is ideal for teams exploring safer, modern tooling in safety-critical environments. It’s not just about code—it’s about adoption at scale.

Interacting with foreign languages through Rust’s FFI exposes Rust to a range of potential safety issues. In this talk, we discuss why merely focusing on memory safety for FFIs is insufficient and present an approach and framework for interacting with foreign libraries from Rust while maintaining type and memory safety, and other critical invariants.

Rust has won systems programming, but can it be used for more? The biggest barrier to “high level Rust” isn’t performance or safety — it’s ergonomics and developer productivity. In this talk we explore Rust’s potential as a high-level programming language and how Dioxus is solving the fundamental challenges. We’ll dive deep into the design of innovations like linker-based asset bundling, cross-platform deployment, and even sub-second Rust hot-reloading. The future of application development is Rust, and we’re making it a reality.

Rust is spreading. In this talk, you’ll learn how one team used Rust at every layer: a fast command-line core, a desktop UI, and native components integrated into a non-Rust backend. This talk is about where Rust fits, where it struggles, and how it can work alongside other tools instead of trying to replace them.

In an era where governments have the ability to eavesdrop on journalists and their sources through mass surveillance infrastructure, The Guardian developed Secure Messaging to provide a secure, anonymous, and easy-to-use initial contact mechanism. This presentation will detail how Rust language features were instrumental in building the system’s secure and performant backend services and how we made an inherently opaque system observable.

Want to turn a local Rust meetup into a thriving, nationwide movement? In this talk, I’ll share battle-tested lessons from scaling Rust Gdańsk across Poland—how to attract members, keep them engaged, secure sponsors, and build a community that lasts. Whether you’re starting from scratch or looking to level up, this is your roadmap to making Rust meetups thrive.

This talk explores how eBPF and Rust can overcome limitations to enable low-overhead observability and distributed tracing in native systems—without modifying application code. We’ll walk through a Rust-based eBPF implementation that observes function calls, injects and propagates trace context (e.g., traceparent), and emits OpenTelemetry spans from the kernel to user space using ring buffers. We’ll also show how this enables auto-instrumentation of mixed-language applications, where context flows seamlessly across C++, Rust, and other runtimes. If you’re building high-performance systems, this session will show how to bring OpenTelemetry distributed tracing deep into the native stack.

Drawing from a high-altitude balloon case study, along with some key comparisons to the kind of Arduino programs that are the default for student experiments, this talk will make the argument that Rust is now perfectly positioned for the kind of microcontroller code common in education contexts. This talk will be relevant to anyone exploring or teaching microcontroller programming, especially those with some exposure to the Arduino Framework, along with anyone interested in exploring Rust in a context they might not be familiar with.

Adopting Rust in large C++ projects presents a difficult choice: perform a costly, large-scale rewrite, or refactor code to accommodate the limitations of traditional interop solutions such as bindgen or cxx. This talk will discuss how high-fidelity Rust/C++ interoperability can offer a seamless path for gradual adoption using language and compiler extensions.

This talk distills key insights from the ICRA25 (IEEE International Conference on Robotics and Automation) workshop, presenting a comprehensive overview of how Rust is addressing critical pain points in robotics development. The robotics community is at an inflection point, seeking alternatives to traditional languages that struggle with memory safety and concurrency issues. This session provides a timely exploration of Rust’s potential to revolutionize how we build autonomous systems, offering attendees practical guidance on adoption pathways and highlighting real-world success stories. By bridging the academic research presented at ICRA with practical industry applications, this talk offers unique value to those interested in systems programming for safety-critical applications.