[Talk::Overflow #18] EuroRust 2025 Tech Talks

Rust’s Maturation from Systems Language to Production Workhorse

EuroRust 2025 took place October 9-10 in Paris, bringing together the European Rust community for two days of technical talks spanning desktop development, compiler internals, production deployment, and embedded systems. This wasn’t a conference about Rust’s potential—it was about Rust in production, at scale, solving real problems.

The conference showed where the ecosystem is investing energy: performance at scale, developer experience for large teams, and pushing the boundaries of what’s possible at compile time.

Top Talks

Rendering at 1 Million Pixels / Millisecond with GPUI — Conrad Irwin

Conrad Irwin, co-founder of Zed, delivers a masterclass on high-performance graphics rendering. He introduces GPUI, the Rust-based UI framework powering Zed, which achieves incredible rendering speeds by leveraging Rust’s unique ownership model and zero-cost abstractions. This talk is essential for anyone interested in the future of desktop applications, showing how Rust can outperform traditional C++ frameworks while providing modern, declarative UI paradigms. Irwin’s deep dive into the rendering pipeline reveals how Zed achieves its legendary responsiveness.

Building a Lightning-Fast Search Engine — Clément Renault

Clément Renault, CTO of Meilisearch, discusses the architectural decisions and engineering tradeoffs involved in building a search engine from scratch in Rust. The talk covers the transition from C++ to Rust, the importance of memory-mapped files, and how to optimize for both indexing speed and query latency. For backend engineers, this is a rare look into the internals of a production search engine, highlighting how Rust’s safety guarantees simplify concurrent programming in a performance-critical domain.

Data Engineering with Rust — Michele Vigilante

Michele Vigilante explores why Rust is becoming the go-to language for data-intensive applications. Traditionally dominated by Python and Java, data engineering is shifting toward Rust for its ability to handle massive datasets with minimal overhead. Vigilante walks through building high-throughput data pipelines, leveraging crates like arrow-rs and datafusion. This talk provides a practical blueprint for teams looking to migrate their data infra to Rust for significant cost and performance gains.

Are We Desktop Yet? — Victoria Brekenfeld

Victoria Brekenfeld, engineer working on System76’s COSMIC desktop environment, examines the state of Rust for desktop application development. The talk covers the challenges of building a full desktop environment in Rust, the maturity of GUI frameworks, and what’s still missing. For teams considering Rust for desktop apps, this is a reality check on tooling gaps, cross-platform rendering, and where the ecosystem needs to grow. COSMIC is one of the largest real-world tests of Rust for desktop—Brekenfeld’s insights come from shipping, not speculation.

How Rust Compiles — Noratrieb

Noratrieb walks through Rust’s compilation pipeline from source code to executable binary. This isn’t a surface-level overview—it’s a deep dive into HIR, MIR, LLVM IR, and how the compiler transforms your code at each stage. Understanding this pipeline matters when you’re debugging slow compile times, optimizing performance, or trying to understand why certain patterns produce better codegen. If you’ve ever wondered why Rust’s compiler is slow but the output is fast, this talk explains the tradeoffs.

Building and Maintaining Rust at Scale — Jacob Pratt

Jacob Pratt shares lessons from building and maintaining large Rust codebases. The talk addresses dependency management, API evolution, breaking changes, and how to structure projects for long-term maintainability. This is essential viewing for teams scaling Rust beyond a few microservices—Pratt covers the organizational and technical challenges that emerge when Rust codebases grow to hundreds of thousands of lines and multiple teams.

Misusing Const for Fn and Profit — Tristram Oaten

Tristram Oaten explores Rust’s compile-time computation capabilities through const functions, macros, and zero-cost abstractions. The talk demonstrates how to move runtime work to compile time, reducing binary size and improving performance. This is advanced Rust—Oaten shows techniques for offloading validation, parsing, and computation to the compiler, making your runtime code faster and safer. If you’re building performance-critical systems, these patterns are worth learning.

Rewrite, Optimize, Repeat: Our Journey Porting a Tracepoint from C to Rust — Luca Palmieri

Luca Palmieri documents the iterative process of porting a performance-critical C tracepoint to Rust. The talk covers initial rewrites, profiling, optimization, and the tradeoffs between idiomatic Rust and raw performance. Palmieri doesn’t sugarcoat the challenges—Rust’s safety guarantees sometimes conflict with low-level performance needs. This is a case study in pragmatic Rust: when to use unsafe, how to profile effectively, and how to balance safety with speed.

---

---

TL;DR — All Remaining Talks

Production Unsafe Rust — Muskan Paliwal

Muskan Paliwal discusses patterns for using unsafe Rust in production systems. The talk covers when unsafe is necessary, how to audit it, and strategies for minimizing risk while maintaining performance.

From any to this: using concrete error types instead of a catchall — Leo Kettmeir

Leo Kettmeir explores using concrete error types instead of dynamic Any types. The talk demonstrates how strong typing improves error handling, debugging, and API design in Rust applications.

Roto — Terts Diepraam

Terts Diepraam introduces Roto, a fast and safe scripting language for routing and filtering. The talk covers Roto’s design, its integration with Rust, and use cases for embedded scripting in network applications.

The Lego Line Follower Challenge — Massimiliano Mantione

Massimiliano Mantione shares lessons from building a Lego line-following robot in Rust. The talk covers embedded Rust, real-time constraints, and the challenges of hardware integration.

Reflection on the Humans Powering Rust Ecosystem — Rohit Dandamudi

Rohit Dandamudi reflects on the people and community behind Rust’s growth. The talk examines open-source sustainability, contributor burnout, and how the Rust community maintains its culture as the language scales.

---

Trust Your Benchmarks, Not Your Instincts: A Rust Performance Quiz — Arthur Pastel & Adrien Cacciaguerra

This interactive session challenges common performance assumptions in Rust. The co-founders of CodSpeed present real-world code snippets, asking the audience to guess which implementation is faster before revealing the actual benchmark results. The talk provides a practical look at how modern hardware, compiler optimizations, and Rust's abstractions interact in ways that often defy "common sense" intuition.

How to Fit an Elephant in a Rusty Refrigerator: Conquering a 7,000-Type API — Kiril Karaatanasov

An exploration of the architectural challenges involved in building a type-safe Rust client for a massive, legacy enterprise API. Karaatanasov discusses strategies for handling polymorphism mismatches, optimizing compile times when dealing with thousands of generated types, and transforming complex query systems into ergonomic, type-safe Rust code without sacrificing performance.

One Rust Binary to Fight Them All: How I Use Rust to Combat Human Trafficking — Brooke

A powerful case study on using Rust for social impact. Brooke discusses the development of a high-performance digital forensics tool used to analyze massive amounts of data in investigations against human trafficking. The talk focuses on building a single, portable, and extremely fast binary that can be deployed in diverse environments to provide investigators with immediate, actionable insights.

Compile-time Deadlock Detection in Rust using Petri Nets — Horacio Lisdero Scaffino

This talk introduces a tool that analyzes Rust programs at compile time to detect deadlocks and lost signals. By translating Rust’s Mid-level Intermediate Representation (MIR) into Petri Nets—a mathematical modeling language for distributed systems—the tool can verify thread interleavings and identify potential synchronization issues before the code ever runs.

Rust/C++ Interop: Carcinization or Intelligent Design? — Victor Ciura

A deep dive into the current state of interoperability between Rust and C++. Ciura examines the tradeoffs between various interop tools (like cxx and autocxx), ABI compatibility challenges, and the architectural patterns required to maintain a hybrid codebase. The talk focuses on pragmatic strategies for teams gradually migrating large C++ systems to Rust.

Building a Chatbot Service with Rust, WGPU, and Tokio — Ada Hieta

Ada Hieta demonstrates how to run machine learning inference locally using Rust, bypassing traditional Python-based stacks. The talk covers using WGPU for GPU-accelerated compute via WGSL shaders and integrating it with the Tokio async ecosystem to serve responses efficiently. It’s a blueprint for building high-performance, asynchronous ML services entirely in Rust.

-Znext-solver: what, why, and when — lcnr

A technical deep dive into the ongoing work on the Rust compiler's next-generation trait solver. lcnr explains the limitations of the current solver, the design goals of the new implementation (completeness, soundness, and performance), and how it will enable more advanced type system features while fixing long-standing compiler bugs.

Rust’s Memory Model: The Logic Behind Safe Concurrency — Martin Ombura Jr.

This session demystifies how Rust’s ownership and borrowing rules map to the hardware level. Ombura Jr. explains the atomic memory model, memory ordering (Relaxed, Acquire/Release, SeqCst), and how the compiler uses these rules to guarantee data-race freedom. Essential for engineers writing low-level concurrent primitives.

No Cars Were Harmed for This Talk: Automotive Rust, Amateur Style — Frank Lyaruu

A pragmatic and entertaining look at applying Rust in the automotive sector. Lyaruu shares experiences using Rust to interface with CAN buses and vehicle sensors, discussing the challenges of real-time constraints, hardware safety standards, and the benefits of Rust’s safety guarantees in an industry where software failure can have physical consequences.

How to Make Your Own Stream Operator — Willem Vanhulle

A practical guide to extending Rust's asynchronous streams. Vanhulle walks through the process of implementing custom stream adapters, focusing on the Stream and Poll traits. The talk covers common pitfalls in async state management and how to build reusable, high-performance stream processing components.

Random Seeds and State Machines: An Approach to Deterministic Simulation Testing — Alfonso Subiotto

Subiotto presents a methodology for testing complex distributed systems using deterministic simulation. By modeling system logic as state machines and controlling all sources of non-determinism (time, network, randomness) via a seedable runner, teams can reproduce rare "heisenbugs" consistently and speed up CI by orders of magnitude.

A Deep Dive into Serde-Driven Reflection — Ohad Ravid

While Rust lacks a built-in reflection system, serde can be leveraged to achieve similar goals. Ravid explores how to use the serde data model to build tools for runtime inspection, automatic UI generation, and generic data transformation, providing a powerful alternative to traditional macro-based reflection.

Porting Embassy to a Rust-based Embedded Operating System — Dănuț Aldea

A technical account of integrating the Embassy async runtime with TockOS, a secure, capability-based embedded OS. Aldea discusses the challenges of reconciling Embassy’s cooperative executor model with Tock’s kernel-enforced isolation, offering insights into the future of secure, async-first embedded development.

A Minimal Rust Kernel: Printing to QEMU with core::fmt — Philipp Schuster

A bare-metal tutorial on building a functional kernel starting from no_std. Schuster demonstrates how to set up basic hardware initialization and implement a serial driver that integrates with Rust's core::fmt infrastructure, allowing developers to use standard formatting macros in an environment without an OS.

What Actually Are Attributes? — Jana Dönzelmann

An exploration of one of Rust's most flexible but misunderstood features. Dönzelmann explains the different types of attributes (built-in, tool, and procedural macro attributes), how the compiler processes them, and how to use them effectively to control compilation, generate code, and implement domain-specific logic.

Panic! At The Disk Oh! - Jonas Kruckenberg

An investigation into the complex world of filesystem errors and crash consistency in Rust. Kruckenberg discusses how to handle disk-related panics, the realities of fsync, and how to build resilient data storage systems that can survive power loss and hardware failures without corrupting data.

---

💬 Like what you read?

You’re reading [Talk::Overflow #17] Nordic.js 2025 Tech Talks — the weekly digest for developers who want to stay sharp and skip the noise.
→ Browse past issues
→ Suggest a talk
→ Share it with the friends

Stay curious. Stay kind.

— Talk::Overflow

---