The toolchain a kernel needs

This lab is a welcome whose substance is the setup — and it ends, like every lab in this course will, with a green check. Nothing here is self-reported: the finale is your machine proving it can run the whole loop before you write a line of Rust. Ten minutes cold, most of it the toolchain downloading itself; about one if Rust is already in place.

The promise

Enough Rust to write a kernel — and nothing more. Seven labs from here you will have owned memory without a garbage collector, laid a struct out to a byte-exact ABI, reached through a raw pointer on purpose, built a crate with no standard library under it, and driven the cargo machinery that targets bare metal. That list is not a syllabus somebody guessed at: it was counted off the OS course this primer feeds, which uses asm! sixteen times and generics zero times. So this course spends its time where a kernel spends yours — on the memory model, not on the type system.

Every lab is your own code, your own tests, and your own test output as the evidence. There is no lecture to watch and no quiz: you write the module, you write the #[test] functions the project names, and the grader reads what cargo test printed on your machine.

How a lab is graded

You read and decide here; you build in your terminal.

• sboot test grades your work on your own machine, as often as you like. It is how you find out what to fix.
• sboot submit records the official result with us — the same checks, our computation. It comes back with a link to your code review — written by the course's AI reviewer over your diff; reading that page and pressing Complete on it is what finishes a lab and opens the next.

This course publishes every check it grades, so there is no hidden second list waiting at submit.

Nothing boots in this course. No emulator, no disk image, no bootloader — the evidence is what a command printed. That keeps the toolchain here down to Rust itself plus the system linker step 4 installs once, and it is why you can learn the language without also learning to debug a machine that will not start. The bare metal comes later, on the courses this one unlocks; what you install today is the same nightly toolchain they use.

Your code stays yours

The folder sboot start unpacks is yours — plain files and, if git is on your machine, a local git repo you can push anywhere, or nowhere. We hold no GitHub credential and never touch your remote repo: gh, git and sboot only ever run on your machine. sboot submit uploads your source and what your test run printed; what we keep afterwards is the verdict — your progress record — and the diff your code review was written on, not a copy of your repo.

The course's own checks live with sboot, not in that folder, so publishing this repo publishes your Rust and nothing else.

New machine, months from now? Install sboot, run sboot login, then sboot resume with your folder's path or your repo's address. It fetches what a fresh copy is missing and runs this lab again: the same proof it gives you today.