Session Description

Rust is often described as a systems language that gives you memory safety without losing the performance of C or C++.

But many engineers still wonder:
does Rust really match C++ performance in real programs?

In this talk, I will explore this question by writing
programs in both Rust and C++ and benchmarking them.

We will look at examples like iterator chains vs simple loops, bounds checking, and memory allocation patterns.

By looking at benchmarks and generated assembly, we will try to understand where Rust performs the same as C++, and where safety or abstraction might introduce some overhead.

The goal is to give a practical view of Rust’s performance in systems programming.

Key Takeaways

• A clearer understanding of how Rust performance compares with C++ in common systems programming scenarios.
• Practical insights into when Rust abstractions are truly “zero-cost” and when they may add overhead.

Intended Audience

This talk is useful for systems programmers, C/C++ developers, and engineers who are curious about Rust for performance-critical systems.

Anyone interested in compilers, low-level programming,
or benchmarking will find it useful.

Speaker Bio

I am a systems and compiler engineer working on low-level programming and compiler infrastructure. My interests include LLVM, GPU compilers, systems programming, and performance analysis.

I am also the maintainer of CompilerSutra.com , where I share educational content and practical explanations about compilers, LLVM, and systems programming to help developers understand how modern compilers work under the hood.