Learning Rust Is Easier When Someone Hands You 100 Small Problems

You've probably heard the pitch by now: Rust is fast, safe, and increasingly everywhere. Maybe you've even opened the official book, read a few chapters, and then quietly closed the tab when the borrow checker showed up. The gap between "I understand the concepts" and "I can actually write this" is real, and it's exactly the gap that 100 Exercises to Learn Rust is designed to close.

What It Does

This is a structured Rust course built around a single premise: you learn by doing, one exercise at a time. Rather than reading about ownership and lifetimes in the abstract, you work through 100 exercises that take you from knowing nothing about the language to being able to start writing your own programs.

The course was written by Mainmatter, a consultancy that runs Rust training as part of its workshop portfolio. That's worth noting because it means the exercise progression comes from people who teach this material professionally, not from someone assembling a list in their spare time.

The repository itself is the exercise material. You head to rust-exercises.com for the actual instructions and course flow, and the repo backs that up. If you get stuck or want to check your work, there's a separate solutions branch containing the answers, which is a nice touch—you can compare your approach against theirs rather than guessing whether you got it right.

Why It's Cool

• It's incremental by design. The "one at a time" framing isn't just marketing. The whole point is that each exercise is a small, digestible step, so you're never staring at a blank file wondering where to begin. That's the opposite of how most people try to learn a language—by attempting a project that's way above their current level.

• There are 100 of them, and that number matters. A handful of exercises is a demo. A hundred is a curriculum. It implies real coverage of the language's core concepts, not just a taste of syntax before you're left to fend for yourself.

• The solutions branch gives you a safety net. Being able to check your work against a reference implementation is genuinely useful when you're learning. You can see idiomatic approaches you might not have thought of, and you can unblock yourself without abandoning the exercise entirely.

• It's honest about tooling. The requirements section recommends an IDE with Rust autocompletion—specifically RustRover or VS Code with rust-analyzer. That's practical advice. Autocompletion and inline type hints make a huge difference when you're new to a statically typed language, and the course doesn't pretend you should be doing this in a bare terminal out of some misplaced sense of purity.

• It's openly licensed. The material is released under a Creative Commons Attribution-NonCommercial 4.0 license, so you can use it, share it, and learn from it freely as long as you're not turning around and selling it.

One thing worth being clear about: this is a course, not a library or a tool you'll integrate into a project. Its value is entirely in the learning path it provides. If you're already comfortable with Rust, this isn't for you.

How to Try It

Getting started is straightforward, and the README keeps it that way.

1. First, make sure you have Rust installed. If you don't, follow the instructions at rust-lang.org/tools/install. If rustup is already on your system, run:

   rustup update
   

   That ensures you're on the latest stable version—worth doing since the course assumes current Rust.

2. Optionally (but recommended), set up an IDE with Rust support. RustRover or VS Code with the rust-analyzer extension will both work.

3. Head to rust-exercises.com and follow the instructions there. That's where the course actually lives and where you'll find the exercise flow.

4. If you want to peek at solutions or compare your work, check out the solutions branch of the repository.

The repository is at github.com/mainmatter/100-exercises-to-learn-rust.

Final Thoughts

This is best suited to someone who has never written Rust and wants a guided on-ramp rather than a reference manual. The exercise-by-exercise structure is a genuinely good fit for how people actually build fluency in a new language—small reps, immediate feedback, steady progression. If you've been circling Rust for a while without committing, this gives you a concrete place to start and a clear finish line. It won't teach you everything about the language, but it'll get you from zero to writing your own programs, which is the part that usually stops people cold.

Follow @githubprojects for more developer tools and open source projects.