Skip to content


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

Latest commit


Git stats


Failed to load latest commit information.
Latest commit message
Commit time

How to learn modern Rust

A guide to the adventurer.

Table of Contents

Learn Rust deeply one step after the other

Rust is an incredible powerful programming language. It is fast, compiled, without a runtime and it brings new concepts of safety to programming.
It is the most beloved language for five years in a row in Stack Overflow users pool.
To learn Rust go through the following content in the listed order, the majority of the content is free.

  1. Why Developers Love Rust

  2. Video - Rust Crash Course - Rustlang

  3. Video - Introduction to Rust Part 1

  4. Video - Introduction to Rust Part 2

  5. Video - Rust for the impatient - No Boilerplate

  6. A half-hour to learn Rust - fasterThanLime Blog

  7. Videos - Microsoft Beginner's Series to Rust
    GitHub Code

  8. The Tour of Rust

  9. A Rust experienced developer teaches a C++ experienced developer (Jason Turner) about Rust, from zero.
    Jonathan Teaches Jason Rust - Part 1 - C++ Weekly
    Jonathan Teaches Jason Rust - Part 2 - C++ Weekly

  10. The Rust Programming Language Book
    by Steve Klabnik and Carol Nichols, with contributions from the Rust Community

  11. Rust Language Cheat Sheet

  12. Rustlings
    Small exercises to get you used to reading and writing Rust code.

  13. Blessed - An unofficial guide to the Rust ecosystem

  14. Videos - Intro to Rustlang - Tensor Programming

  15. Videos - Rustlang Project - Tensor Programming

  16. Standard collections - std info and how to choose the correct collection

  17. Trivia About Rust Types: An Authorized Transcription of Jon Gjengset’s Twitter Thread

  18. Video - Unsafe & FFI in Rust

  19. Rust by Example Book

  20. Study carefully the methods of Option<T> in the documentation, they are used in all Rust programs

  21. Study carefully the methods of Result<T, E> in the documentation, they are used in all Rust programs

  22. Rust's Most Important Containers Option, Result - 10 Useful Patterns - Code to the Moon

  23. Command Line Applications in Rust - Book

  24. The Rust Standard Library documentation

  25. Learn Rust With Entirely Too Many Linked Lists - Book

  26. Rust Design Patterns - Book

  27. Effective Rust - Book

  28. The Rust Cookbook - Book

  29. The Cargo Book

  30. Guide trough of the Advent of Code 2020

  31. Rust API Guidelines Book

  32. The Rust Reference Book

  33. The Rustonomicon - The Dark Arts of Unsafe Rust - Book

  34. The Little Book of Rust Macros - Book

  35. Writing Interpreters in Rust: a Guide - Book

  36. Video - Cheaply writing a fast interpreter - Neil Mitchell

  37. Make A Language
    A series about making a programming language called Eldiro using the Rust programming language.

  38. Engineering Rust Web Applications - Book

  39. Programming Rust: Fast, Safe Systems Development 2nd Ed
    by Jim Blandy, Jason Orendorff

  40. Rust for Rustaceans: Idiomatic Programming for Experienced Developers
    by Jon Gjengset

  41. Refactoring to Rust
    by Lily Mara

  42. Practical System Programming for Rust Developers
    Build fast and secure software for Linux/Unix systems with the help of practical examples
    by Prabhu Eshwarla

  43. Hands-On Concurrency with Rust: Confidently build memory-safe, parallel, and efficient software in Rust
    by Brian L. Troutwine

  44. GDB: The GNU Project Debugger

  45. The LLDB Debugger

  46. Valgrind User Manual

  47. The perf Linux profiler - Examples of use

  48. QuickCheck - QuickCheck is a way to do property based testing using randomly generated input.

  49. American Fuzzy Lop - A good fuzzer

  50. Criterion rs - Statistics-driven Microbenchmarking in Rust

  51. The Complete Rust Programming Reference Guide: Design, develop, and deploy effective software systems using the advanced constructs of Rust
    by Rahul Sharma, Vesa Kaihlavirta

  52. Creative Projects for Rust Programmers: Build exciting projects on domains such as web apps, WebAssembly, games, and parsing
    by Carlo Milanesi

  53. Rust High Performance: Learn to skyrocket the performance of your Rust applications
    by Iban Eguia Moraza

  54. Writing an OS in Rust Philipp Oppermann's blog

  55. The Rust Unstable Book

Text Processing in Rust

  1. Text Processing in Rust
    by Mihalis Tsoukalos

  2. Working with strings in Rust - fasterThanLime Blog

  3. String continuations
    The backslash, the newline and the starting spaces will disappear.

    "... the {p}, by the {p}, for the {p}, \
    will never fall.",
    p = "people"

Will print: 
"... the people, by the people, for the people, will never fall."
  1. For ASCII Strings (value lower then 127) non UTF-8 strings, one can process much faster the string if it is converted to bytes and then compared to bytes.
