This repository collects resources for writing clean, idiomatic Rust code. You can find a sortable/searchable version of this list here.
Idiomatic coding means following the conventions of a given language. It is the most concise, convenient, and common way of accomplishing a task in that language, rather than forcing it to work in a way the author is familiar with from a different language. - Adapted from Tim Mansfield
Contributions welcome! To add missing resources, please refer to the contributing documentation.
-
blessed.rs — An unofficial guide to the Rust ecosystem. Suggestions for popular, well-maintained crates.
-
cheats.rs - Idiomatic Rust tips — A list of quick tips to make your code more idiomatic.
-
clippy — A bunch of lints to catch common mistakes and improve your Rust code.
-
Elements of Rust — A collection of software engineering techniques for effectively expressing intent with Rust.
-
Patterns — A catalogue of design patterns in Rust.
-
Possible Rust — A blog for intermediate Rust programmers exploring real-world code and design patterns.
-
Rust Anthology — The best short-form writing about Rust, collected.
-
Rust API Guidelines — An extensive list of recommendations for idiomatic Rust APIs.
-
Rust by Example — A community driven collection of example code which follow Rust best practices.
-
Build your own JIRA with Rust — A test-driven workshop to learn Rust by building your own JIRA clone!
-
Comprehensive Rust — A four day Rust course developed by the Android team, covering all aspects of Rust.
-
Ferrous Systems Teaching Material — Free workshop material produced by Ferrous Systems for trainings.
-
Hecto: Build your own text editor in Rust — This is a series of blog posts that shows you how to build a text editor in Rust
-
Idiomatic Rust Workshop — A talk/workshop about idiomatic Rust code focusing on effective use of existing syntax and design patterns
-
PingCAP talent plan — A series of training courses about writing distributed systems in Rust.
-
Procedural Macros Workshop — A selection of projects designed to learn to write Rust procedural macros.
-
Rust 101 — A Rust University course by tweede golf.
-
Rust Development at Sentry — A document containing useful resources for getting started with Rust and adhering to Sentry coding principles.
-
rust-lang/rustlings — Small exercises to get you used to reading and writing Rust code.
-
Command Line Applications in Rust — A tutorial on how to write CLI apps in Rust, learning many aspects of the ecosystem.
-
Command-Line Rust — Learn the language by writing Rust versions of common Unix coreutils.
-
Discover the world of microcontrollers through Rust! — An introductory course on microcontroller-based embedded systems using Rust.
-
High Assurance Rust — Developing secure and robust software, focusing on embedded-friendly data structures in Rust.
-
Programming Rust: Fast, Safe Systems Development — A comprehensive Rust Programming Guide that covers most of Rust's features in detail.
-
Rust Atomics and Locks — Helps Rust programmers of all levels gain a clear understanding of low-level concurrency.
-
Rust Cookbook — Examples that demonstrate good practices to accomplish common programming tasks in Rust.
-
Rust for Rustaceans — Covers how to design reliable, idiomatic, and ergonomic Rust programs based on best principles.
- Aim For Immutability in Rust — Explains why variables are immutable in Rust by default.
- Compile-Time Invariants in Rust — Shows how macros can be used to enforce invariants at compile-time.
- Rust Number Conversion: Don't Follow the Book... — A blog post discussing the best practices for number conversion in Rust.
- Hexagonal architecture in Rust — Describes how to build a Rust service using domain driven design and a test-first approach.
- Wrapping errors in Rust — Wrapping 'reqwest::Error' and a custom error type as an enum to make library usage easier.
- Aiming for idiomatic Rust — Discusses different ways to solve a popular coding puzzle, 'balanced brackets', in Rust.
- Naming Your Lifetimes — Explains how using longer, declarative lifetime names can help to disambiguate which borrow is which.
- Are out parameters idiomatic in Rust? — Discusses the pros and cons of functions returning a value vs. modifying a parameter in-place.
- Guide on how to write documentation for a Rust crate — Writing good documentation with rustdoc including many examples.
- Learning Rust through open source and live code reviews — Covers patterns like 'FromStr' and exposing a CLI and a library in one crate.
- Refactoring Rust Transpiled from C — Describes how to lift a C-project that was automatically converted to unsafe Rust to safer, more idiomatic Rust.
- Context-preserving error handling — Explains how to use crates like 'thiserror' in combination with 'map_err' to add context to errors.
- Rust Patterns: Enums Instead Of Booleans — Discusses how using enums instead of booleans can express intent more clearly in Rust.
- Taking string arguments in Rust — Discussing how to avoid subtle issues with string handling and when to use 'str' vs 'String'.
- Await a minute — Example code for moving from raw futures to async/await syntax to improve error handling.
- Programming an ARM microcontroller in Rust at four different levels of abstraction — Demonstrates how Rust helps to move from low-level embedded code to high-level abstractions.
- The balance between cost, useability and soundness in C bindings, and Rust-SDL2's release — Writing safe, sound, idiomatic libraries despite the limitations of the borrow checker.
- Math with distances in Rust: safety and correctness across units — How to create a system to cleanly and safely do arithmetic with lengths.
- Lessons learned redesigning and refactoring a Rust Library — 'RefCell', the builder pattern and more.
- Iteration patterns for Result & Option — Explores how to filter and partition iterators of Result and Option types idiomatically.