rust-lang/rustlings

This system is an interactive CLI tool and educational platform designed to teach the Rust programming language through a structured set of hands-on exercises. It provides a terminal-based interface for browsing, running, and verifying solutions across core language topics such as variables, ownership, concurrency, and async programming. The system also includes tooling for creating and validating community-contributed exercises, alongside a static website for documentation.

24 changes.

This period focused on the comprehensive expansion of the Rustlings exercise curriculum, introducing modules for variables, functions, control flow, ownership, structs, enums, strings, modules, hashmaps, error handling, generics, traits, iterators, threads, smart pointers, and conversions. Concurrently, the project underwent a significant architectural overhaul, rewriting the CLI and watch mode with a new TUI, state management, and integration testing to improve the user experience and development workflow.

19 changes.

The project introduced a new list interface with search and filtering capabilities, while refactoring watch mode to support manual execution and debounced file watching. Concurrently, the codebase was significantly expanded with comprehensive solution files for nearly all existing exercises and the addition of new quiz modules.

5 changes.

The project introduced asynchronous programming exercises using the Tokio runtime to teach concurrent file processing and task management. Simultaneously, the website was rebuilt using the Zola static site generator with Tailwind CSS styling and new template structures.

A new exercise module (12\_options) has been added to the track, introducing three exercises (options1, options2, options3) that teach the use of Rust's Option type. The module includes a README explaining the concept and use cases, along with starter code for implementing functions that return Option values, using if-let/while-let statements, and pattern matching with Option enums.

_exercises/04\_primitive\_types, exercises/12\_options, exercises/21\macros · high confidence

The async1 exercise solution now demonstrates asynchronous programming by using the Tokio runtime to concurrently calculate mean test scores from three separate class files. The solution spawns three async tasks to read and process 'scores\_class\_a.txt', 'scores\_class\_b.txt', and 'scores\_class\_c.txt' simultaneously, then aggregates the results to verify the expected mean scores (84, 89, and 76 respectively).

_solutions/24\async · high confidence

The new async1 exercise in the 24\_async module introduces asynchronous programming using the tokio runtime. It simulates calculating mean test scores for three classes concurrently by spawning async tasks that read from separate input files (scores\_class\_a.txt, scores\_class\_b.txt, scores\_class\_c.txt). The exercise requires users to fix compiler errors by making the calculate\_mean\_score function async and awaiting the spawned tasks to verify the results.

_exercises/24\async · high confidence

Added a new 'Modules' exercise section (exercises/10\_modules) introducing Rust's module system, including three exercises (modules1, modules2, modules3) and a README with further reading.

_exercises/10\modules · high confidence

The website now uses a new set of Zola templates, including a base layout with header/footer navigation, a 404 error page, an index page, and a page template that displays a table of contents. A new anchor-link template and a component for collapsible details sections have also been added to support the site's content structure.

website/templates · high confidence

A new 'Threads' exercise module has been added to the curriculum, introducing learners to concurrent programming in Rust. The module includes a README with reference links and three progressive exercises: threads1 focuses on spawning threads and collecting their return values using JoinHandles; threads2 demonstrates sharing mutable state between threads using Arc and Mutex; and threads3 covers message passing between threads using channels (mpsc).

_exercises/20\threads · high confidence

Added solution files for the modules exercises (modules1, modules2, and modules3) in the solutions directory. These files demonstrate correct implementations for module visibility, re-exporting with aliases, and using standard library time features.

_solutions/10\modules · high confidence

Added reference solution files (strings1.rs through strings4.rs) for the strings exercise, providing implementations for string creation, slicing, trimming, composition, replacement, and type coercion.

_solutions/09\strings · high confidence

The \exercises/09\_strings\ directory now includes a README and four exercise files (strings1.rs through strings4.rs) that provide completed solutions for learning Rust string handling. These exercises cover creating owned \String\ values, passing string slices, trimming/composing/replacing strings, and distinguishing between \&str\ and \String\ types in function calls.

_exercises/09\strings · high confidence

The \exercises/07\_structs\ location now includes a complete exercise set (structs1.rs, structs2.rs, structs3.rs) and a README. Users are guided through defining regular, tuple, and unit structs, using struct update syntax, and converting free-standing functions into methods and associated functions on a \Fireworks\ struct, with tests verifying the expected behavior.

_exercises/07\structs · high confidence

