BEGIN:VCALENDAR
VERSION:2.0
X-WR-CALNAME:rustconf2026
X-WR-CALDESC:Event Calendar
METHOD:PUBLISH
CALSCALE:GREGORIAN
PRODID:-//Sched.com RustConf 2026//EN
X-WR-TIMEZONE:UTC
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T120000Z
DTEND:20260908T220000Z
SUMMARY:Registration and Badge Pickup
DESCRIPTION:\n
CATEGORIES:REGISTRATION
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:f427860b2fc79b8648f4a9bb0689cb61
URL:http://rustconf2026.sched.com/event/f427860b2fc79b8648f4a9bb0689cb61
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T130000Z
DTEND:20260908T163000Z
SUMMARY:Workshop 1: Practical Actor-Based Concurrency in Async Rust (Additional Registration Required)
DESCRIPTION:Asynchronous Rust makes it possible to build highly concurrent systems—but structuring shared state correctly remains one of the most common sources of complexity for intermediate Rust developers. Even when code compiles\, subtle contention\, accidental locking across `.await`\, and `Send + Sync` constraints can make larger systems difficult to reason about.\nThis workshop explores actor-based design as a practical architectural pattern for structuring async applications in Rust. Rather than sharing mutable state\, actors encapsulate ownership behind message-driven boundaries\, simplifying reasoning about concurrency\, backpressure\, and failure handling.\n\nWorkshops are optional add-ons for in-person attendees only and are not included in RustConf tickets. Workshop tickets can be purchased for an additional fee.&nbsp\;\n\n
CATEGORIES:WORKSHOPS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:390061cff819f84d67180f1c4155021e
URL:http://rustconf2026.sched.com/event/390061cff819f84d67180f1c4155021e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T130000Z
DTEND:20260908T163000Z
SUMMARY:Workshop 2: Hello\, Kernel! Linux Driver Development in Rust - Part 1 (Additional Registration Required)
DESCRIPTION:Rust is entering the Linux kernel\, bringing memory safety and modern tooling to low-level systems programming. In this hands-on workshop\, attendees will learn how to build a Linux kernel with Rust support enabled\, set up a complete development environment targeting both x86-64 and aarch64\, and write a practical Rust-based misc device driver. We’ll explore kernel-space inter-process communication and the use of background tasks for asynchronous work\, giving participants a concrete\, end-to-end understanding of how Rust can be used to develop real Linux drivers today.\n\nWorkshops are optional add-ons for in-person attendees only and are not included in RustConf tickets. Workshop tickets can be purchased for an additional fee.&nbsp\;
CATEGORIES:WORKSHOPS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:f136802b630bcb970e4ccd6e52837dc0
URL:http://rustconf2026.sched.com/event/f136802b630bcb970e4ccd6e52837dc0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T130000Z
DTEND:20260908T163000Z
SUMMARY:Workshop 3: Using Advent of Code as an FFI Playground (Additional Registration Required)
DESCRIPTION:Using Advent of Code (AoC) puzzles as the substrate\, participants build a working Rust FFI library from scratch\, wrapping a real AoC solution in a C glue layer and calling it from multiple different target languages. By the end of the workshop\, attendees leave with a working multi-language project\, a replicable methodology\, and hands-on intuition for the pitfalls that make production FFI hard.\nAoC problems are uniquely well-suited for FFI practice because they have diverse input/output types (primitives\, strings\, iterators)\, a motivating narrative that makes repetition feel worthwhile\, no production baggage — you can break things freely — and progressively increasing complexity across 12-25 days of problems each year. Unlike algorithm-focused competitive programming\, this approach uses AoC’s rich problem variety to stress-test real cross-platform FFI patterns: string encoding mismatches between Java and Swift\, async model incompatibilities\, and the lowest-common-denominator constraints that make production FFI viable.\n\nWorkshops are optional add-ons for in-person attendees only and are not included in RustConf tickets. Workshop tickets can be purchased for an additional fee.&nbsp\;\n\n
CATEGORIES:WORKSHOPS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:892a14f5e236f932374f9d8b11b4479b
URL:http://rustconf2026.sched.com/event/892a14f5e236f932374f9d8b11b4479b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T173000Z
DTEND:20260908T210000Z
SUMMARY:Workshop 4: C→Rust\, Beyond the Basics (Additional Registration Required)
DESCRIPTION:Rewriting a C codebase in Rust isn’t a big bang: it’s a marathon\, where you execute a series of small\, deliberate steps. This workshop teaches you how to do it incrementally\, based on hard-won lessons from migrating production C codebases over to Rust.\nWe’ll start with FFI fundamentals (repr(C)\, bindgen\, cbindgen)\, move to writing correct extern “C” interfaces\, then work through a 4-step module rewrite process: encapsulate\, rewrite\, bridge\, swap. Along the way\, we’ll cover the pitfalls (mixed allocators\, string encoding\, performance overhead) and some of the high-level strategies you can use when planning out a large-scale migration. There will be hands-on exercises at each stage.\n\nWorkshops are optional add-ons for in-person attendees only and are not included in RustConf tickets. Workshop tickets can be purchased for an additional fee.&nbsp\;
CATEGORIES:WORKSHOPS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:c641ddf9c052701d5423cd22cb38196e
URL:http://rustconf2026.sched.com/event/c641ddf9c052701d5423cd22cb38196e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260908T173000Z
DTEND:20260908T210000Z
SUMMARY:Workshop 5: Hello\, Kernel! Linux Driver Development in Rust - Part 2 (Additional Registration Required)
DESCRIPTION:This workshop is an extension to “Hello\, Kernel! Linux Driver Development in Rust – Part 1”. We aim to go beyond purely software-based examples by introducing embedded devices connected over USB. This will allow participants to experiment with Rust driver development against real\, external hardware\, and better understand how Rust fits into common kernel subsystems used in practice.\nThese exercises will cover the basics of device probing\, binding a driver to a USB device\, and handling simple data transfers\, all while leveraging Rust-for-Linux abstractions to maintain safety and clarity. The goal is not to dive into complex USB internals\, but to provide a practical\, approachable introduction to USB driver development.\n\nWorkshops are optional add-ons for in-person attendees only and are not included in RustConf tickets. Workshop tickets can be purchased for an additional fee.&nbsp\;\n\n
CATEGORIES:WORKSHOPS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:73e51319f124e3108284a3735cb03b7e
URL:http://rustconf2026.sched.com/event/73e51319f124e3108284a3735cb03b7e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T120000Z
DTEND:20260909T220000Z
SUMMARY:Registration and Badge Pickup
DESCRIPTION:\n
CATEGORIES:REGISTRATION
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:63a8a8b7cbb4b92599504300016a5948
URL:http://rustconf2026.sched.com/event/63a8a8b7cbb4b92599504300016a5948
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T130000Z
DTEND:20260909T131500Z
SUMMARY:Opening Remarks
DESCRIPTION:An introduction to RustConf 2026 from your host\, the Rust Foundation!
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:41ec10752c5836569b80748203185006
URL:http://rustconf2026.sched.com/event/41ec10752c5836569b80748203185006
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T131500Z
DTEND:20260909T134500Z
SUMMARY:Keynote: Rust Adoption at Scale With Ubuntu
DESCRIPTION:When Ubuntu 25.10 shipped with Rust-based rewrites of core system packages like coreutils and sudo\, it marked the first milestone toward making memory-safe utilities the default in Ubuntu. In this talk\, Jon Seager charts the journey behind that decision\, including the motivation\, tradeoffs and surprises along the way. Canonical has now shipped Ubuntu 26.04 LTS\, the first long term support release to feature these utilities with our trademark 15-year support and security maintenance. Also covered is the upki project\, a collaboration between Canonical and the Rustls project\, all the ways you can develop with Rust on Ubuntu\, and our plans for the future.
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:8f888361cb9115ae4c0ade7002904b33
URL:http://rustconf2026.sched.com/event/8f888361cb9115ae4c0ade7002904b33
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T140500Z
DTEND:20260909T141500Z
SUMMARY:Project Update: Bringing Rust into Python
DESCRIPTION:In the last few years\, Python users started looking at Rust as an alternative for building Python modules. It can deliver performance on par with C with a developer experience much closer to Python.\n \n Late last year\, two members of the Python Core team proposed integrating Rust into the CPython interpreter and standard library.\n \n The Rust Project reached out with support\, and established an ongoing communication channel with core Python developers\, PyO3 maintainers\, and on the Rust side\, Cargo\, language\, and compiler members. We talked through the challenges they're facing\, proposed suggestions\, brought in experts\, and worked together to address concerns people will raise.\n \n This is an overview of that collaboration\, where we're now and what's coming next.
CATEGORIES:PROJECT UPDATES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:41eb4ec335b697a76eee40f3abcdd26b
URL:http://rustconf2026.sched.com/event/41eb4ec335b697a76eee40f3abcdd26b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T143500Z
DTEND:20260909T150500Z
SUMMARY:☕️ Morning Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:0e35f6f4c670021f06edd6ce57116fbd
URL:http://rustconf2026.sched.com/event/0e35f6f4c670021f06edd6ce57116fbd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T150500Z
DTEND:20260909T154500Z
SUMMARY:"Rust: Batteries Included" — Inside Volvo Cars' SmartCell\, The Next-Gen EV Battery
DESCRIPTION:SmartCell is Volvo Cars’ new AC battery technology\, marking a breakthrough in EV development by eliminating complex components like the inverter and onboard charger. This simplifies the drivetrain\, reduces cost\, and enables a cleaner architecture by shifting more intelligence into the battery itself — and this is where Rust comes in. Building on our experience bringing Rust into production automotive systems\, we use it to deliver robust\, correct\, and secure embedded software with strong performance and predictable behavior. This talk explores how Rust supports this software‑defined battery technology and the engineering lessons from scaling Rust further into automotive systems.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:782e13dcbc28b7daeb7c2b80858e793f
URL:http://rustconf2026.sched.com/event/782e13dcbc28b7daeb7c2b80858e793f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T150500Z
DTEND:20260909T154500Z
SUMMARY:Good or Bad Vibes? Coding with AI in Rust
DESCRIPTION:AI-assisted Rust code writing is increasing in prevalence in both open-source and production environments. Recent LLM models can write Rust that compiles\, passes tests and may look idiomatic\, yet there can be underlying issues. Crate maintainers may frequently encounter "vibe-coded" contributions: code that is syntactically correct but architecturally un-idiomatic.\n Get ready to contribute! This talk will mix maintainer experience with a small live snapshot of how the room is encountering AI in Rust today.\n Drawing from lessons learned while maintaining an open-source Rust crate and managing a contributor community\, the speaker will examine where AI genuinely accelerates development and where it consistently struggles. Rather than focusing on tools or prompts\, the talk explores how LLM generated patterns work with Rust’s ownership borrow checker\, type system\, and particularly with Rust’s crate design.\n We will look at patterns in “vibe-coded” Rust: code that may work but lack clear invariants and code fighting lifetimes and borrow checker issues. We’ll see where AI genuinely helps Rust developers\, where it can actually struggle\, and what it could mean for learning\, reviewing\, and maintaining Rust code.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:80f9dfaea893feabef3978a962776149
URL:http://rustconf2026.sched.com/event/80f9dfaea893feabef3978a962776149
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T150500Z
DTEND:20260909T154500Z
SUMMARY:Zngur: Simplified Rust/C++ Integration
DESCRIPTION:A good C++ interop solution is essential for organizations migrating new development to Rust on their large\, existing C++ codebases. While popular solutions exist\, they often require unsafe-Rust expertise or make assumptions about the code being exposed. These problems are compounded when you add experienced C++ engineers to the mix who are Rust novices.\n \n Zngur\, a relatively new Rust/C++ interop solution\, takes a different approach: one that is both principled and delightful for experienced C++ developers. Taking the stance that C++ semantics are a superset of Rust's\, calling Rust from C++ requires only declaring what should be exposed\, and the other direction involves writing a simple layer on the C++ side.\n \n This talk covers the basics of Zngur's architecture\, how to use it\, and practical considerations for applying it to a large C++ codebase.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:1706e0dcc2b66c4ecd439683a8a1fa9a
URL:http://rustconf2026.sched.com/event/1706e0dcc2b66c4ecd439683a8a1fa9a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T155500Z
DTEND:20260909T163500Z
SUMMARY:Detecting Borrow and Provenance Bugs Across Unsafe Rust and C/C++ Interoperability
DESCRIPTION:Rust’s ownership system eliminates many memory errors at compile time\, yet real-world systems routinely bypass these guarantees through unsafe code\, raw pointers\, and foreign interfaces to C/C++. In these contexts\, failures often stem not from simple memory faults but from violations of Rust’s semantic aliasing and provenance rules\, which may remain invisible to conventional debugging methods.\n \n This talk demonstrates practical techniques for diagnosing such violations across unsafe Rust and cross-language boundaries. It contrasts byte-level memory instrumentation that detects spatial and temporal errors with semantic execution methods that track pointer provenance\, initialization state\, and language invariants. It further presents ownership-aware instrumentation strategies that selectively monitor high-risk pointers using lifetime information\, reducing overhead while preserving detection capability. Finally\, it shows how dynamic provenance tracking can enforce borrow permissions during execution\, exposing aliasing violations introduced by foreign code.\n \n The talk concludes with guidance on choosing appropriate methodologies based on precision\, performance\, and deployability in production systems.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:6da6e62122435bbb1fddf8689508ef16
URL:http://rustconf2026.sched.com/event/6da6e62122435bbb1fddf8689508ef16
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T155500Z
DTEND:20260909T163500Z
SUMMARY:Fearless Concurrency on the GPU
DESCRIPTION:This session introduces a novel open source Domain-Specific Language (DSL) that enables developers to author high-performance GPU kernels directly in safe Rust. The DSL employs a tile-based programming model targeting the Tile IR open source MLIR dialect\, allowing developers to focus on algorithms that decompose large tensor-based computations into smaller tile-based ones. By automating memory management and the utilization of specialized hardware like matrix accelerators\, the DSL raises the GPU programming abstraction\, compiling to high-performance binaries without the need for unsafe Rust.\n \n To orchestrate workloads on modern systems\, a tensor programming API enables the static composition of data movement and kernel launch operations into discrete device operations. These device operations are asynchronously submitted as tasks to multiple GPUs using a preferred async Rust runtime. Consequently\, the async runtime serves as a unified scheduler of concurrent activities running on both the CPU and GPU.\n \n Through an exploration of this system\, attendees will gain a fundamental understanding of why data races occur in GPU code and see how they are fundamentally eliminated through the application of Rust’s ownership model. The session illustrates how to enforce memory safety within a macro-based DSL and extends those guarantees to asynchronous orchestration\, providing a practical framework for building high-performance heterogeneous systems.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:31099828128cccf2eab41f3d8e028962
URL:http://rustconf2026.sched.com/event/31099828128cccf2eab41f3d8e028962
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T155500Z
DTEND:20260909T163500Z
SUMMARY:Replacing #[cfg] with Traits: The Inlinable Dyn Extension Trait Pattern
DESCRIPTION:Library authors often face a painful trade-off: support optional features via a labyrinth of compile-time #[cfg] gates\, or rely on stubbed defaults and API toggles that push feature negotiation to runtime - at the expense of binary bloat and runtime assertions.\n \n This talk explores a third option: the "Inlineable Dyn Extension Trait" (IDET) pattern. By leveraging Rust's type system and modern compiler optimizations\, it is possible to write zero-cost APIs that offer the best of all worlds: a seamless DevEx without #[cfg] gates\, assertion-less static/dynamic feature negotiation\, and codegen that consistently strips unused features as dead code.\n \n This session is informed by the architecture and evolution of the `gdbstub` crate - an ergonomic\, feature-rich\, and easy-to-integrate implementation of the GDB Remote Serial Protocol.\n \n Attendees will learn how to design flexible\, modular\, ergonomic libraries that scale from no_std microcontrollers to modern hypervisors\, without succumbing to "#[cfg]-hell".
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:29a9281068bf00e9b6ca4377f08946eb
URL:http://rustconf2026.sched.com/event/29a9281068bf00e9b6ca4377f08946eb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T163500Z
DTEND:20260909T180000Z
SUMMARY:🍴 Lunch Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:5d5bcec1ff3a38c426c5617c5cd1e560
URL:http://rustconf2026.sched.com/event/5d5bcec1ff3a38c426c5617c5cd1e560
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T180000Z
DTEND:20260909T184000Z
SUMMARY:Compiling the Linux Kernel with gccrs
DESCRIPTION:After five years of intense development and focus on the standard library\, the gccrs project is now finally able to compile existing production Rust code - with our first major milestone being the Linux kernel.\n \n This talk will narrate the journey that the compiler underwent in order to handle the difficult Rust standard library as well as various crates within the kernel. We will explore curious Rust behavior\, unassuming code snippets with complex compiler ramifications\, as well as numerous hacks and trivia from both rustc and gccrs. The inner workings of a Rust compiler will be explored\, and you will gain a deeper understanding of just how much work is done behind the scenes\, and how that allows for the Rust programming language to be so ergonomic at the cost of the compiler engineers’ sanity.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:09687428308e9405ad8d6bb3170947e6
URL:http://rustconf2026.sched.com/event/09687428308e9405ad8d6bb3170947e6
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T180000Z
DTEND:20260909T184000Z
SUMMARY:Reverse Engineering Rust Malware in 2026
DESCRIPTION:In the past several years\, professional malware reverse engineers have come to a terrible realization: They need to learn how to reverse Rust programs. The widespread adoption of Rust has not only led to an increase in legitimate software targets to study and examine for vulnerabilities\, but also an explosion in malware written in Rust.\n \n This talk is a survey of the reverse engineering landscape for Rust malware in 2026. It walks through the analysis of a Rust malware sample\, and discuss the techniques that Rust malware authors are using in their programs. It looks at the limitations of program analysis and decompilation tools\, which are still largely built to analyze C programs\, against Rust binaries. Finally\, it discusses the challenges present in teaching Rust reverse engineering to malware reverse engineers\, and the differences in mindset\, tool adoption\, and educational approach between malware reversers and Rust software developers.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:35267450b009cd64ea9623417289ac39
URL:http://rustconf2026.sched.com/event/35267450b009cd64ea9623417289ac39
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T180000Z
DTEND:20260909T184000Z
SUMMARY:Tokio\, Rayon\, and the GPU: Profiling a Radiology AI Pipeline in Rust
DESCRIPTION:How do you go about profiling and optimizing a performance-critical medical AI system in Rust?\n \n This talk presents a case study of porting a radiology AI system from Python to Rust\, a system that had been shown to boost radiologist productivity by up to 40% in a study\, but that relies on high-performance ingestion and processing of data to deliver these results. This resulting system leverages both Tokio and Rayon to power a complex pipeline including async\, CPU-intensive\, and GPU-intensive workloads.\n \n Attendees will learn the practical profiling techniques used to identify bottlenecks in this system\, will see the decisions made in order to overcome these bottlenecks\, and will get a brief look at those challenges that are still left tackle. The result is a system that processes nearly a million radiology studies a year across 10+ hospitals on one on-prem commodity GPU.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:f6bcba3c879aca23540754e2025b4739
URL:http://rustconf2026.sched.com/event/f6bcba3c879aca23540754e2025b4739
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T185000Z
DTEND:20260909T193000Z
SUMMARY:From C++ APIs to Idiomatic Rust: Wrapper Design Patterns
DESCRIPTION:In this talk\, we’ll walk through a practical example of wrapping a real C++ library and show repeatable design patterns for: modelling ownership and lifetimes\, mapping error handling into Result\, defining safe abstraction boundaries\, and minimising unsafe surface area. We’ll also discuss how generated bindings (e.g.\, Crubit-style tools) accelerate interop\, and why wrapper design still requires deliberate human judgment.\n \n We’ll cover common interop footguns like unsound Send/Sync assumptions\, ABI/layout hazards\, panic/exception boundary issues\, accidental copies\, and wrapper-layer performance regressions\, and close with a review checklist teams can apply immediately.\n \n This matters because in large production C++ codebases\, adoption often starts with “generate bindings” but teams quickly discover that bindings aren’t APIs. The wrapper design is what determines safety\, ergonomics\, and long-term maintainability under constraints like thread-safety\, exceptions\, stable APIs\, and strict performance budgets.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:729f65d76f7bf9a9e0a1af41a6dbe532
URL:http://rustconf2026.sched.com/event/729f65d76f7bf9a9e0a1af41a6dbe532
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T185000Z
DTEND:20260909T193000Z
SUMMARY:The Future of Rust in Academia
DESCRIPTION:Discover Rust's potential to shape the future of software engineering in academia! In this talk\, we'll explore why Rust’s safety\, performance\, and growing industry demand make it the ideal language for modern curricula\, empowering students to explore fundamentals\, e.g. low-level hardware and language design\, and thus preparing them best to build the future.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:be4666d66541e05ea8ffd4ca73fc07a4
URL:http://rustconf2026.sched.com/event/be4666d66541e05ea8ffd4ca73fc07a4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T185000Z
DTEND:20260909T193000Z
SUMMARY:Unsafe Rust
DESCRIPTION:This presentation explores the role of Unsafe Rust in systems programming and its implications for safety-critical software. Rust is designed to provide memory safety and prevent common programming errors through its ownership and borrowing model. However\, certain low-level operations require the use of unsafe code\, which introduces risks such as undefined behavior (UB) and under-specified semantics. We examine the distinction between safe and unsafe Rust\, the nature of UB\, and why formal specifications are essential for reliability. The talk highlights challenges in defining Rust’s semantics\, the concept of library-level invariants\, and the importance of operational models for correctness. Finally\, we outline the “Golden Path” toward a complete Rust specification\, including initiatives like MiniRust\, A-mir-formality\, Tree Borrows\, and Miri\, which aim to close the UB gap and provide a rigorous foundation for safe and predictable Rust programs.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:ad5a97796d269ef954ba2567af137b1d
URL:http://rustconf2026.sched.com/event/ad5a97796d269ef954ba2567af137b1d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T193000Z
DTEND:20260909T200000Z
SUMMARY:☕️ Afternoon Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:d255610a29df3b646636299a48691556
URL:http://rustconf2026.sched.com/event/d255610a29df3b646636299a48691556
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T200000Z
DTEND:20260909T204000Z
SUMMARY:Listening to the Radio with Rust
DESCRIPTION:The radio spectrum is full of signals: FM music stations\, aircraft transponders\, ham radio repeaters\, and even an atomic clock broadcasting the exact time. With a $30 USB dongle and some Rust code\, you can tune in to all of it.\n \n This talk is an introduction to software-defined radio (SDR) through the lens of Rust. We'll start with what's actually out there on the airwaves: the surprisingly rich world of signals you can receive with cheap hardware. Then we'll walk through the Rust ecosystem for SDR: connecting to an RTL-SDR receiver\, working with raw IQ samples\, and turning those samples into something meaningful.\n \n Along the way\, we'll build three small programs: an FM radio receiver that demodulates broadcast stations\, a decoder for a shortwave time signal\, and an ADS-B-based flight tracker. Each demo highlights different strengths of Rust for signal processing — zero-cost abstractions for real-time DSP pipelines\, strong typing for managing sample rates and frequency math\, and the performance needed to keep up with a continuous stream of radio data.\n \n No prior radio or DSP experience is needed. You'll leave with a working mental model of how software-defined radio works and a clear path to start experimenting with Rust and radio yourself.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:533dabf4cffbfd064eb1a647f8982358
URL:http://rustconf2026.sched.com/event/533dabf4cffbfd064eb1a647f8982358
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T200000Z
DTEND:20260909T204000Z
SUMMARY:Migrating RediSearch from C to Rust - Challenges and Techniques
DESCRIPTION:Cybersecurity is more prominent than ever. Rust offers the perfect opportunity to modernize your companies tech stack\, address tech debt\, get shiny new developer features while also addressing security needs. But rewriting is big and scary. It can massively increase complexity\, slow down engineering and put features at risk. We want to share our learnings from helping a client\, RediSearch\, migrate a complex and highly critical codebase from C to Rust. The challenges we faced and the solutions and techniques we developed with the client\, both technical and organizational.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:8f643176104abadce7b5ab50836c45f4
URL:http://rustconf2026.sched.com/event/8f643176104abadce7b5ab50836c45f4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T200000Z
DTEND:20260909T204000Z
SUMMARY:When Safe Code is Fast - Scientific Computing in Rust
DESCRIPTION:Bounds checking is slowing Rust down\, the borrow checker prevents performant data structures\, and existing libraries in C++ and Fortran have had too many decades of optimizations to just catch up with them - we have heard it all. But\, what if we don’t listen?\n \n In this talk\, we’ll explore two new features of the Rust standard library: computing derivatives via std::autodiff\, and running code on GPUs\, via std::offload. We will put our compiler googles on\, and have a close look at plenty of Benchmarks for these new features\, and their possible safe or unsafe usages. (Un)surprisingly we will see that safe Rust fares a lot better than unsafe Rust in both cases. After this talk and looking through plenty of examples\, these results hopefully become a bit more intuitive.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:b5630c028e432df6ad4d27213db2fe12
URL:http://rustconf2026.sched.com/event/b5630c028e432df6ad4d27213db2fe12
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T205000Z
DTEND:20260909T205500Z
SUMMARY:Redox OS Update and Demo
DESCRIPTION:Redox OS is a Unix-like operating system written in Rust and community developed. Redox is intended to be a complete alternative to Linux\, for the cloud and desktop. We will provide an overview of new features and recent progress\, and give a quick demo of programs running on Redox.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:545fbb840a619c4693777dd2a9c00d76
URL:http://rustconf2026.sched.com/event/545fbb840a619c4693777dd2a9c00d76
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T205500Z
DTEND:20260909T210000Z
SUMMARY:Building Rust Africa: From Community to Continent Scale Institution
DESCRIPTION:Rust Africa began as a small\, informal developer community and evolved into a structured\, cross-continental initiative working to institutionalize Rust across multiple African countries. This talk presents the strategic decisions\, governance models\, incorporation debates\, and operational challenges behind building a sustainable open-source ecosystem in an emerging market context.\n \n Rather than focusing on inspiration\, the session examines execution: selecting a jurisdiction for nonprofit incorporation\, designing leadership structures to prevent fragmentation\, securing partnerships\, managing volunteer burnout\, and aligning with global Rust ecosystem stakeholders. It also highlights measurable impact\, from community expansion to industry engagement.\n \n Attendees will gain an inside look at what it takes to scale a programming language ecosystem where infrastructure\, funding\, and institutional support are limited. The talk concludes with a practical blueprint for building resilient Rust communities in underrepresented regions\, offering lessons applicable beyond Africa.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:0a63eb48fc12284c3ed95a662ed9ee8b
URL:http://rustconf2026.sched.com/event/0a63eb48fc12284c3ed95a662ed9ee8b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T210000Z
DTEND:20260909T210500Z
SUMMARY:Using the Rust Standard Library on High-End MCUs
DESCRIPTION:Most embedded Rust software is no_std. However\, as more powerful microcontrollers become available\, we may be able to use the Rust standard library to simplify embedded development. Learn what it's like to port and use the Rust standard library in embedded projects\, with comparisons against existing no_std and std solutions.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:54ca8183c0b3eea366d396b5ebea4533
URL:http://rustconf2026.sched.com/event/54ca8183c0b3eea366d396b5ebea4533
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T210500Z
DTEND:20260909T211000Z
SUMMARY:Tips for Speeding Up Cargo Build in CI
DESCRIPTION:The Rust maintenance team has done a lot of work to speed up compilation times\, particularly for iterative development\, but how can we speed up compilation for situations like CI where we ought to start with a blank slate? This talk will discuss quick\, practical tips for easy ways to speed up a CI build.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:ac7a9a9255a27dc11bb0ecb5902502c4
URL:http://rustconf2026.sched.com/event/ac7a9a9255a27dc11bb0ecb5902502c4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T211000Z
DTEND:20260909T211500Z
SUMMARY:Layered Configuration and Safe Hot Reload in Rust
DESCRIPTION:Hot reloading configuration in long-running services is often treated as a file-watching problem. In practice\, most failures occur because configuration is mutated in place\, partially applied\, or insufficiently validated before entering runtime state.\n \n This lightning talk presents a layered configuration model that makes safe hot reload a natural consequence of system design. Configuration flows through clearly separated stages: an operator-facing specification\, parsing into an in-memory representation\, structured validation\, transformation into a runtime representation\, and finally an immutable runtime snapshot used by the system.\n \n Each stage produces a distinct representation with an explicit boundary and purpose. Validation happens before the runtime state exists. After validation\, the runtime configuration is immutable and can be atomically replaced as a unit.\n \n By separating specification from runtime and relying on immutable snapshots\, hot reload becomes a matter of constructing a new validated configuration and swapping it in\, rather than mutating global state. Rust’s type system and ownership model make these boundaries explicit and enforceable\, reducing the risk of partial updates and inconsistent behavior.\n \n The pattern applies broadly to long-running Rust services that need reliable configuration updates without restarts or shared mutable state.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:3cc6e88e67d11bb4f9e709515774df7b
URL:http://rustconf2026.sched.com/event/3cc6e88e67d11bb4f9e709515774df7b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T211500Z
DTEND:20260909T212000Z
SUMMARY:Building Efficient Web Scrapers
DESCRIPTION:This talk explores the considerations and design choices for developing efficient web scrapers. It centers on a comparative analysis between Python and Rust. Contrasting Python's ease of use and rich data science ecosystem\, with Rust's advantages in performance\, memory safety\, and concurrency.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:19bb592d803ea07170e6cbf253148a5d
URL:http://rustconf2026.sched.com/event/19bb592d803ea07170e6cbf253148a5d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T212000Z
DTEND:20260909T212500Z
SUMMARY:Implementing a High Performance Serialization Library
DESCRIPTION:This talk introduces wincode\, a high-performance Rust serialization library. You’ll learn how hidden copies can sneak into otherwise safe code\, how placement initialization helps avoid them\, and how compile-time metadata can dramatically improve performance without sacrificing ergonomics or maintainability.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:2ef37e299c01c724fcf1ac2d6c1c4beb
URL:http://rustconf2026.sched.com/event/2ef37e299c01c724fcf1ac2d6c1c4beb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T212500Z
DTEND:20260909T213000Z
SUMMARY:Zero-copy Transfers with io_uring and Rust
DESCRIPTION:This talk examines the performance costs of epoll-based file-to-socket I/O\, including redundant memory copies and excessive syscalls. It then shows how Rust and io_uring achieve high-throughput\, low-latency file-to-network transfers using fixed buffers\, registered files\, and sockets\, demonstrated through a practical zero-copy pipeline.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:8a4f8348475b60c900dce71f3f62d130
URL:http://rustconf2026.sched.com/event/8a4f8348475b60c900dce71f3f62d130
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T213000Z
DTEND:20260909T213500Z
SUMMARY:Crates in Firefox Over FFI
DESCRIPTION:We will look at integrating an existing crate (urlpattern) into Firefox's gecko platform (C++) to create a new Web API\, and some challenges martialing data across ffi boundary.
CATEGORIES:COMMUNITY LIGHTNING TALKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:8b30fa90439509d4696f44fce9d6765c
URL:http://rustconf2026.sched.com/event/8b30fa90439509d4696f44fce9d6765c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T214500Z
DTEND:20260909T215000Z
SUMMARY:Closing Remarks
DESCRIPTION:\n
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:ac3e3323538693f84a823394e048670b
URL:http://rustconf2026.sched.com/event/ac3e3323538693f84a823394e048670b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260909T220000Z
DTEND:20260909T233000Z
SUMMARY:🎉 Evening Reception
DESCRIPTION:Mingle with fellow Rustaceans after an exciting first day at RustConf! Appetizers and drinks will be provided.&nbsp\;
CATEGORIES:SOCIAL EVENTS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:7e3f66fb4e751ee72dc20d125bf94693
URL:http://rustconf2026.sched.com/event/7e3f66fb4e751ee72dc20d125bf94693
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T120000Z
DTEND:20260910T220000Z
SUMMARY:Registration and Badge Pickup
DESCRIPTION:\n
CATEGORIES:REGISTRATION
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:b3d612cc7c3b7f5cdadf3ce3288fed98
URL:http://rustconf2026.sched.com/event/b3d612cc7c3b7f5cdadf3ce3288fed98
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T130000Z
DTEND:20260910T133000Z
SUMMARY:Keynote - To Be Announced
DESCRIPTION:\n
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:9e292542935c1cc8ead40283a2da2430
URL:http://rustconf2026.sched.com/event/9e292542935c1cc8ead40283a2da2430
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T134000Z
DTEND:20260910T135000Z
SUMMARY:Project Update: Safety-Critical Rust Consortium
DESCRIPTION:\n
CATEGORIES:PROJECT UPDATES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:7f30dc753cfaabcf83c99ad8bb232586
URL:http://rustconf2026.sched.com/event/7f30dc753cfaabcf83c99ad8bb232586
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T143000Z
DTEND:20260910T150000Z
SUMMARY:☕️ Morning Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:e2f869755f4bae9073d6331c6158022d
URL:http://rustconf2026.sched.com/event/e2f869755f4bae9073d6331c6158022d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T150000Z
DTEND:20260910T154000Z
SUMMARY:Making GPUs Feel Native in Rust
DESCRIPTION:GPUs power some of the most important workloads in computing\, yet they still feel foreign in Rust. Today Rust can program GPUs\, adapting to GPU-native models. This talk explores the inverse: making GPUs Rust-native\, where the hardware feels like a natural part of the language.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:6f4a4a2897147a439da66f5fa0a02146
URL:http://rustconf2026.sched.com/event/6f4a4a2897147a439da66f5fa0a02146
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T150000Z
DTEND:20260910T154000Z
SUMMARY:Rust: The First 10 Years Were the Easiest
DESCRIPTION:We spent more than 10 years proving that Rust works. We focused on memory safety\, async\, and moved from a niche experiment to the Linux Kernel. \n\nBut building a revolution was easier than maintaining a global standard. As we head toward 2027\, the "honeymoon" phase is over\, and we are now facing the real challenges: managing decentralized governance\, navigating corporate pressure\, continuously evolving the language without breaking everything\, and addressing technical debt. \n\nThis session is a reality check on what happens when a language as disruptive as Rust becomes the establishment. Let’s skip the basics and focus on the system issues that will define the next 10 and more years of Rust. You thought the climb was hard\, but now the real game begins.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:c26f6e209aff916f3b35376337648f3f
URL:http://rustconf2026.sched.com/event/c26f6e209aff916f3b35376337648f3f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T150000Z
DTEND:20260910T154000Z
SUMMARY:Simulating a Million Patients: Realistic Health Data Generation in Rust
DESCRIPTION:Healthcare researchers desperately need realistic synthetic patient data: for teaching\, for testing analysis pipelines\, and for sharing results without compromising real patients' privacy. But generating data that's actually realistic is surprisingly hard. Naïve approaches produce patients who are statistically implausible: twenty-year-olds with dementia\, smokers whose blood pressure is unaffected by their habit\, populations where diabetes and hypertension never co-occur.\n \n This talk presents a graph-based approach to synthetic patient generation\, built in Rust\, that models how diseases actually progress through a human life. Using directed acyclic graphs with age-banded transition probabilities\, the system walks each simulated patient through decades of accumulating risk factors\, diagnoses\, and complications\, producing population-level data that preserves the statistical relationships epidemiologists rely on.\n \n We'll trace a concrete clinical scenario\, elderly patients developing diabetes\, then hypertension\, then suffering a transient ischaemic attack\, from its representation as a DAG\, through its implementation in Rust\, to its output as a million-row dataset. Along the way\, we'll cover the Rust design decisions that made this tractable: strong types that prevent impossible patient states\, seeded RNG for scientific reproducibility\, and the adaptor pattern that lets the same patient model emit records in different clinical formats.\n \n You don't need a medical background to follow this talk. You'll leave with transferable patterns for modelling complex real-world processes as graphs\, and a new appreciation for why Rust's type system is a gift to scientific computing.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:361c3ff20ec80720a6e15d55af836ed8
URL:http://rustconf2026.sched.com/event/361c3ff20ec80720a6e15d55af836ed8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T155000Z
DTEND:20260910T163000Z
SUMMARY:BorrowSanitizer: Securing Rust Across Foreign Function Boundaries
DESCRIPTION:From the Linux Kernel to Chromium\, Rust is increasingly finding its way into security-critical C++ applications. Developers who interoperate with these languages need to use Rust’s unsafe features to bypass the restrictions of the borrow checker. However\, when unsafe code is used incorrectly\, it can break the compiler’s assumptions about aliasing\, leading to silent\, “impossible” forms of undefined behavior that can cause critical errors at run-time. Miri—Rust’s de-facto bug-finding tool—has high overhead and limited support for foreign function calls\, which prevents it from finding these errors in multilanguage applications. We are creating BorrowSanitizer: a new dynamic bug-finding tool for finding violations of Rust’s newest “Tree Borrows” aliasing model in applications that interoperate with C++.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:6a3a924722c50868e6ec039413cddba3
URL:http://rustconf2026.sched.com/event/6a3a924722c50868e6ec039413cddba3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T155000Z
DTEND:20260910T163000Z
SUMMARY:Rust Atomics in the Wild: Memory Ordering Design Patterns from Popular Crates
DESCRIPTION:Modern Rust codebases use atomics for much more than simple shared-state coordination. When multiple atomics interact\, subtle behaviors can appear that are easy to miss and can look arbitrary at first. With a closer view\, a small set of recurring patterns shows up across many production systems\, and those patterns can be applied deliberately to solve nuanced coordination problems when both correctness and performance matter.\n \n This talk classifies these patterns by starting with a short refresher on Rust’s atomic memory model\, then framing the problems being solved\, describing the minimal structure of each pattern\, and connecting it to real implementations in widely used Rust crates and runtimes\n \n The five patterns covered are:\n 1. Publish and consume with Release and Acquire\n 2. One time initialization and fast paths\,\n 3. CAS driven state machines for coordination\n 4. Handoff via RMW and release sequences\n 5. Snapshot style reads using sequence counters and index publication.\n \nAttendees will see common pitfalls\, what correctness argument each ordering supports\, and where performance wins or losses typically come from. The goal is to make memory ordering choices reviewable\, explainable\, and repeatable.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:9120c98be13e192ca3f61b9f644ec4e8
URL:http://rustconf2026.sched.com/event/9120c98be13e192ca3f61b9f644ec4e8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T155000Z
DTEND:20260910T163000Z
SUMMARY:Rust for ML Infrastructure: A Case Study in Building an ONNX Runtime
DESCRIPTION:What does it take to build a machine learning inference engine in Rust - and what does that experience reveal about Rust as a language for ML infrastructure?\n \n This talk presents lessons learned from designing and implementing a GPU-accelerated ONNX runtime in Rust. The project\, Onyxia\, parses ONNX graphs\, compiles them through a multi-pass pipeline\, generates WGSL compute shaders\, and executes them via wgpu across desktop\, mobile\, and the web.\n \n The session focuses on how Rust's language\, tooling\, and ecosystem made the project possible. A friendly compiler and a strong type system make working with graphs a joy. Tests and documentation colocated with the code make it easy to understand the internals of the crates. Together\, these properties make it possible to build a runtime that is both efficient and understandable.\n \n The talk also reflects on Rust's growing adoption in machine learning infrastructure and the ecosystem crates that make such projects practical today.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:31470dd76a46c4d9f5a295c25d8a477b
URL:http://rustconf2026.sched.com/event/31470dd76a46c4d9f5a295c25d8a477b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T163000Z
DTEND:20260910T174500Z
SUMMARY:🍴 Lunch Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:cb85ebe5735667bf3b63293cfb9e1a00
URL:http://rustconf2026.sched.com/event/cb85ebe5735667bf3b63293cfb9e1a00
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T174500Z
DTEND:20260910T182500Z
SUMMARY:2 Hours to 10 Minutes: Building Rust Monorepos at Scale with Bazel RBE
DESCRIPTION:A Rust monorepo with multiple workspaces and a CI pipeline that routinely exceeded two hours with recurrent flaky results. After five iterations — GitHub Actions tuning\, shell script hacks\, self-hosted Prow and a custom Rust-based orchestrator — each improvement eventually hit a ceiling\, until the team spent more time debugging CI than shipping code.\n \n This talk is about the infrastructure that broke the cycle: Bazel Remote Build Execution on self-hosted bare metal\, bringing CI under ten minutes. Engineers can choose to use Cargo or Bazel locally — no workflow disruption.\n \n The talk walks through what was built\, why each previous approach hit its ceiling\, and what running an RBE cluster for Rust actually looks like in production.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:b907aa37bee4e2d8f6fbc653c845d613
URL:http://rustconf2026.sched.com/event/b907aa37bee4e2d8f6fbc653c845d613
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T174500Z
DTEND:20260910T182500Z
SUMMARY:Real-Time Rust in Robotics
DESCRIPTION:Robots are complex interconnections of subsystems which use a varied mix of software. David will describe a typical robot's architecture and highlight the areas where Rust is making headway. He will present his team's experience with bringing Rust to the low-level sensors and actuators on a research robotics platform\, showing how the use of bare-metal Rust improved the system's reliability and real-time performance. Finally\, he will suggest how the Rust community can encourage further adoption of Rust in robotics and related applications.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:048e4a6676e73e733fc3a79967983ae2
URL:http://rustconf2026.sched.com/event/048e4a6676e73e733fc3a79967983ae2
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T174500Z
DTEND:20260910T182500Z
SUMMARY:Servo Devtools: Where Rust Meets JavaScript
DESCRIPTION:Servo is a web rendering engine written in Rust\, one of the largest and oldest Rust projects out there. One of the areas we’re actively pushing forward is DevTools support\, connecting Servo to Firefox DevTools over the Remote Debug Protocol. This means writing a server in Rust that speaks with a client written in Javascript.\n \n Every browser engine needs DevTools\, but building them is a project in itself. In this talk we’ll look at what building DevTools for Servo looks like. The Inspector\, the Console\, the Debugger. What are the hard parts and what challenges we face. How we navigate a client written in JS\, a server written in Rust\, and the role SpiderMonkey(C++) and mozjs(Rust) play in making it all work.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:9fc01f98b58827cd1ebc48b4295de017
URL:http://rustconf2026.sched.com/event/9fc01f98b58827cd1ebc48b4295de017
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T183500Z
DTEND:20260910T191500Z
SUMMARY:TARmageddon: Reflections on a Multi-Crate CVE
DESCRIPTION:What happens when several people create popular forks of a Rust project and then a vulnerability impacts all of them? When we found a parsing vulnerability in tokio-tar\, dubbed TARmageddon\, we discovered how a simple oversight in TAR parsing logic can yield dangerous behavior... and then we discovered the widespread impact. We’ll walk through this vulnerability and how the responsible disclosure ended up sent to four different projects. We’ll look at how this disclosure became a scavenger hunt for maintainer email addresses\, popular forks\, and dependent projects.\n \n We'll then evaluate why this kind of forking might be more common in Rust and how the synchronous/asynchronous divide can result in disparate forks of Rust projects\, exploring methodologies to eliminate async/sync separation in common libraries.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:c4152bac383877b07765c613ec8dd5f0
URL:http://rustconf2026.sched.com/event/c4152bac383877b07765c613ec8dd5f0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T183500Z
DTEND:20260910T191500Z
SUMMARY:Tick Tock: Maintaining Time
DESCRIPTION:Learn what goes into maintaining a foundational crate in the Rust ecosystem\, from API design to constructing algorithms from scratch and catching bugs before they're noticed. An overview of recent optimizations\, handling of security vulnerabilities\, and some more niche topics will be covered as well!
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:3db5c0a687fc5f2890febd7488fb8f7f
URL:http://rustconf2026.sched.com/event/3db5c0a687fc5f2890febd7488fb8f7f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T183500Z
DTEND:20260910T191500Z
SUMMARY:Writing a Zero-Copy Database Parser from the Ground Up
DESCRIPTION:Building a high-performance database proxy demands wire-speed parsing with minimal overhead. This talk walks through the design and implementation of a zero-copy streaming parser in Rust that parses database wire protocols incrementally from the first byte received\, using a fixed-size ring buffer and arena-allocated borrow tracking to yield structured slices directly into the network buffer with no intermediate copies and constant memory regardless of payload size.\n \n The talk covers the core abstraction: a trait-based streaming API that uses Rust's type system to bind borrowed slices to the underlying ring buffer at compile time\, a ring buffer designed to allow concurrent immutable borrows of disjoint regions across async yields\, and a borrow tracker that manages lifetimes as the buffer is refilled. Attendees will see how a small ring buffer can parse and inspect every byte of an arbitrarily large payload\, how deterministic pattern matching eliminates backtracking on partial reads\, and where carefully scoped unsafe makes the design sound.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:1f711f0cea047090208e364b46c429f9
URL:http://rustconf2026.sched.com/event/1f711f0cea047090208e364b46c429f9
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T191500Z
DTEND:20260910T194500Z
SUMMARY:☕️ Afternoon Break
DESCRIPTION:\n
CATEGORIES:BREAKS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:ec4c338f4636386a9466ce8e7e0db938
URL:http://rustconf2026.sched.com/event/ec4c338f4636386a9466ce8e7e0db938
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T194500Z
DTEND:20260910T202500Z
SUMMARY:Beyond the &: A Future for Native Smart Pointers in Rust
DESCRIPTION:Rust is often described as a "library-first language\," yet user-defined smart pointers are second-class compared to built-in types like &\, &mut\, and Box. These native types enjoy special privileges\, like integration with the borrow checker\, that ordinary library types like Arc\, RefCell\, and PyRef cannot currently replicate. These limitations make Rust much clunkier than it has to be. They also prevent powerful concepts like in-place initialization from being expressed safely.\n \n This talk presents an update on the "Beyond the &" roadmap\, an initiative to bridge these gaps. We explore how exposing the borrow checker's fundamental primitives allows us to generalize standard "superpowers" to user-defined types. We discuss plans to extend the reference model itself by investigating new types like &own and &uninit\, which aim to solve long-standing issues with safe in-place construction.\n \n By mapping out these primitives\, we enable a future where pointer types like VolatilePtr and CppRef – as well as wrapper types like Cell and MaybeUninit – are as ergonomic to use as builtin types. This creates powerful new patterns for systems programming\, interoperability\, and abstraction.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:0a50c3675bc7862558c0bd27bf1e69a1
URL:http://rustconf2026.sched.com/event/0a50c3675bc7862558c0bd27bf1e69a1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T194500Z
DTEND:20260910T202500Z
SUMMARY:Oxidizing Fields of Mistria
DESCRIPTION:Fields of Mistria\, a cozy 2D pixel-art farming-sim\, was released in Early Access in 2025 to overwhelmingly positive reviews. We use a substantial amount of Rust at NPC Studio\, both in development and at runtime. This talk will cover how we started using Rust and how it has evolved during Early Access.
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:0ae277624afab6d4bea137c8831222c1
URL:http://rustconf2026.sched.com/event/0ae277624afab6d4bea137c8831222c1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T194500Z
DTEND:20260910T202500Z
SUMMARY:Tyr: A New Rust GPU Driver for the Linux Kernel
DESCRIPTION:This talk will discuss the new Rust kernel driver for Arm Mali GPUs. We will start by introducing the Linux GPU stack and follow with a brief overview on how modern GPUs work. This will segue into a discussion about the current status of the Tyr driver and its surrounding infrastructure\, including other Rust GPU drivers for the Linux kernel. We will conclude by discussing the future plans for the project and touch upon some of the issues that are still at large.\n
CATEGORIES:BREAKOUT SESSIONS
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:80ec77c35596a1b4e7fd85e148783b51
URL:http://rustconf2026.sched.com/event/80ec77c35596a1b4e7fd85e148783b51
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T203500Z
DTEND:20260910T212000Z
SUMMARY:Fireside Chat - Stewarding Rust & Python
DESCRIPTION:What does it take to steward two of the world's most widely used programming languages — and what can Rust and Python learn from each other?\nTo close RustConf 2026\, the executive leaders of the Rust Foundation and the Python Software Foundation sit down for a candid conversation on the challenges facing open source communities today: AI's impact on language ecosystems\, cross-ecosystem interoperability\, security priorities\, governance lessons\, and how to lead global communities in a rapidly changing world.&nbsp\;
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:321e2b8d3760ccf6b0e3d1c3a3f6c6cf
URL:http://rustconf2026.sched.com/event/321e2b8d3760ccf6b0e3d1c3a3f6c6cf
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260910T212000Z
DTEND:20260910T213000Z
SUMMARY:Closing Remarks
DESCRIPTION:\n
CATEGORIES:KEYNOTES
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:c1f6fba2a789298b68154465db561850
URL:http://rustconf2026.sched.com/event/c1f6fba2a789298b68154465db561850
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260911T120000Z
DTEND:20260911T160000Z
SUMMARY:Registration and Badge Pickup
DESCRIPTION:\n
CATEGORIES:REGISTRATION
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:77adc2145b78904dd39321f30537f0e8
URL:http://rustconf2026.sched.com/event/77adc2145b78904dd39321f30537f0e8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260531T182123Z
DTSTART:20260911T130000Z
DTEND:20260911T190000Z
SUMMARY:UnConference (Additional Registration Required)
DESCRIPTION:The RustConf “UnConference” is a beloved tradition of unstructured discussion following the main conference. The UnConf is all about immersive discussions and exchanging ideas between participants\, rather than following a typically structured program. Arrive with some ideas about the burning topics you’d like to discuss and get ready to jot them down and dive in with other Rustaceans! It’s a place for community discussions\, not sales or service pitching.\n\nThe UnConference is an optional add-on for in-person attendees only and is not included in RustConf tickets. UnConf tickets can be purchased for an additional fee.&nbsp\;
CATEGORIES:UNCONFERENCE
LOCATION:Palais des Congrès de Montréal\,  Palais des Congrès de Montréal
SEQUENCE:0
UID:4d879a8793e6281734ebf8639f9b53c0
URL:http://rustconf2026.sched.com/event/4d879a8793e6281734ebf8639f9b53c0
END:VEVENT
END:VCALENDAR