Rust is an excellent default for building secure, reliable software. But, unfortunately, memory safety alone is not enough to provide security. This practical introduction to application security (AppSec) will give your team the tools that it needs to increase its security posture while continuing to ship.
Bring your laptop, we will build a game.
Your terminal can do more than you think and this workshop shows you how. Ratatui is the leading framework for building terminal user interfaces (TUIs) in Rust. This workshop by the framework's maintainer will get you cooking up some tasty terminal UIs in no time.
Learn full stack web development in Rust with one of the maintainers of the Leptos framework. This fun and practical workshop provides you all that you need to evaluate Rust's readiness for the web and to start building your first app.
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.
All about panics in Rust!
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.
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.
Creative coding is the practice of writing code to make digital artworks - but how can it be used to make visuals for live performance? This talk will showcase the VJing software I wrote to make that happen, and tell the story of why I rebuilt it with Rust.
Rust + LEDs = 💜. Rust empowers us to think at a high-level for low-level systems. Join me in how I made an LED cube with embedded Rust (no-std & no-alloc), and how you could too.
Tame business rules with tests
Last May we started with zero lines of code — and today we’ve built a fully S3-compatible object storage system. Powered by SPDK, Exaba runs everywhere from Raspberry Pi to exabyte-scale clusters. This talk shares why we chose Rust, how we tackled SPDK integration, and the lessons from building memory-safe, high-performance storage.
What if you could see network packets?
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.
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!
Zoo is building computer assisted drawing (CAD) software from scratch. Rust makes it possible for us to do hard things. This is our story.
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.
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?
At least 1-2 times per week, accidental breaking changes sneak into the new release of some popular Rust package, despite the maintainers' best efforts.
Why is this still a problem 10 years after Rust 1.0?
What will it take to finally stop such breakage, so we can have fearless cargo update?
We’ll look at some benchmarks for the Wild linker then do a deep dive on some of the techniques that have been used to make it fast. The focus will be on some of the more novel and interesting optimisations used. These optimisations aren’t linker-specific and might even be able to be used in your own code.
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.
WebAssembly promises a future for write once, run anywhere—but what happens when you want to run untrusted Wasm binaries from any language, inside a Rust runtime, with domain-specific api? Explore the gnarly details of building a domain-specific container/plugin system, bridging the mismatch between guest expectations and host responsibilities, ensuring safety and determinism, and meaningful error reporting.
Building web services in Rust is powerful — but bridging them to frontend apps and other services is a challenge. Meet ReflectAPI, a library that lets you write your APIs in Rust code once and automatically generate type-safe clients in TypeScript, Rust and beyond — helping Rust APIs reach the world without boilerplate and more confidence.
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.
What was true in 2016 will be true in 2026.