Accepted Talks

Beyond Memory Safety

Rust’s ownership model promises to solve memory safety and data races. However, research shows this model enables much more: it provides an excellent foundation for building tools that help us write correct software. In my talk, I will explain why researchers are so excited about Rust and how new tools could help prevent bugs in your software tomorrow.

more information

Developing a computer algebra system in Rust

In this talk I will introduce Symbolica, a novel, blazing-fast computer algebra system (CAS, e.g. sympy, Mathematica) written in Rust, which is currently in use by several universities.

more information

Ferris wins a Folkrace!

Rust shines in embedded systems!

One of the last robots I built is a small autonomous car that ultimately won a “folkrace” competition: a contest where up to five vehicles race together inside a closed track, where they must be able to avoid opponents and obstacles while completing laps as fast as possible, like in an actual car race.

more information

High performance code and the cost of safe code

It is generally accepted that the increase in safety of Rust’s safe code is worth the minimal performance hit that it incurs. This talk explores the specific case of very high performance code, and specifically a high-performance Brotli encoder, where safe code can be up 20-30% slower than unsafe code - even when using std::simd (and more if not), and discusses possible ways to bridge this gap.

more information

How to build a Linux Kernel Module in Rust? A brief introduction

The introduction of Rust as a second programming language in the Linux Kernel caused noticeable attention in the software developer community and beyond, as it promises a safer and more accessible way to write Kernel modules compared to good old plain C.

more information

Interactive Exploration of Nonlinear Ray Casting with Rust and wgpu

Light is commonly assumed to travel linearly from source to destination. There are however cases where the path of light can be bent or distorted. In the case of black holes for example, the light is attracted by a very strong gravitational center. Heated air can change the direction of light through the varying refraction caused by the temperature transition from heat source to environment. Creating an interactive environment for exploration of such phenomena may help in understanding the images they bring to life.

more information

Miri: checking your unsafe code for Undefined Behavior

In this talk I will explain what Miri is and how it can find bugs in your unsafe code. I will also briefly discuss some of the common cases of Undefined Behavior that you should be aware of when writing unsafe code.

more information

Modern Game Development using the Bevy Engine

The Bevy engine uses a novel purely data driven approach called “Entity-Component-System” (ECS) that makes development different from other game engines of the past. In this talk, I will explain what an ECS is, present the Bevy engine and show how to code simple games.

more information

Profile-Guided Optimization (PGO) in Rust: unknown parts

Profile-Guided Optimization (PGO) is a compiler optimization technique that helps with optimizing software based on a collected in runtime profile. This optimization is available for a long time in the Rustc compiler. But how smooth will be your experience when you try to adopt PGO in practice?

more information

PSA: You too can pack structs

This is an introductory talk. It is aimed at people that are not familiar with struct packing.

Struct packing is useful in a variety of situation, being aware of it can help reduce code complexity and improve performance. Yet, I’ve come across many rust developers who aren’t familiar with struct packing.

This talk presents struct packing, and crates available on that people may not be aware of, but should really use.

more information

Switching from C++ to RUST (from embedded devices perspective)

In this talk, I will share my journey of transitioning from 7 years of embedded software engineering experience in low-level C/C++ to embracing Rust in a commercial project.

more information

Targets Acquired: Rust builds for everyone, courtesy of GitHub Actions

Rust, with its ability to compile directly into native binaries, leverages LLVM to achieve remarkable efficiency across diverse computing environments. However, the wide range of architectures and operating systems presents a significant challenge: ensuring that Rust applications run smoothly on all platforms.

more information

Towards Zero-Copy Binary (De)Serialisation: TypeScript <-> Rust

JSON is the de facto standard for sharing data between backend services, but it’s neither type-safe nor cheap to parse. Enter the world of zero-copy binary protocols for Rust and TypeScript applications. Starting from non trivial datatypes you may find in your codebase - plus their JSON schema definition - we’ll discuss how to model them with Cap’n’Proto: a proven, zero-copy binary protocol used at Cloudflare, and crafted by the creator of Protobuf 2. Ready to level up your cross-language data handling process?

more information

Using Rust for Playing Soccer With Robots at RoboCup

The goal of the RoboCup is to play humans vs. autonomous robots in soccer matches by the year 2050. To drive progress toward this ambitious goal, annual competitions and conferences across various robotics sub-fields are held, to encourage research and development. Traditionally, robot programming has been dominated by languages like C++ and Python. However, first teams are adopting Rust for its benefits in safety, reliability, and performance.

more information

When to (not) use typestate

Sometimes Rust feels like magic when writing. It is often the case that this is because of typestate. A pattern where the state of a resource is embedded into a program’s types, making it hard for developers to write wrong code.

Rust’s type system, borrowing rules and ownership model make typestate a viable option and the pattern works better than in other mainstream programming languages. However, due to the unique and extensive way typestate is used in Rust new rustaceans often do not understand the pattern or use it in a wrong way.

more information