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:00 and for lunch at 13:00.

LEVEL: Advanced


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:00 and for lunch at 13:00.

Our goal is to guide participants from a solid theoretical foundation to more advanced patterns such as Federation and the Strangler Pattern.
We will use a Test-Driven Learning approach: participants will work on a dedicated repository where each branch represents a challenge, and specific tests must pass before they can progress to the next concept.

LEVEL: Introductory and Overview

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:00 and for lunch at 13:00.

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

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

Trillions of dollars and thousands of lives... This is what software complexity costs companies, governments, and individuals.

To minimize this cost and maximize value, we must begin viewing software simplicity as a service to ourselves, to our team, and to society.

This is a practical talk for engineers and leaders seeking actionable guidance on creating high-value software with Rust.

LEVEL: Introductory & Overview

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

CHERI enforces memory safety at the hardware level. Platforms that support it have pointer semantics that differ significantly from those of conventional platforms.

This talk explores what it takes to enable Rust to support a specific CHERI-based platform, and what value we get back from it.

LEVEL: Intermediate

In this talk we are going to explore how to improve Go code generation in coding agents. The goal is to show how to use engineering best practices to "tame the vibes" and reduce AI generated slop, improving code quality and consistency of the responses.

The talk will show examples running on Gemini CLI, but the lessons learned can be applied to any coding agent that supports the described patterns and open source standards including: prompting / context engineering, planning mode, MCP servers, Agent Skills, hooks, sub-agents and others.

LEVEL: Intermediate

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

La strategia di Microsoft sull'intelligenza artificiale è aiutare le organizzazioni a trasformare il modo in cui lavorano, rendendo le persone più produttive, accelerando i processi decisionali e valorizzando il patrimonio di dati e conoscenze aziendali per generare crescita, innovazione e vantaggio competitivo. Perché questo valore sia sostenibile nel tempo, l'AI deve essere adottata in modo sicuro, governato e responsabile, garantendo fiducia, controllo e protezione delle informazioni. La sicurezza non è quindi un elemento separato, ma una componente integrata della trasformazione, che consente alle aziende di individuare e mitigare le vulnerabilità, ridurre il rischio, rafforzare la resilienza del business e permettere ai team di concentrarsi sulle attività a maggior valore.

This talk will be delivered in Italian

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

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

Prima decidere chi vogliamo essere, poi il digitale che ci serve: strategia e operational excellence nel manufacturing.

Avere processi perfetti, fabbriche efficienti e KPI impeccabili non serve a nulla se stiamo facendo la cosa sbagliata. Nell'economia digitale, il terreno di gioco e il concetto di valore sono cambiati: senza un posizionamento strategico chiaro, l'eccellenza operativa diventa solo un modo più efficiente per difendere il passato. Pertanto, il digitale non è una sommatoria di tecnologie, ma una scelta di identità che ridisegna processi, organizzazione, competenze, prodotti e modelli di business. Dunque, il vero rischio non è restare indietro sulla tecnologia, ma diventare straordinariamente bravi a competere in un mercato che non esiste più.

This talk will be delivered in Italian.

Come superare il pilot purgatory e rendere l’AI industriale una capacità operativa.

Il problema non è dimostrare che un algoritmo funzioni: è trasformare una sperimentazione
locale in una capacità affidabile, sostenibile e replicabile nei processi industriali. Il talk propone una chiave di
lettura concreta per capire perché tanti progetti restano piloti e quali condizioni servono per portarli a scala.


This talk will be delivered in Italian.

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

Come l'Intelligenza Artificiale cambia il futuro del controllo e dell'efficienza

La convergenza tra transizione energetica, instabilità geopolitica e digitalizzazione pone il settore HVAC/R di fronte a una sfida senza precedenti.
Tecnologie emergenti come AI Edge e Small Language Models promettono di evolvere i prodotti da semplici asset meccanici a piattaforme intelligenti in grado di ottimizzare prestazioni, consumi e manutenzione. Tuttavia, il valore generato non è scontato: l'introduzione di queste capacità comporta un incremento dei costi hardware, software e di sviluppo che deve essere compensato da benefici misurabili per clienti e costruttori.
La vera sfida sarà individuare il punto di equilibrio tra innovazione tecnologica, sostenibilità economica e creazione di nuovi flussi di ricavi basati sui servizi.

This talk will be delivered in Italian.

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

Pattern matching is at the heart of compilers—but it’s often buried in complex, hard-to-read code.

What if we could make it visual—and declarative?

In this talk, we explore a new approach where flowcharts represent pattern matching logic as tree structures, inspired by logic programming. Instead of writing matching rules directly in code, they are defined visually and compiled into Rust.

LEVEL: Intermediate

Tavola rotonda con gli speaker della Trendy Techs Track moderata da Alexandr Vannas (Develer)

This panel will be delivered in Italian.

Come sta evolvendo l’esigenza di hardware sempre più performante a fronte dell’avvento dell’AI: dalla domanda crescente di nuova capacità di elaborazione alla crisi di disponibilità delle memorie, che ha generato e continua a generare un’impennata dei prezzi.

Come affrontare la transizione verso l’AI: dalla localizzazione dei dati in locale (on-premise) fino al cloud.

This talk will be delivered in Italian.

When working on software it's easy to get buried in technical details and lose sight of the human element. Yet, having worked in the Rust Project for the last 6 years and now co-leading its Compiler Team, I would consider this to be one of the most important parts of what we do.

In this talk I'll explain why the social side of software development is so important, and how you can approach technical collaborations in a way that puts the people first.

Mentre le aziende manifatturiere investono sempre più nell'Intelligenza Artificiale, il vero valore nasce dalla capacità di connettere dati e conoscenza lungo l'intero ciclo di vita del prodotto. Se progettazione e produzione definiscono l'intento del prodotto, il service ne racconta il comportamento reale sul campo.

In questo intervento esploreremo come ontologie di prodotto, contesto lifecycle e dati di servizio possano creare le fondamenta per un'AI realmente efficace. Vedremo come eventi di manutenzione, storia degli asset e conoscenza acquisita sul campo consentano di chiudere il ciclo tra progettazione, fabbrica e operazioni, trasformando il service da funzione operativa a fonte strategica di Product Intelligence.

TBA

In previous RustLab editions, we showed how to build a working Linux kernel
scheduler in user space with Rust, using a C-based BPF layer to channel
scheduling events between the kernel and the user-space Rust scheduler.

The talk will show what it takes to compile Rust for BPF, how to reproduce
Linux's EEVDF fair scheduling behavior, and how this implementation performs
against the default kernel scheduler written in C.

LEVEL: Advanced

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

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

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

Let's cook up a terminal that goes beyond text.

This talk explores building a 3D terminal emulator in Rust with Ratatui and Bevy, covering its architecture, implementation, and the challenges of blending terminal rendering with an interactive 3D world.

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

Most conversations about Rust centre on memory safety, performance, and systems programming.
This talk makes a different case.
It presents the story of Rori, a WhatsApp-based math tutor serving students in low-resource schools across six African countries, built by a small team at Rising Academies.
The talk covers the real engineering decisions made and lessons learnt to keep Rust idiomatic at system boundaries, the team's standards and best practices arrived at through much iteration, and the cost and sustainability consequences that made Rust the right choice for a non-tech organisation building software for the long game of Education.
It closes with a proposition to expand the audience's imagination for where and why we build with Rust.

LEVEL: Intermediate