C.1The end?
Congratulations! You made it to the end.
If you started this course not knowing what a variable was, look at what you can do now. You can read and write Rust, structure a real program across modules, model your data with structs and enums, handle errors honestly, write tests, reach for generics and traits when they help, share data across threads, and reason about ownership and borrowing well enough that the compiler feels like a collaborator instead of an obstacle. You finished by building a multithreaded web server from raw sockets (chapter 26). That's a genuine programmer's toolkit, in a language with a reputation for being hard to learn.
So, is this the end? Of the course, yes. Of your Rust, not even close. The honest truth is that you learn a language by using it, and everything up to now was preparation for that. This appendix is about what comes next.
Build something
There's no substitute for this, so it goes first. Pick a small project you actually want to exist and build it. The ideal first project is a little too ambitious and genuinely yours, because motivation carries you through the parts that get hard, and a real program forces you to make the decisions a tutorial makes for you.
If nothing comes to mind, here are starting points, each of which exercises a different part of what you learned: a command-line tool that does one useful thing (extend the minigrep from chapter 20, or build something new with clap); a program that reads and writes a file format you care about, using serde for JSON or TOML; a small web service built on a framework like axum; a text-based game, which is a surprisingly good ownership workout; or a clone of a Unix tool you use daily (wc, cat, head). Don't aim for perfect. Aim for finished, then make the next one better.
Read other people's code
One of the fastest ways to improve is to read the source of a crate you use. Pick a small, well-regarded one, open its repository, and see how the concepts from this course look in code that ships to thousands of people. You'll pick up idioms no tutorial teaches.
Read deeper
This course was the gentle path in. Now that the ideas are solid, the denser resources will reward you, and several are free and official.
The Rust Programming Language, known as "the Book," is the official text. It covers much of the same ground we did, faster and with a different web-server project at the end, and it's an excellent second pass that will deepen what you know. Rust by Example teaches through annotated, runnable snippets, a good reference when you want to see one specific thing. And the standard library documentation is genuinely worth browsing, not just searching: it's well written, full of examples, and reading through a type like Vec or Option and its methods will teach you tools you didn't know existed.
When you're ready to go below the safe surface, the Rustonomicon is the guide to unsafe Rust and the rules you must uphold by hand, the deep version of chapter 25. It's advanced and you don't need it for most work, but it's there when you do. For asynchronous Rust beyond chapter 23, the Async Book goes further into futures and runtimes.
Join the community
Rust has an unusually welcoming community, and you don't have to learn alone. The users.rust-lang.org forum is the place to ask questions and get patient, expert answers. This Week in Rust is a weekly newsletter that's the easiest way to keep up with the language, notable crates, and what people are building. And the official community Discord and Zulip chats are good for quick questions and finding others working on similar things. When you ask for help, show what you tried and paste the actual compiler error; you know how to read those now, and so does everyone you're asking.
Contribute
This might feel premature, but it isn't: open source needs more than expert contributors. Improving a crate's documentation, adding an example, fixing a small bug, or filing a clear issue are all real, valued contributions, and they're how a lot of people make the jump from "I can use Rust" to "I can build Rust things with others." Find a crate you use and like, read its contributing guide, and start small. The Rust project itself maintains lists of beginner-friendly issues across the ecosystem. You'll learn more from one merged pull request than from a chapter of reading.
A thank-you
This course was built on a simple bet: that Rust's reputation for being hard is mostly a teaching problem, not a language problem, and that a true beginner can learn it well if the ideas arrive slowly and in the right order. You getting here is the bet paying off. Thank you for trusting the slow path, for sitting with the borrow checker until it clicked, and for reading the compiler errors instead of just pasting them somewhere. That last habit alone will serve you for the rest of your programming life.
These tutorials are free and will stay free, and they get better when readers point out what's confusing or wrong. If you found a mistake or a passage that didn't land, the About page has the address to write to. Every correction makes the course better for the next person starting where you started.
Now go build something. We can't wait to see what you make.