Skip to content
Supersource

The Course: Build Your Own LLM System

You build one system, end to end, in four languages: a byte-level language model trained in Python on your own numerics, kernels in C behind a stable ABI, a Rust inference engine that streams completions over HTTP, a Go gateway in front of it, and the containers, charts, traces, and runbooks that keep it running on Kubernetes. Every layer is yours. The course grades it with tests you can read, milestones that run your entry points, and drills that break your deployment on purpose.

For: engineers who want to own an LLM system from the matrix multiply to the pager, not just call one.

How it works: each chapter teaches one module from first principles (the math, a worked example by hand, the interface, the pitfalls), then you write the code in your own repo and ol check <ID> grades it. A pass ends at a milestone that runs your whole system as it stands: after every pass it runs end to end (the spiral).

Start

Section titled “Start”
Terminal window
practice/bin/ol doctor                         # the tools pass 0 and pass 1 need
practice/bin/ol course init --name forge       # your repo (default .scratchpad/course; OL_COURSE_HOME moves it)
practice/bin/ol learn course                   # every stage and your progress
practice/bin/ol learn course next              # read the next unfinished stage
practice/bin/ol start lang.01                  # stub a module into your repo
practice/bin/ol check lang.01                  # grade it

ol learn course --done <stage> marks a stage done only when its check passes ([x]), or with --force ([~]). The fifth column of path.tsv names each stage’s check.

Passes

Section titled “Passes”
PassPathWhat your system does after itGate
P0course-p00-setupan empty repo whose CI lints commits, runs native tests, and runs ol check --all --ciMS-P0
P1course-p01-tracera byte bigram trained by your CLI, served by your Rust engine, behind your Go gateway, on kind, with one trace and one runbookMS-P1
P2-P11pass paths through operateautograd, data, model architecture, inference, serving, durable workflows, agents, and operationsMS-P2 to MS-P11
P12course-p12-multimodalmultimodal extension planned in B14MS-P12, after Step C

Passes 2 to 11 take the system from autograd through operations. Pass 12 is the multimodal extension in the B14 design. Each pass has its own staged path and check column in path.tsv.

Reading order

Section titled “Reading order”
  • SYSTEM.md: the components, their languages, the contracts between them, and how the system grows pass by pass. Read it first.
  • Each pass path’s README says what that pass builds; its milestone.md says what the gate runs.
  • Contracts live in course/contracts/ and are vendored into your repo’s contracts/ by ol course init.

Stages

Section titled “Stages”

Generated from path.tsv. Track progress locally with practice/bin/ol learn.

StageReadDone when
0The system you will build
The Course: Build Your Own LLM System
The System You Will Build		You can name every component, its language, and the contract it serves.
PartCourse Pass 0: SetupEvery stage of that path
PartCourse Pass 1: The TracerEvery stage of that path
PartCourse Pass 2: FoundationsEvery stage of that path
PartCourse Pass 3: Tokens and dataEvery stage of that path
PartCourse Pass 4: Sequence modelsEvery stage of that path
PartCourse Pass 5: TransformerEvery stage of that path
PartCourse Pass 6: Inference and kernelsEvery stage of that path
PartCourse Pass 7: Serving platformEvery stage of that path
PartCourse Pass 8: DurableEvery stage of that path
PartCourse Pass 9: Capstone trainingEvery stage of that path
PartCourse Pass 10: AgentsEvery stage of that path
PartCourse Pass 11: OperateEvery stage of that path
PartCourse Pass 12: MultimodalEvery stage of that path