Rust Next Steps

If you’ve worked through the topics in this course, you already know enough Rust to build real programs — variables, control flow, functions, ownership, borrowing, collections, modules, error handling, traits, generics, and even threads, smart pointers, unsafe, and macros. That’s genuinely most of what you’ll use day to day. What’s left is mostly practice and picking up library-specific knowledge as you need it.

Build something small

The fastest way to actually learn from here is to pick a small project and get stuck a few times. This site has five guided projects to start with:

Guessing Game — the classic first Rust project: input, loops, and match.
Word Counter — read a text file and use a HashMap to count words.
To-Do List CLI — practice Vec, struct, enum, and saving to a file.
CLI Tool with clap — a real command-line tool with subcommands and --help.
Web API with Axum — a JSON API server built on async/await.

Once you’ve done those, try one on your own:

A simple calculator — practice match, Result, and error handling on bad input.
A JSON config reader — load settings from a file with Serde.
A tiny web scraper or API client — fetch a URL with reqwest on top of async/await.

Not sure what kind of program you want to build? The “What You Can Build” pages show where Rust is strong and which crates people use: networking, databases, desktop GUI apps, games and microcontrollers.

Want smaller practice first? Work through the Exercises, or test yourself with the Interview Questions.

Crates worth knowing about

Rust’s package ecosystem (crates, distributed via crates.io) covers most things you’d want a library for. A few that come up constantly:

serde — for reading and writing JSON (and other formats); see JSON with Serde
clap — for building command-line argument parsers; see the clap project
anyhow / thiserror — for error handling in applications and libraries; see anyhow & thiserror
rand, regex, and chrono — random numbers, regular expressions, and dates; see Random Numbers, Regex, and Dates & Times
log / tracing — for logging; see Logging
reqwest — for making HTTP requests
tokio — for async programming; see Async/Await

You add any of these to a project with cargo add <crate name> — no separate package manager needed. The Cargo & Crates page explains how that works and how to pick a good crate.

Topics we didn’t cover

This course went further than most beginner tutorials — including things like smart pointers, threads and channels, async/await, unsafe Rust, calling C (FFI), WebAssembly, and writing your own macro_rules! macros. A few deeper topics have their own pages, for when you’re ready:

Procedural macros — the more powerful (and more complex) cousin of the macro_rules! macros from the Macros page; these are what power #[derive(Debug)] and similar under the hood
no_std / embedded Rust — writing Rust without the standard library, for microcontrollers and other constrained environments

You don’t need any of these to write useful Rust — they’re worth knowing exist, and worth learning once you actually hit a problem that needs them.

Where to keep learning

The Rust Book — go back through it now that the basics have clicked; a lot of it will make more sense the second time
Rust by Example — more annotated code to read
Rustlings — small exercises you fix, right in your terminal
This Week in Rust — a weekly newsletter to see what the community is building

One last honest note

You’ll still hit compiler errors that confuse you, and that’s normal — it happens to people who’ve written Rust for years, not just beginners. The difference experience makes isn’t that the errors stop; it’s that you get faster at reading them. Keep writing code, keep reading what the compiler tells you, and it keeps getting easier.

Good luck, and thanks for sticking with it this far. 🦀

Quick check

1. Which crate is recommended here for reading and writing JSON?

2. Which crate is mentioned for async programming?

3. Which of these does the page list as a topic it did NOT cover?

Score: 0 / 3