Four classroom days target experienced engineers
Google's course begins with syntax and control flow, then moves through references, traits, generics, ownership, borrowing, lifetimes, iterators, testing, error handling, and unsafe code. The intended student already writes software, usually in C++ or Java. That assumption lets the material cover the language in 4 days, but it also makes the early sections brisk. A new programmer would be learning programming concepts and Rust's ownership model at the same time.
The instructor guide describes a 9:00 to 4:00 day with a 1-hour lunch, leaving 3 hours each for morning and afternoon sessions. Exercises take 30 to 45 minutes in both halves, including solution review. Google recommends spreading the 4 days across 2 weeks so students have time to process the material. This is a real teaching plan with live coding and questions, rather than a slide deck that happens to have an agenda.
What happened when we ran it
Our fresh Debian sandbox installed 321 Rust packages in 24 seconds. The build then succeeded in 143 seconds, and the test command finished in 11 seconds with 107 passed and 0 failed. We measured commit c1852c3 in an unprivileged container with 3 CPUs, 12 GB of RAM, and no secrets. Nothing in the install, build, or test log failed.
The checkout was modest beside most developer platforms: 864 files, roughly 10,117 lines of source, and 25.3 MB. Our scan found 6 CI workflow files, a tests directory, and no Dockerfile. Those figures cover the repository machinery and test suite, not a class of students. They cannot tell us whether an instructor explains the borrow checker well or whether a learner remembers lifetime syntax a month later.
The 25.3 MB checkout still needs Bazel and mdBook tools
Building locally starts with Rust and Bazel installed through Bazelisk. The cargo xtask install-tools command then obtains the expected versions of mdBook, translation helpers, the exercise preprocessor, course utilities, and a link checker. cargo xtask serve runs the site on port 3000, while cargo xtask build creates static output. The successful 143-second lab build shows that this toolchain worked in our stated container at the measured commit.
Publishing has an extra step: the README says exercises must be built, zipped, and added to the HTML output separately. Translation work adds Gettext utilities and dprint, with one PO file per language. On Windows, Git symlinks and Developer Mode must be enabled. None of this is difficult for a Rust team, though it is more setup than reading the hosted course. Most learners can use Google's published site and avoid the local build entirely.
Android and Chromium classes need their native workspaces
The 4-day fundamentals course is self-contained, while several deep dives assume expensive surroundings. The Android half-day needs an AOSP checkout, an emulator or device reachable through adb, and examples built before class. The Chromium half-day expects an existing Chromium build that can run. These sections are valuable because they address real integration with C++, Java, AIDL, GN, and platform build rules, but they are poor choices for a generic Rust workshop.
Bare-metal Rust takes a full day and requires a BBC micro:bit v2 plus extra packages. Concurrency is another full day, covering traditional synchronization and async work. The idiomatic Rust material lasts 2 days and assumes the fundamentals are already familiar. An unsafe-code deep dive is marked work in progress. Instructors should select the track their environment can support instead of presenting the repository as one continuous beginner course.
Self-study loses the classroom questions and compiler mistakes
The README directly says self-study is less ideal. A solo reader misses questions, answers, discussion, and the compiler errors an instructor deliberately triggers while typing examples. Speaker notes fill part of that gap, and the repository includes solutions to its exercises. Issue 52, still open after an update on July 28, 2026, says videos would help cover what is normally spoken in class. That language describes a hope, rather than a promised release.
Self-directed learners have better starting choices. The official Rust book develops concepts in a continuous narrative. Rustlings makes the compiler part of a sequence of small corrections, while 100 Exercises To Learn Rust uses a longer exercise-led path. Google's material becomes more useful after one of those routes, or when a colleague can stop, ask questions, and reproduce errors live. Its specialized Android and Chromium chapters then offer material the general introductions do not.
September pull requests show maintenance without release tags
The repository was pushed on September 1, 2026, and pull request 3275 was updated on September 4. GitHub listed 33,347 stars, 117 open issues, and 55 open pull requests. The latest-release endpoint returned no release, but that does not make the course abandoned. The live site and main branch are the delivery path, and recent code and translation pull requests show ongoing work.
Licensing also deserves attention before reuse. Code and embedded examples use Apache-2.0, while Markdown, documentation, and images use CC BY 4.0. That split is sensible for a course, but an internal fork must retain the right notices and attribution for each kind of file. For teams ready to teach, the clean 107-test result and detailed instructor notes make this a strong base. For a lone novice, the authors' own self-study warning should decide the matter.