My subjective wrap-up of Eurorust 2025


by admin

This year’s Eurorust conference was organised in Paris at the Cité des Sciences, so it was a great opportunity to find out what’s new in rust ecosystem and also meet some of the people behind the project. Here is my subjective take on the conference highlights.

Workshops

The conference was preceded by one day of workshops. They ranged from computer vision to game engines. For full list see:

https://eurorust.eu/2025/schedule/#workshop-day

Edge AI with rust

I attended the edge AI workshop led by Alexandru Radovici, from Wyliodrin, Romania.

We deployed a face recognition model and LLM-based chat app on RaspberryPi 5 (with cooling and attached camera). The deployment was done with rust’s candle framework plus some helper libraries.

The instructor claimed that rust becomes popular for edge AI thanks to small binary size and wide range of platforms supported. It’s mostly used together with an existing rust application code. However, thanks to the maturity of python’s ML/AI ecosystem, the training is still done and probably will continue to be done with python-based frameworks (such as pytorch, tensorflow).

Some interesting rust AI/ML frameworks in rust:

  • candle (from huggingface, modelled after pytorch, dynamically typed)
  • burn (from tercel, most mature, with limited static typing support)

Link to materials: https://hedge-ai-101.wyliodrin.com

rust meetup

Paris Rust meetup took place the evening before the conference. It consisted of a couple of short talks followed by pizza and social event.

Three interesting tools were presented during first part:

  • graphite.rs – procedural painting
  • parse_int – rust library for flexible parsing of numbers
  • dioxus – rust’s full stack web framework.

Then came a crazy quiz prepared by Amos of the SDR podcast fame (see below) on the intricacies of rust compiler. I did better that just selecting the answers by random, but it was close enough.

Main conference

During the two days of conference plenty of talks were presented and also ample time for discussion was available during the breaks.

The main topics were:

  • rust compiler – present and future; optimization tricks used by the compiler
  • embedded devices
  • critical safety applications (mostly automotive)
  • rust adoption in industry and elswhere

Here are summaries of some notable presentation (according to my subjective selection).

rust idioms

This talk titled “Exemplary by Design” was presented by Jacob Pratt.

The main message was that an idiomatic code is easier to read and maintain, it has fewer bugs and it’s more secure. However, as new features are added to the language (remember the slogan “stability without stagnation”), the idioms may change and the code should be adapted.

Some popular idioms are:

  • using cargo workspaces for multiple repositories
  • rust analyser for code completion and clippy lints for linting/checking for misuse of some syntax
  • traits for shared behaviour
  • newtype pattern for specialisation of standard data types (for example for values with units)
  • embed enum in struct for the full control over its public API
  • new method for specification of default values is coming to rust (RFC 3681)

For testing:

  • use unit tests in the same file as the code
  • doctests within docstrings
  • integration tests should sit in a separate tests directory

Link to slides: https://jhpratt.dev/presentations/eurorust-2025/slides.pdf

SDR podcast recording

There were two sessions of live recording of Self Directed Reserach (SDR) podcast with Amos Wenger and James Munns. The first session was about a socket library implemented in rust and the second about optimization tricks used by the compiler.

Honestly, the discussion was very technical and went way beyond my knowledge of rust, compilers, assembly etc. However, I found it interesting to see how much code could be simplified and optimized away by the LLVM compiler such that the final assembly does not do some useless computation and uses much less instructions than a naive translation.

Link to podcast: https://sdr-podcast.com/

Rendering million pixels per second

This keynote was a kind of motivational talk presented by Conrad Irwin from Zed industries (zed is an editor that’s gaining traction in the rust ecosystem). Through a very personal story, he shared his dislike for “spinning wheels”, i.e. the interfaces that make users wait. He also presented the gpui framework for the user interfaces. His take home message was that software should not only be performant but also it should make other people feel good and productive. As someone noticed on the internal chat, this is a relatively high bar for all software engineers, but also for the company that wants to integrate the AI functionality into its products.

Rewrite, optimize, repeat

The author of ‘Zero to Production in Rust’ book, Luca Palmieri, shared his experience of porting the redis query plugin from c++ to rust. He said that migrations of large codebase should be done gradually, in a sort of hybrid system, where migrated code is exposed to the existing codebase with the FFI (foreign function interface). Then he took the audience through the details of redis’ Triemap implementation that uses some unsafe rust blocks to reach optimal performance. This implementation is then wrapped with safe code for the user facing API.

Data engineering with rust

It was probably one of the best dataeng talk I have ever listened to. Michele Vigilante, Vienna-based software engineer, took an example of fictitious online commerce company and showed how to build a data processing pipeline using rust/apache arrow/apache data fusion/delta-rs.

In this talk, I liked how Michele explained the what, why, and how of data engineering.

His use case was a typical OLAP pipeline rather than a explorative data analysis or prediction API, so he did not cover popular data science or machine learning utils.

He also shared some of his tips for data processing:

  • partition to limit data size
  • use event based triggering instead of scheduling
  • batch processing is easier tha streaming
  • parallelize IO
  • split pipelines into medallion architecture

Link to slides: https://github.com/vigimite/talks

People behind rust project

This was a non-technical talk that focused on the rust community itself. The community is reputed to be rather diverse and inclusive, but Rohit Dandamudi, a research scientist from British Columbia, went further and quantified the diversity by looking at the interaction networks on github projects (from the rust project organization). Not surprisingly, he found that most interactions are centered on few individuals, but he also discovered smaller scale sub-networks that group people of different nationalities and genders. For example, some countries with relatively small developer base, such as Romania and Iran, may be over-represented in terms of the number of contributions.

In general, Rohit aptly recognised that the existing seeds of diversity must be kept up and supported by targeted actions, so that the community can grow as a whole. One of such attempt is rust vision document which is currently being drafted by the community: https://rust-lang.github.io/rust-project-goals/2025h1/rust-vision-doc.html

You can read the full paper on arXiv : https://arxiv.org/abs/2503.22066

Wrap-up

In overall, this was a good conference and I much enjoyed hanging around the good rust folk. There is a decent interest in topics such as data processing, machine learning, data science etc in the community, so I think the rust ecosystem will continue growing in this area. I am definitely sold on the embedded devices part of the ecosystem (for example, the embassy crate looks great), so I will try to include it in some of my future projects.

There was also some substantial python bashing on the stage and in the corridors. The main complaints centered around python’s packaging system and its type system, i.e. something that rust really excels at (even compared to other system-level languages). I assume that the kind of language tribalism is typical for programming conferences, and it might be similar, for example, on EuroPython conference (maybe I will try attending it next year to find out).

Maybe see you next year in Barcelona?