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.

Bring your laptop, we will build a game.

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.

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.

New to Rust and feeling overwhelmed? This fast-paced, code-heavy session will demystify tricky concepts like the borrow checker, smart pointers, lifetimes, and async through live coding and interactive quizzes, giving you the confidence to fully enjoy and learn from the rest of the conference.

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.

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.

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.

All about panics in Rust!

Tame business rules with tests

What if you could see network packets?

Peer-2-Peer networks are essential for data-sovereignty, but they're very poorly understood. From 9+ years of building P2P tools in community, I've learnt that it's easier to show than tell. Join me for a tour of how I've used Bevy to visualise P2P data flows.

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 the Operations Research team, we help decision makers optimize decisions for various problems, such as routing and network planning. To have a greater impact, we aim to solve more problems with the tools we develop. This talk discusses the importance of composing business criteria to achieve this goal and how rust's type system makes it convenient and efficient.

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 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.

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.

Modern OpenAPI is a very flexible standard which bridges the gap between languages and frameworks. Embracing this standard allows easier transition to Rust and comprehension of the semantics of APIs. This talk encourages API specifications as a first principle which, as a public resource, accelerates client implementations, too.

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.

Let's build a programming language.

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.