Schedule

In this hands-on training, participants will learn how to design and build a full-fledged Man-In-The-Middle (MITM) tool using the Rust programming language. The course provides a practical dive into low-level networking, from Layer 2 packet crafting to HTTP/TLS interception.

LEVEL: Intermediate

This is a whole day long workshop.
According to the speaker, there will be pauses at 11:00 and 16:00 for coffee breaks and at 13:00 for lunch.

In this workshop we will learn how to program a line follower robot.

We will program the robot using async no_std Rust, and we will run the code in a very realistic physical simulation, where wheels can lose grip, motor responses are not linear, sensors have noise and other kinds of quirks, and we will see how all these issues become more problematic at higher speeds.

LEVEL: Intermediate

This is a whole day long workshop.
According to the speaker, there will be pauses at 11:00 and 16:00 for coffee breaks and at 13:00 for lunch.

In labs, hospitals, and research institutes, Rust is starting to appear where it matters most: places where correctness, clarity, and safety aren't just features, but the foundations of good science and reproducibility. This keynote explores how Rust is beginning to quietly transform the scientific and health domains, powering tools that are open, auditable, and built to last. From epidemiological software like synthetic data generators and codelist frameworks to environmental models and open biomedical infrastructure, we’ll spotlight projects that show how systems programming can serve the public good and support good science. We'll also reflect on the legacy of scientific tooling and how we can ensure the Rust tools we build today promote transparency, collaboration, and open science tomorrow.

LEVEL: Intermediate

Can you build mission-critical, high-performance infrastructure software in Rust without mastering its full complexity? Yes, you can — and I’ll show you how.

In this talk, I’ll share how I wrote (and still maintain!) a rock-solid infrastructure system for a 1,400-person hospital — in Rust — using what I affectionately call “just the friendly parts.” It manages employee lifecycles, synchronizes user data across 20+ proprietary systems, and ensures real-time legal compliance for medical qualifications — all with flawless uptime for over three years

LEVEL: Intermediate

Where your application allocates memory is a challenging task. Some valuable tools like Valgrid are hard to understand and use.
In this talk, we will implement a custom allocation from scratch that allows us to easily track memory allocation inside an application.
Finally, I will show how it can be used in your applications.

LEVEL: Advanced

Rust offers a powerful trait system that allows us to write highly polymorphic and reusable code. However, the restrictions of coherence and orphan rules have been a long standing problem and a source of confusion, limiting us from writing trait implementations that are more generic than they could have been.

LEVEL: Advanced

Axum makes writing a basic web service easy, but how do you keep it from getting all tangled up as it grows in size and complexity?

In this talk, we’ll walk through practical patterns, hard-earned lessons, and maybe even a bad joke or two. If you're ready to level up your Axum skills, this talk will help you to keep your web backend fast, clean and maintainable, without sacrificing your sanity.

LEVEL: Intermediate

Lightning Talks:

Rust’s reputation for being slow to compile can be a major obstacle for developers who value rapid iteration and feedback. The easy answer is that iteration is slower, but we need less cycles as the code written tends to be more correct.

We’ll explore strategies to take control of Rust’s compilation time, from optimizing compiler options and leveraging faster linkers or faster compilers, to reusing compilation results between projects with sccache or shared target folders.

LEVEL: Intermediate

Debugging Rust code can feel like navigating uncharted waters — especially when the tools were originally built for C and C++. In this talk, we’ll explore the key components of the Rust debugging experience across platforms, from compiler-generated debug info (DWARF/PDB) to console-based and GUI-based debuggers like GDB, LLDB, VSCode/CodeLLDB, WinDBG, and RustRover. We’ll break down what goes into debug info, what gets lost in translation, and how that affects your ability to introspect values and types.

LEVEL: Intermediate

Can we use machine learning to assist one of the most critical components of an operating system: the CPU scheduler?

In this talk, we explore how Rust and AI can be combined together to experiment with intelligent scheduling decisions in the Linux kernel.

LEVEL: Advanced

In July 2024, I was hired by the Rust Foundation to join the Rust Infrastructure team.
In this talk I will share my experience in the team, including our ways of working, the challenges we faced, the solutions we implemented to better serve the Rust Project and the Rust Community, and our plans to make the Rust infrastructure more efficient, secure, and reliable.

LEVEL: Introductory and Overview

Many real-world problems like scheduling, routing, and resource allocation are too complex for deterministic or greedy algorithms to solve effectively. When the solution space is chaotic, non-differentiable, or constrained by real-world uncertainty, we need smarter search strategies. That’s where Evolutionary Algorithms (EAs) come in.

This talk demonstrates how Genetic Algorithms (GAs), a powerful subset of EAs, can be paired with Rust’s core strengths—performance, ownership, and traits—to build fast, modular, and parallelizable solutions. I’ll show how Rust’s type system and concurrency model make it uniquely suited to implementing evolutionary approaches that are robust, scalable, and often more flexible than traditional methods.

LEVEL: Intermediate

The talk will contain the following sections:
1- the linux kernel, a general overview, unintentional obfuscations, and how a software engineer building similar software can navigate it
2- A fast 3 minute introduction to linux’s syscall naming conventions
3- challenges I’ve come across building intentrace
4- compare intentrace to strace
5- performance techniques
6- complexity in developer tooling

Final notes:
- some of the technical points in these sections are still being implemented in the intentrace codebase.

LEVEL: Introductory and Overview

A journey through the origin of Async Rust, why it is necessary (and when it’s not) and the issues caused by the “over-async” phenomenon.

We will also cover why for library maintainers it’s hard to create sync/async public API for their crates and how (and whether) we can mitigate it.

Showcasing maybe-fut a library that with the power of advanced proc macro is able to allow developers to expose sync and async API reusing the same code.

Eventually, we’ll conclude with some thoughts on an async Rust std library and how the language could overcome code duplication when implementing both APIs.

LEVEL: Intermediate

Terminals are essential tools for developers, but few understand how they actually work under the hood. This talk explores the architecture of terminal emulators by walking through the process of building one from scratch. From handling PTYs and ANSI escape codes to rendering text efficiently and managing input, we’ll uncover the hidden complexity behind the command line.
Attendees will gain a deeper understanding of terminal internals, systems programming, and the trade-offs involved in creating modern, high-performance developer tools.

LEVEL: Intermediate

When I first started learning Rust, I didn’t plan to build a tool that would sit at the center of a national HPC infrastructure. I just wanted to explore a new language. Fast forward to today, and that curiosity has grown into Manta—a system application designed to unify and simplify access to CSCS’s Alps infrastructure, which spans multiple geographically distributed HPE Cray EX machines.

LEVEL: Introductory and Overview

TBA

You know what's fun? Writing an interpreter for a tiny programming language. You know what's even more fun? Writing a JIT compiler for it!
In this talk, we'll walk through writing an interpreter for a very simple language along with a JIT compiler, and we'll discuss some of the many possible extensions for the language. We won't be building anything more than a toy, but it will be a great exercise in understanding how programming languages and compilers work under the hood. We'll quickly tour parsing and abstract syntax trees (ASTs), intermediate representation (IR) and static single assignment (SSA), examine a compiler backend, and briefly touch upon register allocation and optimizations.

LEVEL: Advanced

ECS or Entity-Component-System libararies in Rust are plenty because it combines two feats: Highly performant cache friendly access - something important in Games and simulations but also a more surprising one: simpler data sharing/reference semantics in Rust.

LEVEL: Introductory and Overview

TBA