# mainmatter/100-exercises-to-learn-rust: a self-paced Rust course in 100 exercises

> Mainmatter's course turns Rust fundamentals into 100 graded exercises, with a book on rust-exercises.com and answers on a separate solutions branch. It is aimed at people who have never written Rust, and its licence is the main thing to check before using it at work.

**mainmatter/100-exercises-to-learn-rust** — A self-paced course to learn Rust, one exercise at a time.

- Repository: https://github.com/mainmatter/100-exercises-to-learn-rust
- Website: https://rust-exercises.com
- Stars: 9,616 · Forks: 2,193
- Language: Rust
- License: not declared
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/mainmatter-100-exercises-to-learn-rust

## What the 100 exercises actually cover, and who they are for

The README opens with a direct pitch: you have heard about Rust but never had the chance to try it, and this course takes you from knowing nothing about Rust to being able to start writing your own programs. That is a narrower promise than it sounds. The course is not a tour of async runtimes, embedded targets or FFI. It is a beginner path, and the sequencing is the product: 100 exercises, one at a time, with the course text hosted on rust-exercises.com rather than in the repository.

The intended reader is someone who has programmed before but not in Rust. The README recommends an IDE with Rust autocompletion and names RustRover and Visual Studio Code with the rust-analyzer extension. That recommendation only makes sense if the reader is expected to fight the borrow checker interactively. The course is written by Mainmatter and is listed as one of the trainings in their Rust workshop portfolio, so the exercise progression reflects material they teach in paid settings, repackaged for self-study.

## How the repository is laid out and how an exercise runs

