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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 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.

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.

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.

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