no_std

Every Rust program you have seen so far leans on the standard library, written std. It is the toolbox that ships with the language: String from lesson 02, files, threads, collections that grow as you push into them. Lean on it freely, on a normal machine.

But look at what those tools are made of. Opening a file is the open syscall. Starting a thread is a syscall. A collection that grows needs heap allocation, memory requested while the program runs, and that memory ultimately comes from the kernel, the same way M1's mmap got it. Walk to the bottom of almost anything in std and you find a syscall. The standard library quietly assumes there is a kernel underneath to answer.

Bare metal

Now remember where this course is going: a small machine driving a display over SPI. Code that runs on a chip like that, or code that runs inside a kernel, has no kernel underneath it. There is nothing to answer a syscall. Programmers call this bare metal: your code and the hardware, with no operating system in between. On bare metal, std's quiet assumption is simply false, and the library cannot work.

Dropping the assumption

Rust lets you say so, with one line at the top of the program:

#![no_std]

The attribute tells the compiler: build this program without the standard library, because there is no operating system where it is going. Files, threads, and the growing collections are gone. You cannot ask for what nothing can provide.

What remains is core: the part of the language's library that needs nothing beneath it. The number types and their arithmetic. Slices, the fixed views into buffers. Options, results, comparisons, iteration. Everything in core is self-contained computation, compiled instructions working on memory the program already has, so it runs anywhere the processor runs.

Who lives here

This is not an exotic corner. Embedded Rust, the code on small chips in instruments and machines, is no_std code. The Rust that goes into the Linux kernel is built on the same discipline, since kernel code has no kernel above itself to call. And thunk's own display simulator, the one you will program in the coming modules, is written against this discipline too: if code only uses core, it could run on the real panel's chip, not just in the simulator.

So the Rust you will read from here on is the small kind. No files, no threads, no growing collections. Types, arithmetic, buffers, and a wire. The next lesson starts on the types.

Key terms

• **standard library (std)** — Rust's full toolbox; it assumes an operating system underneath.
• heap allocation — memory requested while the program runs, which ultimately comes from the kernel.
• bare metal — running with no operating system between your code and the hardware.
• **#![no_std]** — the attribute that builds a program without the standard library.
• core — the library that remains: types, arithmetic, and traits that need nothing beneath them.