New solution files (clippy1.rs, clippy2.rs, clippy3.rs) have been added to the 22\_clippy exercise directory, demonstrating how to resolve common Clippy warnings. These examples show best practices such as using the standard library's PI constant, replacing iteration with if-let for Option handling, using clear() instead of resize(0) for vectors, and using mem::swap for value swapping.

_solutions/22\clippy · high confidence

A new exercise set (exercises/22\_clippy) has been added to teach users how to use the Clippy tool for catching common Rust mistakes. The set includes three exercises (clippy1.rs, clippy2.rs, clippy3.rs) that require fixing specific Clippy warnings, such as incorrect float usage, improper Option handling, and inefficient code patterns, along with a README explaining how to install and use Clippy.

_exercises/22\clippy · high confidence

Introduced a new 'Hashmaps' exercise module (exercises/11\_hashmaps) containing three progressive tasks: hashmaps1.rs requires populating a HashMap with fruit names and counts; hashmaps2.rs involves managing a basket of fruits using an enum key while preserving existing entries; and hashmaps3.rs focuses on parsing soccer match results to build a score table using a custom TeamScores struct. The set includes a README explaining hash maps and comprehensive unit tests for each exercise.

_exercises/11\_hashmaps, exercises/16\lifetimes · high confidence

The enums exercise (exercises/08\_enums) now includes a README and three Rust source files (enums1.rs, enums2.rs, enums3.rs) that guide users through defining and using enums. enums1.rs introduces basic enum variants, enums2.rs demonstrates enum variants with associated data, and enums3.rs provides a State struct with methods that are invoked via a match expression on a Message enum, testing the user's ability to process different message variants and update state accordingly.

_exercises/08\enums · high confidence

The \exercises/01\_variables\ directory now contains a complete set of six exercises (variables1.rs through variables6.rs) along with a README. These exercises guide users through core Rust variable concepts, including immutability, mutability, type inference, shadowing, and constants, requiring users to fix compiler errors to complete each task.

_exercises/01\variables · high confidence

The 'exercises/03\_if' module now includes three new exercises (if1.rs, if2.rs, if3.rs) and a README to teach Rust's if expressions. if1.rs asks users to implement a function that returns the larger of two integers, if2.rs requires fixing a type mismatch in a function that returns different string responses based on food input, and if3.rs involves fixing type consistency in a multi-branch if-else expression that maps animal names to habitats.

_exercises/03\if · high confidence

The move\_semantics section now includes five exercises (move\_semantics1 through move\_semantics5) along with a README linking to the Rust Book chapters on ownership and borrowing. These exercises guide users through fixing compiler errors related to vector ownership, mutability, borrowing, and reference handling.

_exercises/06\_move\semantics · high confidence

A new 'Traits' exercise module (exercises/15\_traits) has been added to the curriculum, containing five exercises (traits1 through traits5) and a README. These exercises guide users through implementing traits for specific types (String, Vec\<String\>), using default trait method implementations, and applying trait bounds to generic functions.

_exercises/15\traits · high confidence

A new \exercises/quizzes\ directory has been introduced containing three quizzes that test knowledge across multiple sections. Quiz 1 covers Variables, Functions, and If statements with a scenario involving apple pricing. Quiz 2 focuses on Strings, Vecs, Move semantics, Modules, and Enums, requiring the implementation of a command transformer. Quiz 3 tests Generics and Traits by modifying a ReportCard struct to support both numerical and alphabetical grades.

exercises/quizzes · high confidence

The \solutions/quizzes\ directory now contains complete Rust source files for three quizzes. Quiz 1 provides a solution for calculating apple prices with bulk discounts. Quiz 2 demonstrates two approaches (loop-based and iterator-based) for transforming a list of strings using specific commands. Quiz 3 implements a generic \ReportCard\ struct that supports both numerical and alphabetical grades by leveraging the \Display\ trait.

solutions/quizzes · high confidence

The solutions directory now includes complete reference implementations for the smart pointers and conversions modules. The smart pointers section provides solutions for creating recursive cons lists using Box, managing multiple owners with Rc, sharing data across threads using Arc, and implementing Clone-On-Write logic with Cow. The conversions section adds solutions demonstrating type casting with the as operator, value-to-value conversions via the From trait for temperature units, string parsing with FromStr for structured data, fallible conversions using TryFrom for color tuples and arrays, and reference-to-reference conversions using AsRef and AsMut.

_solutions/23\conversions · high confidence

