Workshops

Intermediate: Participants should be comfortable with Rust ownership basics and async/await. This workshop does not cover async fundamentals.

Asynchronous Rust makes it possible to build highly concurrent systems—but structuring shared state correctly remains one of the most common sources of complexity for intermediate Rust developers. Even when code compiles, subtle contention, accidental locking across `.await`, and `Send + Sync` constraints can make larger systems difficult to reason about.

This workshop explores actor-based design as a practical architectural pattern for structuring async applications in Rust. Rather than sharing mutable state, actors encapsulate ownership behind message-driven boundaries, simplifying reasoning about concurrency, backpressure, and failure handling.

Participants will build a realistic async service step by step: starting from a single stateful actor, scaling to multi-worker designs, and introducing coordination, graceful shutdown, and production concerns. Throughout the workshop, we’ll examine tradeoffs, performance implications, and when actor-based approaches are the wrong tool.

Attendees will leave with practical patterns for isolating state, structuring concurrency boundaries, and scaling async systems without relying on pervasive shared mutable state.

Participants are expected to bring a laptop to work on hands-on exercises.

The workshop runs on stable Rust and requires only a standard Tokio setup (macOS, Linux, or Windows) and the Flume crate.

Beginner – Intermediate: Attendees should be familiar with Rust, C, and the Linux command line. Prior experience with Linux Kernel development is NOT required.

Rust is entering the Linux kernel, bringing memory safety and modern tooling to low-level systems programming. In this hands-on workshop, attendees will learn how to build a Linux kernel with Rust support enabled, set up a complete development environment targeting both x86-64 and aarch64, and write a practical Rust-based misc device driver. Along the way, we’ll explore kernel-space inter-process communication and the use of background tasks for asynchronous work, giving participants a concrete, end-to-end understanding of how Rust can be used to develop real Linux drivers today.

• Build and configure a Linux kernel with Rust support enabled
• Set up a productive Rust-for-Linux developent environment for both x86-64 and aarch64 targets (depending on what laptops attendees have)
• Write a basic misc device driver in Rust
• Implement kernel–user space inter-process communication in a Rust driver
• Understand the core Rust-for-Linux abstractions and how they map to traditional kernel concepts
• Leave with a working example and a repeatable workflow to continue experimenting with Rust in the Linux kernel

Participants are expected to bring a laptop to work on hands-on exercises.

Technical requirements:

• Linux x86 64bit or ARM64
• Ubuntu 24.04 LTS, Arch Linux, or Fedora 43 recommended
• GCC Compiler
• LLVM Compiler
• QEMU
• Rust 1.93
• Code Editor with rust-analyzer support

Attendees can run all these in a VM like VirtualBox if they have Windows or macOS.

Beginner – Intermediate: Attendees should be familiar with Rust and able to write basic Rust programs (functions, structs, error handling). Deep Rust expertise or prior FFI experience are NOT required.

Attendees should have a working knowledge of at least one target language: Swift, Kotlin/Java, Python, or Dart (enough to read simple function calls).

Using Advent of Code (AoC) puzzles as the substrate, participants build a working Rust FFI library from scratch, wrapping a real AoC solution in a C glue layer and calling it from multiple different target languages. By the end of the workshop, attendees leave with a working multi-language project, a replicable methodology, and hands-on intuition for the pitfalls that make production FFI hard.

AoC problems are uniquely well-suited for FFI practice because they have diverse input/output types (primitives, strings, iterators), a motivating narrative that makes repetition feel worthwhile, no production baggage — you can break things freely — and progressively increasing complexity across 12-25 days of problems each year. Unlike algorithm-focused competitive programming, this approach uses AoC’s rich problem variety to stress-test real cross-platform FFI patterns: string encoding mismatches between Java and Swift, async model incompatibilities, and the lowest-common-denominator constraints that make production FFI viable.

After this workshop, attendees will be able to:

