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. Some ideas that fit what you’ve already learned:

• A command-line to-do list — practice Vec, struct, and reading/writing a file.
• A word counter — read a text file and use a HashMap to count occurrences.
• A simple calculator — practice match, Result, and error handling on bad input.
• A guessing game — the classic first Rust project; the Rust Book walks through building one.

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)
• clap — for building command-line argument parsers
• reqwest — for making HTTP requests
• tokio — for async programming, once you’re ready for it

You add any of these to a project with cargo add <crate name> — no separate package manager needed.

Topics we didn’t cover

This course went further than most beginner tutorials — including things like smart pointers, threads, unsafe Rust, and writing your own macro_rules! macros. A few things it still doesn’t get into:

• Async/await — for concurrent, non-blocking programs; a different model from the threads you saw on the Concurrency page, often paired with the tokio crate
• 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
• Calling into C (FFI) — using unsafe to call functions from a C library, or expose Rust functions to other languages
• 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. 🦀