Alice is a software engineer at Google, where she works on a driver for the Linux Kernel in Rust, as part of the Android Rust team. She is also a core maintainer of Tokio.
Arc in the Linux Kernel
The Linux Kernel is a very special codebase with a lot of restrictions on how you can write your code. In this talk, you will hear about how Rust has to adapt to work in the Linux Kernel. We will be looking at the kernel's extensive use of linked lists, and how we need to change our Arc to work in that environment, as well as the various unstable compiler features that we are using to make that happen.
Talk title and abstract to be announced
Raph Levien is a research software engineer on the Google Fonts team, primarily working on GPU font rendering. He’s been actively involved in the Rust community for over seven years, and has worked on pulldown-cmark, the Druid UI toolkit, and other popular crates. He has a PhD from UC Berkeley on the topic of interactive curve editing, and has been involved in font creation and 2D graphics tools most of his career.
Xilem: let's build high performance Rust UI
Xilem is a new UI toolkit designed for high performance and idiomatic expression of UI and app logic, suitable for both desktop and mobile. Xilem is built in a layered architecture. At the top is a reactive layer where views are simple statically typed Rust structs (though type erasure is possible), and no macros are needed. The widget layer is evolved from Druid. At the infrastructure layer is Vello, a 2D rendering engine using GPU compute shaders, specially tuned for dynamic vector graphics content. The text stack is also tuned for performance, including supporting animation of variable font parameters. Accessibility is a primary goal, and integration with AccessKit is baked in from the start. Another goal is interop with other projects in the Rust ecosystem, including wgpu, and providing a clean abstraction layer for widgets. It is work in progress, with a strong open source community driving toward ambitious goals.
Nicholas Matsakis is a Senior Principal Engineer at AWS and co-lead of the open source Rust language design team. He has worked on Rust since 2011, and led the design of its “secret sauce”, the borrow checker. He has played a number of other roles in Rust over the years, such as being a member of the Rust core team, the lead of the Rust compiler team, and helping to launch the Rust Foundation. Prior to working on Rust, he completed a PhD at ETH Zurich and did his undergraduate study at MIT.
Type theory for busy engineers
Joe is the original author of Rustls - a TLS library in Rust - which he started in 2016. Since June 2023 he has been funded by ISRG's Prossimo project to work on Rustls full-time.
Replacing OpenSSL, one step at a time
rustls-libssl is a new project that provides a drop-in replacement for OpenSSL's libssl, with the goal of easy retrofitting of memory-safe TLS into existing applications. The talk will start with a general overview of recent work on rustls and then introduce rustls-libssl. We'll dive into some of the challenges Joe has encountered, like 1) various depraved details of the openssl API that made this project particularly challenging, 2) building a shared library from rust, with correctly versioned symbols, 3) writing rust emulations of your native dependencies so miri can run all your tests.
Kevin Boos is currently a software architect at Futurewei working on Project Robius, a new open-source framework for multi-platform app development in pure Rust (including mobile!). Kevin is also the creator of Theseus OS, an open-source OS written from scratch in Rust that rethinks OS structure and implementation strategy, with an emphasis on maximally leveraging PL mechanisms for compile-time safety and verifiable correctness. Kevin obtained his PhD from Rice University with a focus on OS design and continues to collaborate with academic researchers in the PL & OS fields to publish novel work in top computer engineering conferences.
Robius: Immersive and Seamless Multi-platform App Development in Rust
Project Robius is a new community-driven framework that enables developers to create robust, efficient, and immersive applications in Rust that seamlessly run on many platforms, including desktop, mobile, and web. In this talk, we’ll describe our ongoing work to improve the Rust app dev experience, including a brief overview of key constituent projects like the Makepad UI toolkit and the Osiris project for abstracting platform APIs and OS services. We’ll also demonstrate some applications written using the Robius framework, namely Robrix, a new Matrix chat client app that runs on mobile and desktop. Finally, we'll conclude with a roadmap for our future technical plans, along with more info on how you can join the community and get involved in the world of Rust app dev.
Jonas is passionate about benevolent software, Open-Source, and Cybersecurity. So far his journey led him to work on optimising websites using Vite, local first software, peer-to-peer networking, verifiable computation, extensible software and now cross-platform native apps. Aside from programming, he sings in several classical ensembles (talk to him if you love music!) and loves hiking.
K23: A secure research OS running WASM
K23 offers a fresh look a OS design. It is entirely written in Rust with an integrated WASM JIT compiler that tries to answer what an OS built for the 21st century could look like. We will cover the general ideas behind K23 and its inspirations. We'll go over the project progress so far, and detail a few points that are of interest to the Rust crowd: various nightly features used, custom debugging tools, and a few stories from embedded Rust development.
James is a software engineer currently living in Berlin. He primarily works with Rust and Embedded Systems.
Postcard: an unreasonably effective tool for machine to machine communication
Postcard is a binary wire format, a crate providing a `serde` backend, and a growing ecosystem of tools for getting computers, even small embedded ones, productively talking to each other. This talk explores where postcard came from, how it is used today, and how you can use it for building quick, pragmatic, and effective communication protocols for your projects.
Visual application design for Rust
In this talk I will show the new MIT licensed visual application design tool for Makepad. We will walk through our fun new AI examples with generative image and text models and look at the lessons learned developing these applications in Rust.
Henk is an embedded software engineer and one of the lucky people that mainly use Rust in embedded. He's so passionate about Rust that he can't help spreading the word by hosting Rust training for all kinds of areas, and by developing teach-rs, the modular, reusable Rust university course platform.
Oxidizing Education
For Rust to really take off, we have a cycle to break: companies need Rust developers to start doing Rust, and developers need Rust jobs to start learning Rust. To break the cycle, we can oxidize education: enable universities to start teaching Rust. This talk is about how we can do just that.
At Tweede Golf Folkert works on using rust in critical infrastructure, e.g. time synchronization, secure communication and data compression. Additionally he works on the roc compiler (roc-lang.org), which he considers an excellent excuse to play around with academic compiler literature, linkers and assembly.
Compression carcinized: implementing zlib in Rust
Data compression is used when loading almost anything on the web. This talk is about the implementation of zlib-rs. We'll explore how compression works, how to convert a C project to rust, maintain its performance, and foster adoption.
Leon Schuermann is a second-year Ph.D. student in the SNS group at Princeton University, focusing on research in the areas of secure and embedded operating systems. He is an active developer and maintainer of the Tock embedded operating system, written in Rust and designed to run mutually distrustful applications.
Fortifying Rust's FFI with Encapsulated Functions
Memory- and type-safe languages like Rust are increasingly popular for systems development. Nonetheless, practical systems must interact with code written in memory-unsafe languages. Examples for this can be found across the spectrum, with many Rust applications linking against popular libraries such as OpenSSL, to security and safety-critical embedded systems, where subsystems such as cryptographic implementations are subject to industrial and governmental certification requirements. Direct interactions with such libraries, however, expose safe languages to significant risks: any single bug in either the foreign code or the cross-language interactions may arbitrarily violate the memory and/or type safety of the wrapping language. This talk presents Encapsulated Functions, an ongoing research project exploring how to secure cross-language interactions along with their differing guarantees and semantics around memory- and type-safety. At its core, Encapsulated Functions is a framework that combines memory protection mechanisms (such as the RISC-V Physical Memory Protection or Intel's Memory Protection Keys) with a set of portable types to both restrict and encapsulate behavior across the language boundary. Through the portability across different memory protection mechanisms we can utilize this infrastructure in both highly-restrictive embedded systems and applications running on conventional operating systems alike.
Ulf is a software engineer working for Akiles, a PropTech company using Rust firmware in their products. He has spent the past 3 out of 14 years in his career working on embedded Rust in different communities like Embassy and Drogue IoT and maintaining several crates in the wider embedded rust community.
Rust poisoning my wrist for fun
Sophia has been a long-time advocate of better programming languages and tools. She helped create TypeScript and later joined Mozilla to work on compiler errors, IDE support, and the larger Rust ergonomics initiative. She also served on the Rust core team and helped create the Rust Leadership Council.
Talk title to be announced
Dario Nieuwenhuis is the CTO and a co-founder at Akiles. In 2019, he started the Embassy project to explore using async/await in embedded systems. Since then, the project has matured and is being used in production at multiple companies, including Akiles.
Async Rust in embedded systems with Embassy
Async/await in Rust has a unique design compared to other languages that offers much lower-level control. This makes it surprisingly well suited for use in microcontroller-based embedded systems with no operating system, little memory (down to kilobytes!) and no heap. Embassy is an async runtime that makes that possible: it includes an executor that works on no-std no-alloc targets, and libraries to do async IO directly against the hardware. In this talk we'll explore how this is done, what challenges arise and how Embassy solves them, what makes async on embedded unique compared to a standard async runtime like Tokio, and what improvements could we make to the Rust language itself to make it even better.
Michaël Melchiore is an On-Board SW Specialist at Airbus Defense & Space in Toulouse, France. He has been developing data-intensive real-time software in various fields (Railway, Radars, Space) for more than fifteen years. He discovered the Rust language in 2014 and has tried to bring it to his workplace ever since. In 2023, he led an ESA-funded effort to study the potential benefits of using Rust and design techniques from the game industry in the Space SW Industry.
(Th)Rust for Space: Initial momentum
This talk first introduces the specific challenges of developing space-worthy SW in a context of growing customers' expectations, in terms of performance, features and reliability. Then, Michaël presents the ESA study strategy and the initial solutions it yielded. Several concrete use-cases demonstrate how Rust can be extended via its type-system to tackle increasingly domain-specific difficulties in a composable manner. Such results paint a compelling, yet incomplete vision for modern On-Board SW development. This talk finally proposes a few next steps the Space Industry should take to contribute to and leverage the momentum of the Rust community.