|
|
|
|
Organizers
|
|
|
|
Deploying a Behavior Policy on a 115,000 Pound Robot: What Rust Governs, and What It Doesn't
At Bedrock, we deploy a learned behavior policy to operate a heavy-duty excavator on our job sites. The policy proposes motion from multimodal observations, but it does not own machine authority. Around it is an onboard system we wrote in Rust from scratch, from sensor drivers through ML inference and control.
In this talk, we will show where our investment in Rust paid off: in what the model sees (the sensor drivers), what the model may do (a fault system whose response ladder ensures safe fallbacks when the unexpected happens), and how the model is developed (a middleware layer that runs the same components live, in replay over field logs, in simulation, and generates the data the policy trains on). We will also cover three boundaries where Rust got harder: model authoring against Python-authored contracts, model execution against the GPU runtime, and model support, where Rust has optimizers but no Ceres. Overall, we would choose Rust again, and those boundaries are where we would want the ecosystem to grow.
|
Georges Goetz
|
|
|
|
Rust in Robotics: Challenges and Opportunities.
This talk will share the experience in using Rust to build the Zenoh, which is one of the most popular protocols in Robotics. Specifically, I will discuss some of the key advantages that Rust has brought us along with the challenges, especially those posed by async frameworks in the context of real-time and embedded systems. The talk will discuss a set recommended extensions and additional requirements to make async Rust a true asset in robotics.
|
Angelo Corsaro
|
|
|
|
Rust's Tracing and Observability Tools in Robotics
Robotics sits at the intersection of empirical science, hard engineering, and mathematics. Every step in the process has metrics, outputs, and a set of requirements that we try to optimize for. Outside of the benefits of memory safety, Rust has a superpower: observability. Through selective use of the tracing crate we can generate automated reports, instrument code for performance measurements, and track how our application is behaving at an individual and fleet level. In this talk, I will demonstrate how to get started with the tracing crate, and how to think about debugging our robotics stack for more robust systems.
|
Jeremy Steward
|
|
|
|
|
Misc
|
|
|
|
cuda-oxide - Write CUDA kernels in pure Rust
cuda-oxide is a Rust-to-CUDA compiler stack for writing GPU kernels in pure Rust. It lets host and device code live in one Rust source file, compiles #[kernel] functions to PTX through a custom rustc backend, and keeps normal Rust features like generics, closures, type checking, and monomorphization in the workflow. The main point is simple: developers should not have to choose between CUDA’s latest hardware features and Rust’s safer, more composable programming model. cuda-oxide shows that Rust kernels can target modern NVIDIA GPUs, including advanced features like TMA, clusters, atomics, async execution, and Blackwell tensor cores, while retaining Rust’s core benefits: strong type checking, generics, closures, monomorphization, and safer host/device API boundaries.
|
Nihal Pasham
|
|
|
|
Rust in the Wild: Lessons from Building Production Robotics Software
Most arguments for Rust in robotics start with memory safety and benchmarks. This talk starts with production. Drawing on work across industrial robotics, government autonomy programs, autonomous vehicles, and physical AI data infrastructure at Rerun, it covers what Rust actually delivers once you’re shipping: fewer bad patterns surviving to production, faster iteration through compile-time feedback, and — for distributed remote teams — the ability to merge across time zones with genuine confidence.
|
Tim Saucer
|
|
|
|
Panel: Lessons Learned from Rust Adoption
|
TBD
|
|
|
|
|
Misc
|
|
|
|
|
Misc
|
|
|
|
From PyTorch to the Edge: Rust-Native Computer Vision and Robotics with Kornia
After six years building Kornia as a differentiable CV library for PyTorch, we’ve been rebuilding the stack in Rust. This talk covers kornia-rs for real-time computer vision on the edge, Bubbaloop — an open-source orchestration runtime for cameras, sensors, and ML inference on local hardware — and an early look at kornia-slam, our work-in-progress visual SLAM library. We’ll share walkthroughs of real deployments on Jetson and Raspberry Pi, results from Kornia AI’s Google Summer of Code program, and how a non-profit umbrella sustains a growing portfolio of open-source robotics infrastructure.
|
Edgar Riba
|
|
|
|
From ROS to Rust: Hiroz, Zenoh, and a Robotics Stack You Can `cargo build`
This talk covers why the two existing Rust-in-ROS-2 approaches each involve real trade-offs—ros2_rust wraps the C RCL layer and stays wire-compatible but requires a full ROS 2 install and spreads unsafe FFI throughout; dora-rs goes pure Rust but drops wire compatibility entirely—and how hiroz takes a third path: pure Rust, no C dependencies, and wire-compatible with standard ROS 2 nodes out of the box. We then go inside hiroz’s async runtime design, message generation pipeline, and multi-language binding strategies.
|
Yuyuan Yuan
|
|
|
|
|
Misc
|
|
|
|
Executing Safety critical Robotics projects in Rust
Over the last years, Ferrous Systems has not only qualified a compiler, but also helped multiple customers to get their robotics system certified for safety. This talk gives a light intro why certification of a system is meaningful and what it entails. It then deep-dives into how to actually execute on those things in Rust. Because Rust has much more to bring than just memory safety!
|
Florian Gilcher
|
|
|
|
Live Demo
Live demonstration of a robotics stack written in Rust.
|
Organizers
|
|
|
|
|
Organizers
|