The solutions directory for the 'if' chapter now includes complete Rust implementations for exercises if1, if2, and if3. if1.rs provides a function to determine the larger of two integers; if2.rs implements a conditional food selector with specific responses for strawberries, potatoes, and other items; and if3.rs demonstrates using an integer identifier within an if-else chain to map animal names to their habitats (Beach, Burrow, Desert, or Unknown).

(repo-wide) · high confidence

This change introduces the reference solutions for the five exercises in the iterators module (iterators1 through iterators5). The solutions demonstrate idiomatic Rust iterator usage, including basic iteration over slices, string capitalization via map and collect, handling division errors with Result types, computing factorials using fold and product, and counting progress states in hash maps using filter, flat\_map, and sum.

_solutions/18\iterators · high confidence

The solutions directory for the lifetimes module now includes working Rust code for three exercises. lifetimes1.rs provides a function that returns the longer of two string slices using lifetime annotations. lifetimes2.rs demonstrates two approaches to managing reference lifetimes when a borrowed value is dropped, either by extending the variable's scope or by moving the usage into the inner block. lifetimes3.rs shows how to annotate lifetime parameters on a struct that holds references.

_solutions/16\lifetimes · high confidence

The solutions/00\_intro directory now includes reference implementations for the initial exercises. intro1.rs provides the solution for the first exercise, which serves as a terminal navigation step, while intro2.rs demonstrates the correct usage of the println! macro to print "Hello world!", correcting the common typo printline!.

_solutions/00\intro · high confidence

Added four Rust source files (macros1.rs through macros4.rs) to the solutions directory, providing completed implementations for the macros exercise. These files demonstrate macro definition, ordering, the \macro\_use\ attribute, and multi-arm macro syntax.

_solutions/02\_functions, solutions/21\macros · high confidence

This change introduces the completed solution code for the three hashmaps exercises (hashmaps1, hashmaps2, and hashmaps3). For hashmaps1, it provides a function that populates a HashMap with at least three types of fruits totaling five or more items. For hashmaps2, it implements a function using \entry().or\_insert()\ to ensure a basket contains at least one of each of five fruit types with a total count exceeding eleven, without modifying existing entries. For hashmaps3, it adds a \TeamScores\ struct and a function that parses soccer match results into a HashMap, using \entry().or\_default()\ to aggregate goals scored and conceded for each team.

_solutions/11\hashmaps · high confidence

The \solutions/20\_threads\ directory now includes complete Rust solutions for the threading exercises. \threads1.rs\ demonstrates spawning multiple threads that sleep and return their execution duration, collecting results via \join()\. \threads2.rs\ shows how to use \Arc\<Mutex\<\>\>\ to safely update a shared \JobStatus\ counter across threads. \threads3.rs\ implements a message-passing solution using \mpsc::channel\ to coordinate two threads sending values from a queue, verified by a test that checks the received values are sorted.

_solutions/08\_enums, solutions/14\_generics, solutions/20\threads · high confidence

New solution files have been added for the vecs1 and vecs2 exercises. The vecs1 solution demonstrates creating a vector from individual elements using the \vec!\ macro, while the vecs2 solution shows how to iterate over a slice and double each element using a standard for-loop.

_solutions/05\vecs · high confidence

The repository is initialized with essential configuration files including \.gitignore\, \clippy.toml\, \.typos.toml\, and \.rumdl.toml\ to enforce linting, typo checking, and markdown formatting rules. A \build.rs\ script is added to handle Windows-specific file link workarounds, and a \release-hook.sh\ script is introduced to automate CI-like checks (clippy, fmt, tests) and MSRV validation before releases. Documentation files \README.md\ and \CONTRIBUTING.md\ are created, with the latter establishing an LLM usage policy for contributions.

(repo-wide) · high confidence

Added a new 'Error handling' exercise module (exercises/13\_error\_handling) containing six progressive Rust exercises (errors1.rs through errors6.rs) and a README. These exercises guide users through handling recoverable errors using Result, managing parsing errors with ParseIntError, creating custom error enums, implementing the Error trait, using boxed trait objects for generic error handling, and defining custom error types to distinguish between different error sources like parsing and validation.

_exercises/13\_error\handling · high confidence

Rustlings now includes a \dev\ CLI with \new\ and \check\ subcommands to streamline the creation and validation of community exercise repositories. The \dev new\ command scaffolds a new project directory with a \Cargo.toml\ (using edition 2024), \info.toml\, and necessary configuration files like \.gitignore\ and \rust-analyzer.toml\. The \dev check\ command validates exercise structure, ensuring required elements like \fn main()\ and \// TODO\ comments are present, verifying that \\#\[test\]\ annotations match the \test\ flag in \info.toml\, checking for unexpected files, and ensuring the \Cargo.toml\ bin list is up to date.

