Lamellar: Enabling Memory-Safe Distributed HPC in Rust

High-performance computing has long depended on programming environments that deliver exceptional performance but offer limited protection against memory errors, data races, and other sources of software fragility. For many years, this tradeoff was accepted as the cost of building scalable, high-performance systems. But as supercomputers grow in scale and applications become increasingly complex, that compromise is becoming harder to justify. Reliability, maintainability, and developer productivity are now central concerns in the design of future HPC software stacks.

Rust has emerged as a compelling alternative. With compile-time memory safety, strong guarantees around concurrency, and zero-cost abstractions, Rust offers a new foundation for building system software that is both safe and efficient. While much of the early interest in Rust for HPC has focused on kernels, libraries, and isolated application components, an important open question remains: what does it look like to build core distributed runtime infrastructure for HPC in Rust?

This talk presents Lamellar, an asynchronous distributed runtime developed at Pacific Northwest National Laboratory to explore exactly that question. Lamellar is designed to support large-scale distributed-memory applications while leveraging Rust’s language features to improve software correctness and programmer productivity. The project reflects a broader effort to rethink how we build runtime systems for emerging HPC workloads—particularly those that are irregular, communication intensive, and increasingly difficult to express and optimize using traditional approaches.

I will discuss the motivation behind Lamellar, the design principles that shaped it, and the lessons learned from building a distributed runtime in Rust. In particular, I will highlight how Rust’s ownership and borrowing model can be applied in a distributed setting, how asynchronous execution can help expose and manage parallelism across a cluster, and how language-level safety guarantees influence both runtime architecture and application design. The talk will also explore some of the practical challenges involved in bringing Rust into HPC system software, including interoperability with established programming environments and the tension between expressive abstractions and the need for predictable performance.

Beyond the specifics of Lamellar, this presentation will consider what Rust may mean for the future of HPC software more broadly. If memory safety and data-race freedom can be enforced by construction, and if those guarantees can be integrated into high-performance runtime infrastructure without compromising scalability, then we have an opportunity to fundamentally improve how HPC software is developed and maintained. This is especially relevant as the community looks toward increasingly heterogeneous, dynamic, and software-complex systems.

Lamellar is not just an implementation effort; it is also a case study in how modern systems language design can reshape expectations for HPC runtime software. By sharing the experience of building and using Lamellar, this talk aims to provide attendees with a concrete view of both the promise and the realities of adopting Rust at the runtime level. More broadly, it argues that safety, performance, and productivity need not be competing objectives in high-performance computing, but can instead be pursued together as first-class design goals.