Learn Rust by reading many small snippets explaining keywords and symbols.

C2Rust is a project for converting (legacy) C code into equivalent Rust code. The resulting Rust code is very low level and uses pointers and unsafe. The website offers an online demo to show the capabilities of the tool.

A collection of software engineering techniques for effectively expressing intent with Rust.

The repository contains some problems which can be encountered with Rust and explains some solutions for them.

Evcxr is a Rust interpreter and also provides a Jupyter kernel. This is a helpful addition to the online playground as it allows installing and using any crate.

The cheat sheet shows in many code snippets how to do things.

The cheat sheet is produced by https://letsgetrusty.com/ and requires registering to get access.

These websites provide tools, which convert JSON data to structs in different programming languages.

• https://transform.tools/json-to-rust-serde
  The website supports data type generation for a large set of languages. It also supports SVG, HTML, CSS, and GraphQL as input to convert.
• https://typegen.vestera.as/
• https://app.quicktype.io/
  The website supports data type generation for a large set of languages.
• https://schema-analysis.com/ Support JSON, YAML, CBOR, TOML, and XML as input. Multiple output formats are supported too.

The URLO thread has a very extensive list of Rust crates. The list contains good, more or less well-known crates, each with a tiny description.

In the Pin and suffering article, the author fasterthanlime explains how to implement async functions in Rust. The article starts by implementing an async function and the problem of calling blocking functions. It continues with instructions on how to work with Pin and Unpin futures. At the end, the article explains how all of the above can be done without using the syntactic sugar of async functions.

• https://play.rust-lang.org/
  • The Rust playground.
• https://www.rustexplorer.com/
  • Rust playground with the top 10k crates.
• https://www.corust.dev/
  • Collaborative Rust playground.
• https://repl.it/languages
  • REPLs for many languages.
• https://www.tutorialspoint.com/online-programming-compilers.htm
  • Programming playgrounds for a wide variety of languages.
• https://jvns.ca/blog/2023/04/17/a-list-of-programming-playgrounds/
  • Curated list of programming playgrounds.
• https://dev.java/playground/
  • The Java Playground

Rubri is a proof-of-concept Rust executor that fully runs in the browser. The execution speed will be pretty slow since it executes Miri code.

The Rust API guidelines explain conventions around naming, interoperability, and documentation for libraries. It provides a helpful checklist for all important points.

The "Rust Atomics and Locks" book by Mara Bos provides in great detail information about concurrent programming in Rust. It starts with the concurrent programming concepts available in Rust. On this basis, atomics, locks, and channels are explained by building a new one. At the end, it also covers processor and operating system details.

This repository showcases some examples of tricky Rust code that I have encountered during my years working with various advanced macro libraries in Rust (my own and others').

• Rust Container Cheat Sheet
  A slightly older documentation about all of Rusts different container and pointer types.
• Rust String Conversions
  Explains how to convert the different string types into each other.
• Language Cheat Sheet
  Extensive documentation on around the syntax and the base language. Contains links to the book, Rust by Example, the Standard library documentation, the Nomicon, and the Rust Reference, where these links are appropriate.

The Rust Cookbook describes tiny common tasks you might want to do and shows how to solve them in Rust. It introduces many useful crates, which are widespread in the Rust ecosystem, but can also be used to look up solutions to common problems.

Helps in understanding macro_rules macros by automatically generating syntax diagrams for them.

The website shows some Rust code snippets and asks for the output of the program. The questions are medium to hard and often use more advanced features, like macros or lifetimes. Each code snippet has an explanation of the behavior. The website is maintained on GitHub.

This is essentially regexr for Rust. It helps in understanding and writing regular expressions (regex). It takes a regex and explains the different parts of it. Likewise, it also shows how the regex applies to a sample text.

Ferrous Systems creates a large set of presentations explaining basic Rust concepts. They cover the basics like different Rust types, more advanced features like generics and dynamic dispatch, and also include a set of training assignments.

The presentations are all available on GitHub too: https://github.com/ferrous-systems/teaching-material

The website provides tiny interactive tutorials to teach individual Rust concepts. Each tutorial is a tiny runnable Rust snippet. The snippet can be executed directly on the website, providing instant feedback.

Rust regular expression editor and tester.

The Rustlings project is a Rust project consisting of many small exercises. The exercises consist of small code pieces which need to be filled in and contain tests for checking your work. This trains reading and writing Rust code.

First steps with Rust guide by Microsoft. It starts with the basics of installing the tools, the first program, and continues with error handling, traits, and test writing.

"The Little Book of Rust Books" provides an overview of other Rust books. It covers official books such as "the book" or the cargo guide and also unofficial books like the Rust cookbook or the serde book.

Welcome to the Tour of Rust. This is meant to be a step-by-step guide through the features of the Rust programming language. Rust is often considered a language with a steep learning curve, but I hope I can convince you there's a lot to explore before we even get to complex parts.

The Tour of Rust is available in many languages.

The website shows some Rust code snippets. The challenge is to determine if it compiles and if so, what the expected output is. The questions are hard and often use more advanced features, like macros, unsafe, or lifetimes. The website is maintained on GitHub.

Presentation about the basic usage of Rust's serde in three parts:

• The Serde model and structs
• Using Serde with enums
• Doing Things Manually

https://caniuse.rs shows which library functions were stabilized in which Rust version.

The website is a small dashboard that shows the cargo version that is used to access crates.io. This is not cleaned from automatic download like CI systems, but it does provide a rough estimate of adoption of new cargo and Rust versions.

explaine.rs is an interactive playground to explore the syntax of the Rust Programming Language.

You can write any Rust code in the editor and the analyzer will allow you to click/tap on different keywords, punctuation elements and other bits of code and help you understand what they mean.

query.rs offers searching in various rust sources. This includes searching the std documentation for types, functions, or function signatures. Crates can be searched by name and similar by types and functions. It includes further resources, like error codes, lints, and more.