let my_str = "Hello!".to_string();
for c in my_str.chars() {
    if c == 'l' {
        // Do something!

// A faster implementation for ASCII characters would be.

let my_str_2 = "Hello!".to_string();
for b in my_str.bytes() {
    if b == b'l' {
        // Do something!

// There is also a slice of bytes.

let my_str_3 = "Hello!".to_string();
let my_str_as_bytes_slice = my_str_3.as_bytes();

if my_str_as_bytes_slice[2] == b'l' {
        // Do something!
  1. Kibi - A text editor in ≤1024 lines of code, written in Rust

  2. Rust substring processing
    My section below on it.

How Rust maps to memory and lifetimes annotations in Rust

  1. Video - Visualizing memory layout of Rust's data types - Sreekanth
    Incredible video!

  2. Video - Understanding Rust Lifetimes - Ryan Levick

  3. Video - Crust of Rust: Lifetime Annotations - Jon Gjengset

  4. Implementing a HashMap in Rust.
    Video - Live-coding a linked hash map in Rust - Jon Gjengset

How to deal with Circular References and Ownership

The previous link demonstrated 3 ways to attack the problem:

1- Defer borrow checking to run-time, by using a reference-counted pointer (std::rc::Rc) to a std::cell:RefCell.

2- Centralize the ownership (e.g. all nodes are owned by a vector of nodes in the Tree), and then references become handles (indices into the a vector).

3- Use raw pointers and unsafe blocks to go around the rules of safe Rust.

Polymorphism in Rust

Rust Testing and TDD - Test Driven Development

Systems programming in Rust

Background in systems programming

  1. How to learn modern Linux

  2. Safe Systems Programming in Rust
    By Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, Derek Dreyer

  3. The Linux Command Line, 2nd Edition: A Complete Introduction Illustrated Edition
    by William Shotts

  4. How Linux Works, 3rd Edition: What Every Superuser Should Know 3rd Edition
    by Brian Ward

  5. Dive Into Systems: A Gentle Introduction to Computer Systems
    by Suzanne J. Matthews , Tia Newhall, et al.

  6. Operating Systems: Three Easy Pieces
    Remzi H. Arpaci-Dusseau and Andrea C. Arpaci-Dusseau

  7. The Linux Programming Interface: A Linux and UNIX System Programming Handbook
    by Michael Kerrisk
    Note: Read this book from cover to cover!

  8. System Programming Vol I and Vol II
    by Jin-Jwei Chen
    Note: Read this book from cover to cover!

  9. Linux Device Drivers, 3th Edition

  10. Linux Driver Development for Embedded Processors - 2th Edition: Learn to develop Linux embedded drivers with kernel 4.9 LTS
    by Alberto Liberal de los Ríos

  11. Computer Systems: A Programmer's Perspective 3rd Edition
    by Randal Bryant, David O'Hallaron

  12. Computer Networking: A Top-Down Approach
    by James Kurose

  13. The Illustrated Network: How TCP/IP Works in a Modern Network 2nd Edition
    by Walter Goralski

  14. C Programming: A Modern Approach, 2nd Edition
    by K. N. King

  15. Extreme C: Taking you to the limit in Concurrency, OOP, and the most advanced capabilities of C
    by Kamran Amini

  16. C++ Crash Course: A Fast-Paced Introduction
    by Josh Lospinoso

Writing Compilers in Rust

  1. Crafting Interpreters
    by Robert Nystrom
    The book license is Creative Commons.
    Lox Implementations
    Crafting Interpreters in Rust - tdp2110
    Crafting A Lox Interpreter In Rust, Part 1 - Diego Freijo

  2. Video Play List - Crafting Interpreters - Uncle Scientist

  3. LISP interpreter in Rust

  4. Writing An Interpreter In Go
    by Thorsten Ball

  5. Writing A Compiler In Go
    by Thorsten Ball

  6. Compilers: Principles, Techniques, and Tools
    by Alfred Aho, Monica Lam, Ravi Sethi

Contributing to the Rust Compiler rustc

  1. Video - RustConf 2021 - Hacking rustc: Contributing to the Compiler by Esteban Kuber

  2. Video - rustc - A talk by Mark Mansi about the Rust programming language and compiler

  3. Video - Hacking on rustc - Negative literals in indexing expressions

  4. Rust Lang - Compiler Team

  5. The Rust Compiler - rustc

  6. rustc API docs - rustdoc documentation for the compiler

  7. Zulip Chat - rust-lang

  8. Forum Rust Internals

  9. Guide to Rustc Development - Book

  10. Video Play List - rustc lecture series

WebAssembly in Rust - WASM

  1. Rust and WebAssembly - Book

  2. Write Your First WASM Module using Rust

  3. Getting Started with WebAssembly and Rust: A First Look

  4. Crate wasm-bindgen
    Facilitating high-level interactions between Wasm modules and JavaScript.
    The wasm-bindgen guide - Book

  5. Project WASM Fourier
    Example of browser audio microphone data passed to Rust WASM module.
    Note: Really cool example to study and for example do APP's with audio processing on Rust.

  6. Video - Rust + Yew + WASM + Canvas - Vers Binarii

WebFrameworks in Rust - Similar to React Angular or Vue

SQL Databases in Rust

  1. Video - 5 MUST know Rust database libraries

  2. Video - Rust & SQL Databases - With Diesel

  3. 11 database drivers and ORMs for Rust that are ready for production

Rapid Prototyping in Rust - Write fast like Python - Run fast like C

  1. Rapid Prototyping in Rust - Write fast like Python - Run fast like C

Python extended with Rust and running a Python interpreter inside Rust

  1. PyO3 - GitHub

  2. The PyO3 user guide - Book

  3. Python Extensions in Pure Rust with PyO3

  4. Python Extensions in Pure Rust with Rust-CPython

  5. RustPython - A Python-3 interpreter written in Rust

Rust with inline Python

In a program made in Rust, use a macro to insert inline Python and move easily data (variables) between the two.

// Example_1 

use inline_python::python;

fn main() {
    let who = "world";
    let n = 5;
    python! {
        for i in range('n):
            print(i, "Hello", 'who)
// Example_2 
// Creates the data in Rust and plots the plot with inline Python with the lib matplotlib.

use inline_python::python;

fn main() {
    let data = vec![(4, 3), (2, 8), (3, 1), (4, 0)];
    python! {
        import matplotlib.pyplot as plt
  1. Crate inline-python
    Inline Python code directly in your Rust code

The inner workings and all the development steps of this project are beautifully explained, in detail, on this sequence of blog posts.

  1. Writing Python inside your Rust code - Part 1 - Mara's Blog

  2. Writing Python inside your Rust code - Part 1A - Mara's Blog

  3. Writing Python inside your Rust code - Part 2 - Mara's Blog

  4. Writing Python inside your Rust code - Part 3 - Mara's Blog

  5. Writing Python inside your Rust code - Part 4 - Mara's Blog

Rust on or for the Raspberry Pi

  • There are two modes of using Rust with the Raspberry Pi.
    The first one is installing Rust development tools on the Raspberry Pi it self, and the second one is installing on the PC and making cross-compilation to generate a executable that runs on the Raspberry Pi.

Developing on the Raspberry Pi and running Rust programs on the Raspberry Pi

  1. How to Get Started With Rust on Raspberry Pi

Developing on the PC and cross-compiling to run Rust programs on the Raspberry Pi

  1. Cross Compiling Rust for the Raspberry Pi
    It also explains a method to automatically coping the file to the Raspberry Pi after compilation.

  2. Cross compiling Rust for Raspberry Pi

Embedded Rust

  1. An Overview of the Embedded Rust Ecosystem - end 2020

  2. Awesome embedded rust - Github
    Everything you need to know including drivers to connect external devices to the micro-controller.

  3. The Embedded Working Group Newsletter or Blog

  4. Discovery Book
    Good starting point for MicroBit and STM32

  5. PlayList - Embedded Rust course - JaJakub - 2022

  6. Live streams with a good example of developing with Embedded Rust in STM32 BluePill
    Embedded Rust - Vers Binarii

  7. Embedded Hardware Development with Rust - 2018

  8. Embedded Programming is Getting Rust-y - end of 2021
    Embedded Computing Design

  9. The Embedded Rust Book
    Second fantastic book to read
    Generic for any type of chip brand.

  10. Workbook for Embedded Workshops - Book
    Using the Nordic nRF52840 Development Kit.

  11. The Embedonomicon Book
    Deep dive into the inner workings.

  12. Video - How can we write the best device driver?

  13. Video - RTIC - Real Time Interrupt driven Concurrency
    RTIC is a RTOS - Real Time Operating System.

  14. RTIC Book
    Real-Time Interrupt-driven Concurrency.
    A very efficient preemptive multitasking framework that supports task prioritization and dead lock free execution.

  15. Github - rtic-rs - cortex-m-rtic

  16. Video - Grepit about the Rust RTIC framework

  17. Good RTIC project example
    Rust firmware for IR thermometer in STM32 with LCD - geomatsi - rust-ir-thermo

  18. Video - Bare Metal Audio Programming With Rust - Antoine van Gelder - ADC20

  19. Video - Building a simple logic analyser in Rust
    Rust Linz, September 2020 - Roland Ruckerbauer - Embedded Rust
    Board used stm32 compatible bluepill.
    Github - ruabmbua - rlogic

Embedded Rust crates and code size optimization

  1. Crate heapless
   Arc         - Thread-safe reference-counting pointer backed by a memory pool
   BinaryHeap  - Priority queue
   IndexMap    - Hash table
   IndexSet    - Hash set
   Pool        - Lock-free memory pool
   mpmc::Q*    - Multiple producer multiple consumer lock-free queue
   spsc::Queue - Single producer single consumer lock-free queue
  1. Crate ufmt
    A (6-40x) smaller, (2-9x) faster and panic-free alternative to core::fmt

  2. LCD 16x2 - Crate hd44780-driver
    Implementation of the embedded-hal traits for the HD44780, 16x1, 16x2 and 16x4.

  3. Crate Embedded graphics
    It's a 2D graphics library that is focused on memory constrained embedded devices.

  4. Crate flip-link
    Adds zero-cost stack overflow protection to your embedded programs.

  5. Crate defmt
    defmt ("de format", short for "deferred formatting") is a highly efficient logging framework that targets resource-constrained devices, like micro-controllers.

  6. TOML compilation flag options to generate smaller code size


opt-level = "z"

codegen-units = 1
debug = true
opt-level = "z"

Embedded Rust with STM32 BluePill - STM32F103

  1. STM32 BluePill in Rust - Project template and lot's of info
    This is the project template I use in my BluePill projects.

Embedded Rust with Raspberry Pi Pico - 4 dollars board

  1. All relevant Info and a starting project Template.
    Where I have put all the info that I consider to be relevant for Pico development in Rust.
    Raspberry Pi Pico in Rust Proj Template with RTIC USB-Serial and UF2

  2. Raspberry Pi Pico - rp-HAL
    rp2040-hal - Examples
    Examples for the board rp-pico.

  3. Site - rp2040 - Chip documentation

  4. Getting Started with Rust on a Raspberry Pi Pico - Part 1

  5. Getting Started with Rust on a Raspberry Pi Pico - Part 2

  6. Getting Started with Rust on a Raspberry Pi Pico - Part 3

  7. Oleg Eterevsky comment on the previous page - Slightly simpler setup. Instead of using a separate controller for handling the debug, he have just set up debug logging via USB serial port. This requires a bit more boilerplate (handling the USB interrupt and such), but is much simpler from the hardware perspective: you need to just plug in a single Pico board in your USB, flash it and you can immediately see the debug output.
    USB_Serial - repo

  8. Crate usb-device - Experimental device-side USB stack for embedded devices.

  9. Way to easily Reboot the Pico to USB-PEN mode to program it
    You can have a easy reboot without needing to disconnecting and while pressing the boot button reconnecting the cable.
    Just add a switch from pin RUN to GND and while pressing the Boot Button press the Run Button and release the Run switch and them the Boot Button. It will enter the USB-PEN mode, that allows you to program by just coping the Rust or C binary from the PC to the Raspberry Pico micro-controller.
    See official documentation for details.

  10. PlayList - Rust Pico - Low Level Learning

  11. Play List - Raspberry Pi Pico in C - Low Level Learning

  12. PlayList - Intro to Raspberry Pi Pico and RP2040 - Digi-Key
    C/C++ and MicroPython

  13. In-depth: Raspberry Pi Pico's PIO - programmable IO - stacksmashing

  14. Site - Raspberry Pi Pico

  15. Site - Getting started with Raspberry Pi Pico

  16. Book - Get Started with MicroPython on Raspberry Pi Pico

  17. Book - Adafruit - Getting Started with Raspberry Pi Pico and CircuitPython

  18. Video - The Raspberry Pi Pico Review - $4 ARM Microcontroller

  19. Video - Raspberry Pi Pico VGA video output using only resistors

Embedded Rust with ESP32

  1. esp-rs - Rust on ESP-IDF "Hello, World" template

  2. Video - Embedded Rust: Wifi and I2C on a ESP32-C3 - Andrei Litvin
    GitHub andy31415 - rust-esp32-c3-demos

  3. ivmarkov - rust-esp32-std-demo
    A complex demo of ESP32 in Rust


  1. Rust site
    A language empowering everyone to build reliable and efficient software.

  2. Song - Rust 2021 Edition

  3. - The Rust community’s crate registry

  4. Rust weekly news letter

  5. The Little Book of Rust Books

  6. Awesome-rust

  7. Awesome-embedded-rust

  8. Rust Analyzer - User manual and short cut keys

  9. Jon Gjengset - Rust in depth Youtube channel.

  10. Tokio
    Tokio is an asynchronous runtime (async and await) for the Rust programming language. It provides the building blocks needed for writing network applications. It gives the flexibility to target a wide range of systems, from large servers with dozens of cores to small embedded devices.
    See the tutorials.

  11. Best async and await introduction video.
    Video - Crust of Rust: async e await - Jon Gjengset

  12. Video - Creating a Chat Server with async Rust and Tokio – Lily Mara

  13. Tracing - Log tracing platform

  14. Actix Web
    Web Framework that's blazing fast, secure, asynchronous runs over Tokio and is "similar" to Flask of Python.
    Can process 650.000 request per second.

  15. Rocket
    Web Framework that's fast, secure and more "similar" to Django of Python.

  16. Serde
    Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.

  17. BindGen
    Automatically generates Rust FFI bindings to C and C++ libraries.
    Tutorial guide.

  18. Hacking rustc: Contributing to the Compiler by Esteban Kuber - RustConf 2021

Rust Foundation

  1. Video - What Is Rust Foundation?

  2. Site - Rust Foundation

Rust Blogs

  1. pretzelhammer's Rust blog

    1. RESTful API in Sync & Async Rust - pretzelhammer

    2. Common Rust Lifetime Misconceptions - pretzelhammer

    3. Tour of Rust's Standard Library Traits - pretzelhammer

    4. Sizedness in Rust – pretzelhammer

  2. fasterThanLime Blog - Amos Wenger

Rust Youtube Channels

  1. Channel Rust

  2. Channel Rust Foundation

  3. Channel fasterthanlime - Amos Wegner

  4. Channel Jon Gjengset - Rust in depth Youtube channel.

  5. Channel Tensor Programming - Intro to Rust

  6. Channel Tensor Programming - Rust Projects

  7. Channel Let's Get Rusty

  8. Channel Uncle Scientist

  9. Channel Ryan Levick

  10. Channel Tantan

  11. Channel Crazcalm's Tech Stack

  12. Channel Ferrous Systems GmbH
    Embedded Rust

  13. Channel JaJakub
    Embedded Rust

  14. Channel Vers Binarii
    Embedded Rust

GUI programming in Rust

  1. GTK4 - Unlocking the GNOME stack for Rust

  2. Book - GUI development with Rust and GTK 4

  3. Relm4 for GTK4

  4. Speedrunning GUI development in Rust
    Hint: 1.2 seconds compilation technic.

  5. egui: an easy-to-use GUI in pure Rust
    Normal desktop GUI and WebAssembly written entirely in Rust, immediate mode.

  6. eGUI - Web Demo

  7. eframe - It's the official framework library for writing apps using egui

  8. egui - 7a. Building a GUI app in Rust - Part A - creativcoder

  9. egui - 7b. Building a GUI app in Rust - Part B - creativcoder

  10. egui - 8. Building a web app in Rust - WASM - creativcoder

  11. Crate confy
    To maintain the state fo the APP in a config file. Serializes and deserializes automatically with Serde.

  12. Crate tracing

  13. pix_engine
    It's a cross-platform graphics & UI library for simple games, visualizations, digital art, and graphics applications. A kind of more simple Processing or p5.js but for Rust. Has a good collection of examples.

Audio in Rust

  1. RustAudio
    Free and useful Audio, DSP and music libraries written in Rust.

  2. CPAL - Cross-Platform Audio Library
    Low-level library for audio input and output in pure Rust.
    Works aldo in WASM.

  3. Rodio - Audio playback library
    MP3, WAV, Vorbis, Flac, MP4 and AAC.

  4. dasp - Digital Audio Signal Processing in Rust

  5. rust-portaudio - PortAudio bindings and wrappers for Rust.

Faster Compilation - Linker times in Linux and Unix ELF

mold is optimized for Linux, zld only works on macOS. For production use, lld might be the most mature option.

mold is a high-performance drop-in replacement for existing Unix linkers. It is several times faster than LLVM lld linker
In the context of building a Relm4 for GTK-4 GUI application:
"With mold I was able to reduce my incremental compile times by factor 7 to only about 1.2 second. With this, it’s really fun to play with the code of the UI as you can see the result of your changes almost immediately." by the author of Relm4

  1. Mold
// After installing mold, all you need to do is add the
// prefix mold -run to the command you want to run.
// Most likely this will be:

mold -run cargo run
  1. Tips for Faster Rust Compile Times

Machine Learning for Rust

  1. Taking ML to production with Rust: a 25x speedup

  2. Machine learning in Rust using Linfa

  3. Crate Linfa
    linfa aims to provide a comprehensive toolkit to build Machine Learning applications with Rust.
    Kin in spirit to Python's scikit-learn, it focuses on common preprocessing tasks and classical ML algorithms for your everyday ML tasks.

  4. Crate tch-rs
    Rust wrappers for the PyTorch C++ api (libtorch).

  5. Crate Rust TensorFlow
    TensorFlow Rust provides idiomatic Rust language bindings for TensorFlow.

  6. Crate rust-xgboost
    Rust bindings for the XGBoost gradient boosting library.

Rust VSCode plugins

  1. rust-analyzer
    Code analyzer while editing
    For better warnings in the same user interface, go into the VSCode settings > Rust Analyzer > Check On Save: Command and setting “clippy” instead of “check”.

  2. Better TOML
    .toml syntax hilight.

  3. Error Lens
    Better positioning of error messages in editor.

  4. CodeLLDB - Vadim Chugunov
    Debugger plugin for Rust.

  5. Code Spell Checker

  6. Markdown All in One

Rust Debugger

  1. How to Debug Rust with Visual Studio Code

  2. Debugging Rust with VS Code

  3. CodeLLDB - Vadim Chugunov
    Plugin for VS Code

Rust Error Handling

To define good error types that encapsulate other errors. In the case where you need to return from a function, multiple incompatible types, and you don't want to manually write conversion functions that implement the trait std::convert::From< > .

  1. Crate Anyhow
    Use Anyhow if you don't care what error type your functions return, you just want it to be easy. This is common in application code.

  2. Crate thiserror
    Use thiserror if you are a library that wants to design your own dedicated error type(s) so that on failures the caller gets exactly the information that you choose.

Tips and Tricks

GC for Rust - Garbage Collector

“Cases where one needs to maintain a complicated, dynamic graph “(with cycles)” are where a GC becomes useful. Similarly, if one is writing an interpreter for a GCd language, having a GC in Rust would simplify things a lot.”

Programming Parallel computers - Optimization guide C Plus Plus and Rust

  1. Programming Parallel Computers - In depth lectures notes

  2. Comparing Parallel Rust and C++

  3. Crossbeam - Tools for concurrent programming
    Crossbeam - Learning Resources

  4. Rayon - It is a data-parallelism library for Rust
    Video - Rayon: Data Parallelism for Fun and Profit — Nicholas Matsakis
    Rayon: data parallelism in Rust
    Rayon docs

  5. dpc-pariter - Parallel iterator processing
    Adding parallelism to your Rust iterators with dpc-pariter

  6. perf Examples
    See also the lecture.

  7. perf: Linux profiling with performance counters

  8. Systems Performance Enterprise and the Cloud 2nd Ed
    by Brendan Gregg

To install Perf on your Linux system you can do a simple package installation like apt-get if you are on a debian, then execute perf and it will tell you the package that you will have to install that is specific for your Linux kernel version. If your distribution automatically updates your kernel, you will need to download a new and correct version for your new kernel, and install it with your system package manager, ex: apt-get.

In the Rust .toml file add the 2 following lines, to add the debug symbols table to the Rust executable program file, compiled with --release flag:

debug = true

To run Perf profiling on your Rust executable program. After that you can also use flamegraph.

# Temporarily activate this flag perf_event_paranoid.

> echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid

# Record the executable program profiling data in a .data file.

> perf record -F99 --call-graph dwarf <path to the executable>

# To see the report use with Up/Down arrow keys, with "+"
# and with "a" to see the annotated assembly code with the Rust
# code correspondent code. The report will include the % of time in
# inside the function and in each group of assembly instructions.
# Press "tab" key in annotation mode to jump between hot spots.

> perf report

The Perf profiler has many command use the stat command to get the IPC – Instruction Per Clock Cycle, it's an average.

To know how much peak memory your executable program uses do:

> /usr/bin/time -v <path to the executable>

Note: There are 2 "time" executables and this is not the bash default time program. That's why you have to write the full path /usr/bin/time to execute it.

  1. The Rust Performance Book

  2. Guide to Optimization
    Achieving warp speed with Rust
    Cheap tricks for high-performance Rust
    Video - Optimizing Rust - Rust Oslo 2021-11-11 - Lily Mara
    Optimization - Making Rust Code Go Brrrr
    Profile Guided Optimization
    Optimizations: the speed size tradeoff

Rust Optimization - Compilation modes and flags

The best way to optimize your code is to choose the right algorithm and the right data structures.

You can also apply several coding techniques that come from the underling knowledge of how the rust transforms your code structures in memory (stack and heap) and how they are executed, for example avoiding allocation, avoiding cloning large things that aren’t basic types and that are by nature cloned. (More info bellow.) You can do profiling to guide you through optimization, identifying the hot-spots to pin point you to the exact code your program spends that 90% of his time. And to allow you to see where you can shave it in the number of instructions that are executed at the same time and to increase your IPC – Instructions Per Clock cycle of your superscaller CPU. And then you can also mess around with compilation flags like the following, see :

debug = true
  • LTO - Link-Time Optimization
    Link-time optimization (LTO) is a whole-program optimization technique that can improve runtime performance by 10-20% or more, at the cost of increased build times. In Cargo.toml.
lto = true
  • Codegen Units
    The Rust compiler splits your crate into multiple codegen units to parallelize (and thus speed up) compilation. However, this might cause it to miss some potential optimizations. This will optimize it as a all, not dividing into more than one units. You have to benchmark it, because it can run faster or in some cases slower. In Cargo.toml.
codegen-units = 1
  • Using CPU Specific Instructions - Compiling to native CPU features.
    It identifies and optimizes for the features of your CPU used in the compilation machine.
$ RUSTFLAGS="-C target-cpu=native" cargo build --release
opt-level = z

Rust bounds check removal

This forum thread shows well some ways to remove bounds check without the need to do a loop for and a iterator, the case where bounds check are automatically removed, or without using the manual way get_unchecked().

I have put here some examples from the previous forum thread of bounds check removal with a simple assert. Imagine that you have a loop with a index array that the compiler can’t easily know that it doesn’t need to bounds check a easy way to ensure that the bounds check will be removed is with the introduction of an assert that will assure to the compiler it is safe. In this case the assert only makes one bounds check outside a loop and all the bounds checks inside the look will disappear.

// Instead of….
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);

// Do….
assert_eq!(array1.len(), array2.len());
for i in array1.len() {
    println!("{} {}", array1[i], array2[i]);
// This does three bounds checks
pub fn demo1(x: &[i32]) -> i32 {
    x[0] + x[1] + x[2]

// Whereas these two examples each only have one bounds check:
pub fn demo2(x: &[i32]) -> i32 {
    assert!(x.len() >= 3);
    x[0] + x[1] + x[2]

pub fn demo3(x: &[i32]) -> i32 {
    let x = &x[..3];
    x[0] + x[1] + x[2]
  • Removal of bounds checks in extreme cases.
    Rust has slice, array and Vec bounds checks for each indices.
    If you use iterators there will be no bounds check.
    But in the common case Rust uses LLVM, and LLVM does a very good job at removing the bounds checks that aren't needed.
    But if you need the fastest code implementation and want to remove bounds check, you can use get_unchecked() and get_unchecked_mut(), they must be inside a unsafe block.
let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
assert_eq!(x, &[1, 13, 4]);
// Normal performance: 84,694,933 ns/iter (+/- 7,412,836)

// This optimization:  41,440,947 ns/iter (+/- 752,463)   [x2 times faster]

fn bench_vec_of_vec_unsafe(b: &mut Bencher) {
    let (m, n) = (10000, 10000);
    let mut matrix = vec![vec![0u8; n]; m];
    b.iter(|| {
        for i in 0..m {
            for j in 0..n {
                unsafe {
                    *matrix.get_unchecked_mut(i).get_unchecked_mut(j) = 1u8;

Notes - General

  • Enum Option - Option.copied()
// y_copy is a new Option of the cloned char 'a'.
// x is Option<&T> and the y_copy is Option<T> . 
let c: char = 'a';
let x: Option<&char> = Some(&c);
let y_copy: Option<char>  = x.copied();  // =>  Option<char>
  • Trait Iterator - Iterator.copied()
    Example modified from std lib docs.
// Trait Iterator - Iterator.copied()
// Creates an iterator which copies all of its elements.
// This is useful when you have an iterator over &T, but you need an iterator over T.

let a = [1, 2, 3];

    // Vector of references &T , &i32
    let v_copied_ref: Vec<&i32> = a.iter().collect();

// Vector of copied items T , i32
let v_copied: Vec<i32> = a.iter().copied().collect();

// You should write the Vec type like this "vec<_>".
// let v_copied: Vec<_> = a.iter().copied().collect();

// Copied is the same as .map(|&x| x)
let v_map: Vec<_> = a.iter().map(|&x| x).collect();

assert_eq!(v_copied, vec![1, 2, 3]);
assert_eq!(v_map, vec![1, 2, 3]);

// Better and faster to just transform an array into a Vec.
let v_copied_2 = a.to_vec();
assert_eq!(v_copied_2, vec![1, 2, 3]);

Notes on optimization

use std::collections::HashMap;
use fasthash::murmur2::Murmur2_x86_64;

let s = Murmur2_x86_64::new();
let mut map = HashMap::with_hasher(s);
map.insert(1, 2);
  • But for a even faster HashMap or HashSet use,
    hashbrown - Faster drop in replacement for STD HashMap and HashSet, a Rust port of Google's high-performance SwissTable hash map.
    Insert crate hashbrown into .toml file
// The fastest HashMap for Rust. HashBrown a drop in replacement for std HashMap.
use hashbrown::HashMap;
// In main do.

   // In the scope, add the alias to replace normal Strings with SmartString.  
   use smartstring::alias::String;

   // When creating SmartString's from &str instead of doing:

   // Do:

Rust substring processing

  • Rust string processing is kind of hard, because text in a UTF-8 world has many complex details, and Rust exposes all that power and all that complexity to you, the programmer. Sometimes it can be over whelming. Sometimes you only want to have a simple substring or a slice and you don’t mind to pay it’s cost, because you really need this feature and the Standard Library doesn’t help you a lot there.

  • Fortunately carlomilanesi made this code available to all

  • But if you have to do many text operations based on the positions of chars inside a strings this isn’t a really good option, because you have to scan all the strings to the correct position, from the start, to have the string divided it into the correct boundaries of the chars. In this context, you would happily pay a up front cost of transforming the string into a Vec, Vec of chars with individual chars separated, and process it as positional chars with access cost of 1 and then, slice them, range them, append to them at the end (or if you need to append in the start or the middle paying the cost of copy to a new buffer, but you can do it if you need to). The following code is my expansion to the code of carlomilanesi. It will allow you to do it.
    You can find it also in my GitHub repository in…

  • SubStrings, Slices and Random String Access in Rust

use std::ops::{Bound, RangeBounds};

trait StringUtils {
    fn substring(&self, start: usize, len: usize) -> &str;
    fn slice(&self, range: impl RangeBounds<usize>) -> &str;
    fn get_vec_chars(&self) -> Vec<char>;

impl StringUtils for str {
    fn substring(&self, start: usize, len: usize) -> &str {
        let mut char_pos = 0;
        let mut byte_start = 0;
        let mut it = self.chars();
        loop {
            if char_pos == start { break; }
            if let Some(c) = {
                char_pos += 1;
                byte_start += c.len_utf8();
            else { break; }
        char_pos = 0;
        let mut byte_end = byte_start;
        loop {
            if char_pos == len { break; }
            if let Some(c) = {
                char_pos += 1;
                byte_end += c.len_utf8();
            else { break; }
    fn slice(&self, range: impl RangeBounds<usize>) -> &str {
        let start = match range.start_bound() {
            Bound::Included(bound) | Bound::Excluded(bound) => *bound,
            Bound::Unbounded => 0,
        let len = match range.end_bound() {
            Bound::Included(bound) => *bound + 1,
            Bound::Excluded(bound) => *bound,
            Bound::Unbounded => self.len(),
        } - start;
        self.substring(start, len)
    fn get_vec_chars(&self) -> Vec<char> { self.chars().collect() }

trait StringUtilsVecChars {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;

impl StringUtilsVecChars for Vec<char> {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        for c in self.iter() { buf.push(*c); }

trait StringUtilsSlices {
    fn to_string(&self) -> String;
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String;

impl StringUtilsSlices for [char] {
    fn to_string(&self) -> String { self.iter().collect() }
    fn to_string_buf<'a>(&self, buf: & 'a mut String) -> & 'a String {
        for c in self.iter() { buf.push(*c); }

fn main() {
    let s = "abcdèfghij";
    // All three statements should print:
    // "abcdè, abcdèfghij, dèfgh, dèfghij."
    println!("{}, {}, {}, {}.",
        s.substring(0, 5),
        s.substring(0, 50),
        s.substring(3, 5),
        s.substring(3, 50));
    println!("{}, {}, {}, {}.",
    println!("{}, {}, {}, {}.",

    // Allocating a string from Vec<char>.
    let mut vc = s.get_vec_chars(); 
    println!("{}, {}, {}, {}.",

    // Reusing a String buffer from a Vec<char>.
    let mut buf = String::new();
    print!("{}, ", vc[..5].to_string_buf(& mut buf));
    print!("{}, ", vc[..].to_string_buf(& mut buf));
    print!("{}, ", vc[3..8].to_string_buf(& mut buf));
    print!("{}.\n", vc[3..].to_string_buf(& mut buf));
    // Random access to the Vec<char>. 
    for i in 0..(vc.len() - 2) {
        print!("{} ", vc[i..i+3].to_string_buf(& mut buf));
    // Random modifications to the Vec<char>.
    for i in (0..(vc.len() / 3) + 1).rev() {
        vc.insert(i*3, '#');
    println!("{} ", vc.to_string());
    println!("{} ", vc.to_string_buf(& mut buf));

// Output:
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abcdè, abcdèfghij, dèfgh, dèfghij.
//    abc bcd cdè dèf èfg fgh ghi hij 
//    #abc#dèf#ghi#j
//    #abc#dèf#ghi#j

Macros in Rust

  1. Macro file visibility rules

  2. Macros for hashMap, hashset, btreeMap, btreeSet to look similar to Python
    Crate maplit

#[macro_use] extern crate maplit;

let map = hashmap!{
    "a" => 1,
    "b" => 2,

let map1: HashMap<String, String> = convert_args!(hashmap!(
    "a" => "b",
    "c" => "d",

let map2 = convert_args!(keys=String::from, hashmap!(
    "a" => 1,
    "c" => 2,
  1. Macro for graph's
    See the following post from kaj, on the Rust user foruns.
# When you have the following dictionary Python code...

# Adjacency list of graph
data = {
    0: [1, 2],
    1: [0, 2],
    2: [0, 1, 3, 5],
// And you implement it in Rust like this...

let data = HashMap::from([
    (0, vec![1, 2]),
    (1, vec![0, 2]),
    (2, vec![0, 1, 3, 5]),

// ...but you can instead implement it like this...

let data2 = graph![
    0 => 1, 2;
    1 => 0, 2;
    2 => 0, 1, 3, 5

// ...using the following simple Macro...

use std::collections::HashMap;

macro_rules! graph {
    [$($k:expr => $($v:expr),*);*] => {
            $(($k, vec![ $($v),* ])),*

Good way to learn about the topic of computers and programming

  1. Video - Computer Science - Crash Course

For a good challenge do the NAND To Tetris in Rust

  1. From Nand to Tetris
    Building a Modern Computer From First Principles

  2. Video - Shimon Schocken: The self-organizing computer course

  3. Video - From Nand to Tetris Part I Course Promo

  4. Free Course - Build a Modern Computer from First Principles
    From Nand to Tetris (Project-Centered Course)

  5. Free Course - Build a Modern Computer from First Principles
    Nand to Tetris Part II (project-centered course)

All my other guides

Have fun

Best regards,
Joao Nuno Carvalho


A guide to the adventurer.






No releases published


No packages published