Schedule

This is a live-coding session in which I explain the main concepts behind AI applications (LLMs, chatbot REPLs, context, RAGs, agents, etc.) and we implement them in Rust using some open-source libraries to produce a working version.
Participants may code along or just watch, make suggestions, and ask questions.

LEVEL: Introductionary and Overview

Would you like to program robots?

Would you also like to experiment with different robot control algorithms in a flexible and dynamic environment, with quick iteration times, without the need to spend money on real hardware?

Then this workshop is for you!

LEVEL: Intermediate

NOTE: This workshop is a whole day long workshop. 
Accordingly with the speakers, there will be pauses for coffee breaks at 11:00 and 16:30 and for lunch at 13:00.

LEVEL: Advanced

In this workshop, we will build a secure communication protocol from scratch. We are going to move away from messy logic and use the Rust compiler to enforce security rules. Using the Bastion Engine as our guide, we will create a system where a device cannot send data until it is fully authenticated.

LEVEL: Intermediate

TBA

Over the past seven years, I have been using cargo in anger across many different projects, some open source, some internal, and I have a track record of writing about continuous integration, caching, etc.

I'm making a build system designed to be largely compatible with cargo, but that gives properties like hermetic builds, remote execution, perfect caching, etc., that you normally would only get with build systems like Buck2 which have a high set up and maintenance cost.

LEVEL: Intermediate

Rust developers trust `match` to catch unhandled cases, but how does this bit of compiler magic actually work? While building Lisette, a language inspired by Rust that compiles to Go, I found myself implementing an exhaustiveness checker from scratch in Rust using a Maranget-style algorithm. This turned Rust's familiar behavior into explicit machinery and concrete design decisions. 
In this talk, I'll show how exhaustiveness checking works in Lisette: how patterns are normalized, how specialization drives the recursion, how missing coverage is reported through witnesses, and why edge cases like or-patterns, uninhabited types, and slice matching complicate the story.
The result is a practical mental model of the guarantees Rust programmers rely on every time they write a `match` expression.

LEVEL: Intermediate

Burn and Candle are two of the most visible ML frameworks in the Rust ecosystem, but they emphasize different trade-offs.

Burn is framework-oriented: pluggable backends via its Backend trait, automatic kernel fusion, async execution, ONNX import, and a full training story complete with a terminal dashboard. Candle is more minimalist: a PyTorch-inspired API from Hugging Face with a strong focus on lightweight inference and serverless deployment, while still supporting training.

LEVEL: Introductory and Overview

TBA

As robotics systems scale in complexity, integrating algorithm developers, machine learning engineers, and control experts becomes increasingly difficult, particularly when relying on traditional stacks like C++ and ROS. This talk presents Copper, a robotics runtime designed to simplify integration and improve system reliability.

Built in Rust, Copper combines systems-level performance with strong safety guarantees, addressing long-standing challenges such as concurrency bugs and undefined behavior while remaining approachable for developers across disciplines. Through concrete examples and code snippets, the talk highlights how Rust enables robust concurrent execution, safer algorithm design, and a tighter connection between low-level control and high-level system architecture.

Attendees will leave with a clear understanding of how Copper streamlines robotics development into a more cohesive, efficient, and reliable workflow.

LEVEL: Intermediate

Did you ever dream of building your own keyboard, game controller, or custom input device? No? Well maybe you should.

In this talk, I’ll show you how surprisingly accessible this is using Rust. We’ll cover the fundamentals of embedded programming, then walk through building real devices like stream decks, presentation clickers, and game controllers.

LEVEL: Intermediate

This is a fun project about creating Game Boy video games in Rust. It starts by exploring how the Game Boy’s hardware and software work, then explains why you can’t traditionally make Game Boy games in Rust—and how this project was created to solve that problem.
It’s not a destination; it’s a journey!

LEVEL: Introductory and Overview

TBA

A feature flag evaluation service handling ~500k req/min across 300 Django pods was hitting hard scaling limits: cascading failures from database pressure, fragile connection pooling, complex timeouts, and ballooning costs. When 10x growth projections made it clear the architecture wouldn't hold, the team rewrote it in Rust in under 3 quarters. This talk covers the full arc – the decisions, the execution, the results, and the consequences.

LEVEL: Advanced

What does it look like to build an audio DSP pipeline in Rust?

In this talk, we will go from raw audio samples to frequency-domain features using a composable, high-performance pipeline. Along the way, we implement core primitives like windowing and FFTs, and explore how to structure processing stages without unnecessary allocations.

LEVEL: Advanced