src/dev · high confidence

Added the \19\_smart\_pointers\ and \23\_conversions\ exercise tracks. The smart pointers section introduces \Box\ for recursive types, \Rc\ for single-threaded reference counting, \Arc\ for thread-safe shared ownership, and \Cow\ for clone-on-write semantics. The conversions section covers type casting with \as\, value conversions via \From\/\Into\, fallible conversions with \TryFrom\/\TryInto\, string parsing with \FromStr\, and reference conversions using \AsRef\/\AsMut\.

_exercises/23\conversions · high confidence

A new 'Iterators' section has been added to the exercises, containing five progressive exercises (iterators1 through iterators5) that guide users through creating iterators, mapping transformations, handling errors with Result types, computing factorials, and replacing imperative loops with iterator methods for counting map entries.

_exercises/18\iterators · high confidence

A new list interface has been added to the application, allowing users to browse exercises with search and filter capabilities (Done/Pending). The implementation introduces dedicated state management for scrolling behavior and row rendering, including logic to highlight search matches in exercise names and manage terminal size constraints for the display.

src/list · high confidence

The rustlings-macros crate now provides an \include\_files\ proc-macro that reads \info.toml\ to statically embed exercise definitions, source code, solutions, input files, and READMEs into the binary at compile time. This replaces the previous runtime loading of these resources, ensuring that all exercise content is available immediately without file-system access during execution.

rustlings-macros/src · high confidence

The website has been rebuilt using the Zola static site generator, replacing the previous tooling. This change introduces a new configuration structure (config.toml) defining the site metadata, menu items (including a Q&A link), and footer links. It also implements a new styling system using Tailwind CSS (input.css) with a Dracula syntax highlighting theme, and updates the build process via a justfile to handle Zola serving and CSS processing.

website · high confidence

The application has been completely rewritten to use a new architecture. The CLI now uses Clap for argument parsing, introducing a new \list\ command that provides a terminal-based interface to browse, search, and filter exercises. The previous \watch\ mode has been replaced by a new terminal user interface (TUI) that handles exercise verification, hints, and progress tracking. The state management has been refactored into a dedicated \AppState\ module that persists progress to a \.rustlings-state.txt\ file. The initialization process now uses a new \init\ command that sets up the exercise directory, solutions, and a \Cargo.toml\ with embedded exercise binaries. The \dev\ subcommand has been updated to support creating and checking community exercises.

src · high confidence

The exercises in the functions module have been updated to include solutions and stricter type constraints. Specifically, the \call\_me\ function now accepts a \u8\ argument to prevent excessively large outputs, and the \sale\_price\ function signature has been corrected to return an \i64\. Additionally, the \square\ function body has been fixed to properly return the calculated value, and the \README\ now links to the official Rust book chapter on functions.

_exercises/02\functions · high confidence

The generics exercises have been rewritten to focus on practical application of type parameters. In generics1, users must now explicitly annotate the type of a Vec to resolve compiler errors when pushing mixed integer types (u8 and i8), rather than relying on inference. In generics2, the Wrapper struct has been refactored from holding a specific u32 value to being generic over any type T, requiring users to implement the struct and its new method to support storing values of arbitrary types, as verified by tests for both u32 and string storage.

_exercises/14\generics · high confidence

The intro exercises have been refreshed: intro1.rs now displays a detailed ASCII welcome banner and instructions, while intro2.rs has been corrected to trigger a NameError (by using the undefined \printline!\ macro) instead of a format string error, aligning with the intended learning objective for this step.

_exercises/00\intro · high confidence

The test exercises in the \exercises/17\_tests\ directory have been refreshed with new starter code. \tests1.rs\ and \tests2.rs\ now provide basic structures for practicing \assert!\ and \assert\_eq!\ macros, while \tests3.rs\ introduces a \Rectangle\ struct to practice testing functions that may panic, including specific tests for negative dimensions. Additionally, the panic message in \tests3.rs\ has been corrected to ensure accurate error output during testing.

_exercises/17\tests · high confidence

The vecs2 exercise in the 05\_vecs module has been redesigned to require using a for-loop to multiply elements, removing the previous requirement to use the \map\ iterator method. This change simplifies the exercise for early learners by focusing on basic iteration and vector manipulation rather than functional iterator combinators.

