MC Opening Address

Rust isn't a small language and it has a lot of features, functions, and tricks that a lot of items don't know about. I want to some light on those things, helping beginners write better code and reminding experienced developers that rust is actually p cool! The talk would be an unordered list of cool stuff™, like using array repeat expressions with non copy types, collecting into Result and other unconventional types, breaking with a value out of a loop, using const functions in more places than you'd expect, init-less let and its uses, anon import, by_ref functions/auto ref, docs on impl blocks, using patterns everywhere, exhaustive matches & uninhabited values, and so on!

This talk will show how codegen backends are implemented in the rust compiler and how they optimize the content we send to GCC to generate better assembly.

-

Computing is all about abstraction. Sometimes we peek at the layer under us such as compiler-generated assembly, but that still leaves a lot we take for granted. How do computers _really_ work? What if we went all the way down? Let’s build back up from fundamental physics and semiconductors, all the way to something that can be programmed in Rust.

Game engines like Unity and Unreal support both dedicated game servers and client-hosted models. While AAA titles often use dedicated servers, smaller multiplayer games typically rely on client-hosted architectures where one player runs the game session and a relay server only routes messages. This keeps infrastructure costs manageable – yet browser-based multiplayer games rarely adopt this pattern.
This talk shows how to adapt the client-hosted relay approach for browser-based board games using Rust. The relay server, built with Tokio and Axum, manages rooms and forwards messages without understanding the game state. On the client side, a three-layer architecture separates front end, transport, and game logic – compiled to WebAssembly via Macroquad.
A key challenge in async Rust is avoiding complex ownership patterns when sharing state between network tasks and game loops. The talk presents a drain-based approach that sidesteps the typical RefCell/Rc maze by maintaining a clear chain of command between layers: the transport layer polls for requested state changes rather than receiving pushed callbacks.
Outline:
•        Why client-hosted relay architectures suit small multiplayer games (and why browser games rarely use them)
•        Implementing the relay server with Tokio tasks and Axum WebSockets
•        The three-layer client model: front end, transport, game
•        Drain pattern in game state synchronization
•        Brief look at platform-specific challenges (WebSocket crates, egui input handling)
Attendees will leave with a reusable architectural pattern for low-cost multiplayer games and practical strategies for managing async state in Rust.

Building complex asynchronous applications in Rust often leads to tangled dependencies and testing nightmares. At Hyli, we developed a practical architecture to solve this: a message bus pattern that connects independent modules into a cohesive, high-performance system. Inspired by the Modular Monolith pattern, this approach enables flexibility, speed, and improves the developer experience, especially at the testing stage.Talk outline:1. The architecture: bus, modules, busClients
2. Performance benefits: async, flexible, zero latency
3. Developer experience: strong typing and testing-optimized

This is a talk about some recent and future changes in the Rust compiler, and a new feature called "externally implementable items". For now, just an implementation detail with a fun story, but maybe some day a feature that you too can use! We'll talk about both the compiler engineering and language design: what changes we're making in the compiler, and the collaborative process we go through in the rust project to make those changes.

-

Last year Thunderbird added support for Microsoft Exchange, the first time it grew built-in support for a new platform in over 20 years. This work involved figuring out how to build a modern implementation in an aging code base, and we naturally turned to Rust - also a first for Thunderbird!One of the more recent pieces of work in this project was implementing a queuing system for asynchronous requests. This may sound like an easy task, and I certainly thought so at first. In this talk, we'll go through the various iterations of this work, and the challenge to make it generic while preserving object safety.