The repository is a Cargo workspace, not a single crate. The root Cargo.toml lists its members as exercises/*/*, helpers/common and helpers/ticket_fields, with resolver = "2". That two-level glob under exercises/ is the structural clue: exercises are grouped into directories, and each individual exercise is its own crate nested inside a group. You do not compile the whole course at once as one binary; you work inside one exercise crate.

There is also a profile override that is worth reading before you assume anything about the build. The comment above it says it exists to guarantee the expected behaviour on that specific exercise, regardless of the global setting for overflow-checks on the dev profile, and it sets overflow-checks = true for the copy package. That is a deliberate choice to make arithmetic overflow panic in one exercise even if a reader has relaxed overflow checks globally. It is the kind of detail that breaks a learner's mental model if they never notice it.

Two helper crates sit outside the exercise tree: helpers/common and helpers/ticket_fields. The name of the second one suggests at least part of the course builds toward a small domain model with ticket fields, and shared code lives in helpers/common rather than being duplicated per exercise. The book/ directory holds the course text, and site/ holds the published version served at rust-exercises.com.

## Installing Rust and starting your first exercise

The README does not give clone-and-run instructions inside the repository. It points to rust-exercises.com and says to follow the instructions there. So the first step is the site, not the README. What the README does specify is the toolchain requirement: Rust, installed per the official instructions, and if rustup is already present, update it.

```bash
rustup update
```

Run that if you already have rustup. The README says to use another appropriate command if you installed Rust by some other route, so do not assume rustup exists on a distro-managed toolchain. After that, the optional but recommended step is an editor with autocompletion, either RustRover or VS Code with rust-analyzer.

The README does not document a custom runner or a course-specific CLI, so there is no exercise command to copy from it. The workspace layout does mean the exercise crates are ordinary Cargo members, and the README does not describe expected output for any run, so treat a first build as a check that your toolchain is current and the workspace resolves, not as a lesson in itself.

## The solutions branch is a separate artefact, and that shapes how you study

Answers live on the solutions branch, not on main. The README links to it directly. This is a real design decision with consequences. On main you get the exercise stubs and the helper crates; on solutions you get a working version of the course. The two branches are not merged, so there is no in-repo diff view of your attempt against the reference unless you set one up yourself.

For self-study that is mostly fine, and arguably better than a solutions directory sitting next to every exercise, because it removes the temptation to peek. For anyone running this as a cohort, it means the instructor has to decide how to distribute the solutions branch, and the repository offers no tooling for that. There is also no release history, so you cannot pin a version of the course the way you would pin a dependency. You get whatever main and solutions contain at the moment you clone.

## Where the course stops being the right tool

The 100 exercises are a beginner on-ramp, and the repository does not claim otherwise. If you already write Rust and want to sharpen skills in async I/O, unsafe code, trait object design or procedural macros, this is the wrong artefact. The helper crate named ticket_fields hints at a small application-style domain, which is a reasonable place to practise ownership and structs, but nothing in the repository layout suggests coverage of concurrency runtimes or systems-level work.

A second limitation is the licence, covered below, which rules out some uses regardless of technical fit. A third is that the course text is not in the repository in a form the README describes as self-contained. The book/ directory exists, but the README tells readers to go to rust-exercises.com and follow the instructions there. If you want to read the course offline or vendor it into an internal wiki, the README does not document that path. The README also does not document rollback, versioning or a changelog, so a team cannot reason about what changed between two points in time.

## 100 exercises to learn Rust vs rustlings

The obvious comparison is rustlings, the long-standing exercise collection that ships as a CLI you install and run locally. The difference in approach is where the course lives. Rustlings is primarily a set of exercises plus a watcher that checks your edits; the teaching text is thin by design. This project inverts that: the prose lives on rust-exercises.com, the repository holds the workspace of exercise crates, and the answers live on a separate branch.

That makes this course more guided and rustlings more self-directed. It also means this project has an external dependency for its core content, while rustlings is usable entirely offline once installed. A reader who wants a single binary that watches a directory and tells them when a file compiles should pick rustlings. A reader who wants a structured 100-step path with a book alongside it should start at rust-exercises.com. Note that this repository is a Cargo workspace rather than an installed CLI, so there is no equivalent of a rustlings watch command documented anywhere in the README.

## Licence terms and what they mean for a team

The README states the licence plainly: Copyright 2024- Mainmatter GmbH, released under the Creative Commons Attribution-NonCommercial 4.0 International license. That is CC BY-NC 4.0, and the NonCommercial clause is the part that matters operationally. You may share and adapt the material with attribution, but not for commercial purposes. A company running this as internal onboarding for employees is a use case the licence text, not this article, has to settle, and the repository gives no additional permission or clarification beyond the licence link.

This is not legal advice, and the practical point is narrower: before you build a paid workshop, a customer-facing training product or a commercial certification on top of these exercises, read the licence and get a view from someone qualified. Mainmatter sells Rust consulting and workshops, so a commercial training use is precisely the case the NonCommercial term is there to cover. The repository carries no separate licence file beyond the README statement.

## Maintenance and upgrade cost

The last push to the repository was on 2026-06-28, which is under three months before the date of writing, so there is recent activity. There are no releases, which means there is no versioned artefact to depend on and no changelog to read when something changes. Upgrading is therefore a matter of pulling main and re-reading the exercise you are on, because the workspace members and the overflow-checks override in the root Cargo.toml can change between pulls.

The toolchain side is the recurring cost. The README asks for the latest stable Rust and tells rustup users to update. Because the exercises are ordinary crates in a workspace, a Rust edition bump or a change in a helper crate can alter what an exercise expects. There is no documented compatibility matrix, so the honest position is that you re-check the exercise crate after any pull and after any toolchain update. That is cheap for an individual and mildly annoying for a cohort that needs everyone on the same revision.

## Conclusion

Adopt it if you are new to Rust and want a fixed sequence of exercises rather than a reference book, and start at rust-exercises.com because the README does not reproduce the course itself. Do not adopt it if you need a commercial licence for paid training material, since the repository is released under CC BY-NC 4.0 and the README states the licence explicitly. Before committing a team, verify two things: that the exercise you are on is the one the Cargo.toml overflow-checks override targets, and that your toolchain is current, because the README asks you to run rustup update or the equivalent for your installation method.

## FAQ

### What is the fastest way to learn Rust?

This repository does not make a speed claim. Its README describes a self-paced course of 100 exercises that takes you from knowing nothing about Rust to being able to start writing your own programs, one exercise at a time.

### Is Rust still relevant in 2026?

The README does not address Rust's relevance. The one dated signal the repository gives is the last push on 2026-06-28, which shows the course itself was updated recently.

### What are some good projects to learn Rust?

This course is not a project to build; it is a sequence of exercises. The repository layout does include helper crates named helpers/common and helpers/ticket_fields, which suggests the later exercises work on a small shared domain rather than isolated snippets.

## Sources

- [Issues](https://github.com/mainmatter/100-exercises-to-learn-rust/issues)
- [mainmatter/100-exercises-to-learn-rust on GitHub](https://github.com/mainmatter/100-exercises-to-learn-rust)
- [Project website](https://rust-exercises.com)
- [README](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mainmatter-100-exercises-to-learn-rust