_exercises/05\vecs · high confidence

The watch mode implementation has been refactored to introduce a \manual-run\ option, allowing users to control when exercises are executed rather than relying solely on automatic triggers. File change events are now debounced by 200ms to prevent excessive re-runs during rapid editing. Additionally, the system now pauses input processing while an exercise is running to avoid race conditions, and handles terminal resize events to maintain UI consistency.

src/watch · high confidence

Added Rust solution files for the Options exercise; Added integration tests for the CLI tool; Added solution code for the first three testing exercises.

This release updates the Rustlings project dependencies, including the main \rustlings\ package, the \rustlings-macros\ crate, and the \dev\ tooling, to version 6.5.0. The update includes bumps to key libraries such as \clap\ (4.6.6), \crossterm\ (0.29.0), \notify\ (8), and \serde\ (1), alongside the adoption of the Rust 2024 edition and a minimum supported Rust version (MSRV) of 1.88. The \dev/Cargo.toml\ manifest is now automatically generated to list all exercise binaries, and the website dependencies have been updated to include \@tailwindcss/cli\ version 4.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 61 (+18.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 82 (-17.7)
• Architecture 100 (new)
• Maturity 52 → 47 (-5.2)
• Readiness 26 → 70 (+44.8)
• Security 51 → 67 (+16.2)

• Dimension evaluation failed
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• …and 17 more

• AppState::check_all_exercises_impl (cognitive 35) (src/app_state.rs)
• AppState::new (cognitive 16) (src/app_state.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, dependency currency not (crates.io unreachable)
• Duplicated block (10 lines × 2) (exercises/19_smart_pointers/smart_pointers3.rs)
• Duplicated block (13 lines × 2) (exercises/19_smart_pointers/smart_pointers4.rs)
• Duplicated block (13 lines × 2) (exercises/20_threads/threads1.rs)
• Duplicated block (14 lines × 2) (exercises/24_async/async1.rs)
• Duplicated block (15 lines × 2) (exercises/07_structs/structs2.rs)
• Duplicated block (15 lines × 2) (exercises/23_conversions/conversions4.rs)
• Duplicated block (16–18 lines × 2) (exercises/20_threads/threads3.rs)
• Duplicated block (21 lines × 2) (exercises/03_if/if3.rs)
• Duplicated block (30 lines × 2) (exercises/13_error_handling/errors5.rs)
• Duplicated block (6 lines × 2) (exercises/10_modules/modules3.rs)
• Duplicated block (6 lines × 2) (exercises/20_threads/threads3.rs)
• Duplicated block (7 lines × 2) (exercises/08_enums/enums1.rs)
• Duplicated block (7 lines × 2) (exercises/13_error_handling/errors3.rs)
• Duplicated block (7 lines × 2) (exercises/13_error_handling/errors6.rs)
• Duplicated block (7 lines × 2) (src/cargo_toml.rs)
• Duplicated block (8 lines × 2) (exercises/11_hashmaps/hashmaps3.rs)
• Duplicated block (8 lines × 2) (exercises/16_lifetimes/lifetimes3.rs)
• …and 195 more

• 25 commits — 19 feature/other, 6 fixes

• exercises/24_async — 6 commits
• (root) — 4 commits
• dev/Cargo.toml — 3 commits
• (repo) — 2 commits
• exercises/23_conversions — 2 commits
• src/dev — 2 commits
• .github/workflows — 1 commit
• exercises/18_iterators — 1 commit
• exercises/quizzes — 1 commit
• solutions/12_options — 1 commit
• src/app_state.rs — 1 commit
• src/cargo_toml.rs — 1 commit

• fix: Fix clippy warnings in quiz3
• fix: Fix conversions3 explanation
• fix: Fix deprecation warning
• fix: Fix stale exercise references
• fix: Merge pull request #2433 from YangSiJun528/fix-stale-exercise-references
• fix: fix tests
• change: Add exercise async1
• change: Add triagebot config to aid with code review
• change: Change story of exercise async1
• change: Fix minor typo in comment in options 3 solution
• change: Merge pull request #2440 from douglashill/patch-1
• change: Preserve conversions3 wording
• change: Refer to tokio as "mainstream" instead of "popular"
• change: Relax version requirement for tokio
• change: Update Zola
• change: Update deps
• change: add llm usage policy for contributions
• change: async1: Read input from files
• change: async1: remove redundant TODO comment
• change: dev check: allow input files
• …and 5 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rust-lang/rustlings was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.