Learn why Adobe is moving beyond C++ by integrating Rust to build better products faster and more securely. Explore our pragmatic migration strategy for a 78M line codebase, emphasizing incremental adoption and developer enablement over a risky rewrite. Gain insights into Adobe's journey towards a modern, safer, and more productive software development future.
Let's build a programming language.
Rust didn’t just make Postgres extensibility easier—it made it modern. With PGRX, you can build powerful extensions like custom types, aggregates, table access methods, and background workers using Rust code and tooling. This talk dives into how that shift happened, what it enables, and why it’s already reshaping the Postgres ecosystem from the ground up.
ScramVM compiles SQL to bytecode and executes queries via a specialized virtual machine with morsel-based parallelism. We'll explore how this Rust-built engine achieves high performance through intelligent work distribution, core-pinned thread pools, and optimized memory access patterns, sharing lessons learned implementing a production-grade query engine.
Frustration with slow long-distance file transfers led me to build qcp, an open-source tool that goes beyond the limitations of TCP. This is a story of problem-solving, software craftsmanship, and diving into Rust to create a faster and smoother way to move data around.
Blinksy is a Rust library for controlling LEDs in 1D, 2D, and 3D spatial layouts, designed for embedded systems (no-std & no-alloc). You model your LED setups as geometric shapes and create patterns that compute colors based on position and other parameters. This talk will share my creative journey with LEDs and how Rust can enable your journey too.
The Rust programming language and ecosystem changes the code you write, the way you write code, and the expectations you have. This talk goes beyond the hype and shows how the development workflow and expectations change when using this language.
Recently I undertook a massive rewrite of my custom software, Visor, from Ruby into Rust. Visor is a live coding environment and VJing app for creating and performing live visuals. This talk will describe the unique challenges I faced developing Visor and why I believe Rust lays a solid foundation for the tool now and into the future.
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
As a Rust developer, I thought, "Ofc I can learn guitar blazingly fast!"—little did I know.
I'll share my journey of using Rust to process live guitar audio and building a terminal-based app for practicing power chords and riffs, from signal visualization to real-time tuning.
Join me for a crossover of music, Rust, and terminals!
Designing a device that can confine a 100 million degree plasma is no easy task. In the case of magnetically confined fusion, this means designing a superconducting magnet powerful enough to lift an aircraft carrier. This talk discusses how we use Rust to optimise and design superconducting magnets that will operate under the extreme conditions required for fusion power.
The less people have used Rust, the stronger their opinion on how it gets used in production.
Let's separate fiction from reality and take a cold hard look at what the state of Rust in production really is.
It's not a secret that supply chain security is a major concern in 2025. What tools are available to help us make informed decisions on the crates that we use in the Rust software we develop?
Write your own device driver in Rust with the device-driver crate. In this practical talk, we'll be writing software to control an LED touch screen, the CST816S. Along the way, we'll see how some of Rust's high level features, such as the typestate pattern and procedural macros, make writing low level code a joy.
All about panics in Rust!
Tame business rules with tests
I'll explore transforming a React web app into an offline-first desktop application using Rust and Tauri. This covers implementing a SQLite database layer and sync engine in Rust, integrating NFC card reader functionality, and addressing e2e testing challenges. The insights come from my two-year journey developing a real-world application.
We'll look at what it takes to transform the output of the compiler into an executable. We'll then explore aspects of how the Wild linker is designed in order to reduce link times as well as going over some changes you can make to your projects so that they compile faster.
What was true in 2016 will be true in 2026.