• Use Advent of Code as a structured, low-stakes FFI practice environment — progressing from primitives to strings to async across multiple target languages.
• Design a C glue layer that accommodates the lowest-common-denominator constraints of diverse language runtimes, using cbindgen or UniFFI.
• Avoid common FFI pitfalls: string encoding mismatches between Swift/Java, async model incompatibilities, over-exposing Rust idioms that don’t translate across language boundaries.
• Evaluate whether FFI is the right architectural choice for a given situation, including honest assessment of the maintenance burden, onboarding cost, and performance trade-offs.
• Replicate the AoC-as-FFI-playground methodology in their own learning or team onboarding — with a structured progression and a working starter template to build from.

Attendees should arrive with:

• Laptop with Rust toolchain installed: rustup + latest stable cargo.
• A C compiler available: gcc or clang (standard on macOS/Linux; Windows users should use WSL2 or MSVC).
• Git, to clone the starter repository.

Attendees will receive a setup guide at least two weeks before the conference. Required installs:

• rustup update stable
• cargo install cbindgen
• Clone workshop starter repo (link TBD): includes skeleton code, test harnesses for each language target, and a self-check script that validates the environment.
• Optional (choose your language track ahead of time):
• Swift: Xcode Command Line Tools (macOS) or swift.org package (Linux)
• Kotlin/JNI: JDK 17+ and Gradle or Maven
• Python: Python 3.10+ with cffi installed (pip install cffi)
• Dart: Dart SDK 3.0+

A self-check script in the starter repo will verify the full setup and print a green checkmark or specific error messages. Attendees who can’t complete setup beforehand can pair with a neighbor — one working environment per pair is sufficient for exercises.

Intermediate: Assumes working knowledge of Rust (ownership, traits). Experience with C is not a prerequisite.

Rewriting a C codebase in Rust isn’t a big bang: it’s a marathon, where you execute a series of small, deliberate steps. This workshop teaches you how to do it incrementally, based on hard-won lessons from migrating production C codebases over to Rust.

We’ll start with FFI fundamentals (repr(C), bindgen, cbindgen), move to writing correct extern “C” interfaces, then work through a 4-step module rewrite process: encapsulate, rewrite, bridge, swap. Along the way, we’ll cover the pitfalls (mixed allocators, string encoding, performance overhead) and some of the high-level strategies you can use when planning out a large-scale migration. There will be hands-on exercises at each stage.

At the end of the workshop, participants will be able to:

• Set up bidirectional C/Rust FFI with appropriate tooling (bindgen, cbindgen)
• Write correct and ergonomic extern “C” functions
• Apply a systematic process to rewrite a C module in Rust
• Avoid common interoperability pitfalls

Participants are expected to bring a laptop to work on hands-on exercises. You’ll receive instructions via email, ahead of the workshop, detailing what software has to be installed beforehand.

Intermediate: Attendees should have a working knowledge of how to set up the Linux kernel development environment and build a driver. Beginners should attend Part 1 of this workshop in the morning to learn the basics required for Part 2 in the afternoon.

This workshop is an extension to “Hello, Kernel! Linux Driver Development in Rust – Part 1”. We aim to go beyond purely software-based examples by introducing embedded devices connected over USB. This will allow participants to experiment with Rust driver development against real, external hardware, and better understand how Rust fits into common kernel subsystems used in practice.

These exercises will cover the basics of device probing, binding a driver to a USB device, and handling simple data transfers, all while leveraging Rust-for-Linux abstractions to maintain safety and clarity. The goal is not to dive into complex USB internals, but to provide a practical, approachable introduction to USB driver development.

• Understand how USB works
• Understand how to write a small USB driver to control an external device
• Use background tasks to perform asynchronous work safely in kernel space

Participants are expected to bring a laptop that can connect to a USB device. Note: Some work laptops might block this for security reasons – please check!

• Laptop must have a USB-A port (or bring an adapter)
• Must bring a USB-A to USB-C cable or a USB-C to USB-C cable (TBD)

Other technical requirements:

• Linux x86 64bit or ARM64
• Ubuntu 24.04 LTS, Arch Linux, or Fedora 43 recommended
• GCC Compiler
• LLVM Compiler
• QEMU
• Rust 1.93
• Code Editor with rust-analyzer support

Attendees can run all these in a VM like VirtualBox if they have Windows or macOS.