How Rust allows a user-space TCP/IP stack to be deployed across a hundred servers, serving tens of thousands of requests per second whilst looking like a Windows, Linux and Apple device.

LEVEL: Intermediate

TBA

TBA

Does "Arc Mutex T" make you feel uncomfortable too?

In an async world, we can happily use Tokio to write applications which communicate. Apart from the basics, and unbeknownst to many, Tokio gives us all the primitives we need to structure our apps in a maintainable, testable, and reusable way: the actor model.
But there are many ways to implement actors, and some lack good testability, require magic, or constrain the user needlessly. Additionally, actors are only one side of the story! The others are channels and future combinators.

LEVEL: Intermediate

Do you like optimizing code? Do you feel the adrenaline rush of making things unnecessarily fast? Do you get frustrated when slow programs are single-threaded? Then I *cannot* recommend concurrent data structures. Stay away from them -- they are awfully fun and awfully painful.

In this talk, I'll show you why. I'm writing a Rust compiler with performance as the first priority, and I've written several concurrent data structures to help it parallelize work. Each one was a distinct monster that needed a unique approach; but I have collected some common tools and paradigms that ease that work. I'm going to talk about the very worst one -- managing heap allocations. You see, in the dark and subtle world of concurrent programming, there may be ghosts on your heap.

LEVEL: Advanced

CGI is largely forgotten but combined with Rust, it becomes a surprisingly practical deployment model for shared hosting. This session revisits the Common Gateway Interface and shows how to build simple, robust, and cost-effective web backends without a running server process.
Drawing on real B2B projects in industrial measurement, we cover webhook handlers and payment integrations built with cgi-rs, axum-based routes, and tower middleware including a performance comparison between Rust CGI and PHP.

LEVEL: Intermediate

Not tested, Proved. You’ll see what formal verification looks like in practice, what it actually guarantees, and why it’s worth the effort. If you’re interested in writing safer code or just want to understand where bugs hide in protocol implementations, this session will give you a clear, practical overview.

We will use a real work with real use as an example, how can we add formal verification on the CI and have more guarantees of safety without any runtime penalty.

LEVEL: Intermediate

I spent years automating infrastructure with scripts that worked until they didn't. A missing dependency, a half-applied deploy, a config that looked right but wasn't — the alert always came at 3am. The tools I used typed individual resources but not the relationships between them. The dependency graph lived in my head.

So I rebuilt it around one idea: infrastructure deserves the same type discipline as application code. Not just resource validation — typed contracts over the entire composition. Every deployment facet — networking, secrets, orchestration, monitoring, a control center, a cryptographic vault — is an independent module that composes through contracts, not glue scripts. The deploy is a typed DAG with parallel resolution, automatic rollback, and state recovery. Event-driven coordination keeps services in sync. Agents and RAG operate over the same typed structure. If it doesn't typecheck, it doesn't touch a server.

LEVEL: Intermediate

What if domain experts could express arbitrary, complex computations in a declarative manner—testing and deploying new business logic without changing a single line of the underlying software?

In this talk, we will explore how we leveraged Rust to build a high-performance, custom DSL and execution engine for the national electrical grid. You will learn how to design systems that allow non-technical users to safely define complex mathematical workflows, execute them with systems-level efficiency (leveraging vectorized logic and SIMD), and seamlessly interface with the rest of your infrastructure via JSON.

LEVEL: Intermediate

TBA

TBA

Lightning Talks, 03/11/2026

This talk will give an overview what you need to consider if you plan to develop building an interpreter or compiler for your own domain-specific language in Rust.
We will share our experiences and lessons learned when developing µcad, a Rust-based domain-specific language for geometry descriptions.

LEVEL: Advanced

Have you ever wondered how your phone finds the nearest coffee shop, or how millions of GPS points get turned into a meaningful map?
Behind the scenes, it all comes down to geospatial data, and making sense of it requires efficient storage and analysis. In this talk, I'll walk you through the essentials of geospatial processing in Rust using a hands-on use case covering spatial indexing, geospatial operations, and data serialization. For each step, you'll see practical solutions, as well as a few alternatives and common pitfalls.
Whether you're new to geospatial or already familiar with the domain, you'll walk away with a solid understanding of what Rust's ecosystem has to offer and a few hard-earned lessons to save you some headaches. And yes, you'll also finally find out where Rust is on a map.

LEVEL: Intermediate

An overview of what happens when you're tasked to write a firmware for a custom embedded device that is supposed to run on a single battery-charge for many months.

LEVEL: Introductory and Overview