About This Course

A course in local large language models, from the concepts to a cluster, that treats every claim about a model, an engine or a machine as a measurement waiting to be made on your own hardware.

It is published by RunBook Academy as a standalone site, on the same platform as the AmiBroker course. RunBook Academy’s other courses cover production infrastructure; this one applies the same standard, verified against official documentation and explicit about what was and was not checked, to running and building models.

How it was made

The course was designed and written with Claude Code, Anthropic’s agentic coding tool, working from a curriculum and an implementation plan reviewed by the author, against a set of build-time validators that reject an invented command-line option, an undated number, a page that does not match the manifest, or a hands-on page that does not say which machines it supports. The author directed the work, reviewed the pages the validators cannot judge, and executed the labs.

The labs were written from the official documentation of the versions pinned on the what you need page and then executed on the author’s lab before release:

• 2 × NVIDIA DGX Spark, on a direct ConnectX-7 link, which are also the course’s reference cluster pair
• 1 × GMKtec EVO-X2 with an AMD Ryzen AI Max+ 395 and 128 GB of unified memory
• 1 × MacBook Pro with an M5 chip and 24 GB of unified memory
• 1 × MSI Titan GT77 HX 13V with an RTX 4090 laptop GPU (16 GB of VRAM) and 128 GB of system memory, running Ubuntu

!What has and has not been validated

Each lab page carries a line stating which tracks were executed on those machines, with the tool versions and the date. What the machines could not cover ships marked as written from documentation: Track M pages with a memory floor above 24 GB and the two-Mac Thunderbolt 5 cluster; Track N pages at the 24 and 32 GB VRAM tiers, multi-GPU desktops, and the native Windows and WSL2 commands, which were checked by inspection. Readers with that hardware are invited to report their results through the issue template.

What runs on every build: every command-line option is checked against the pinned version’s help output; every measured number must sit in a table with its context; a content audit rejects unfinished sections, empty headings, missing page metadata and pages that disagree with the manifest; a claims audit rejects hype and bare numbers in the course’s own voice; a link check confirms that every internal link resolves; and a release check refuses credentials, tokens, hostnames and machine paths.

Automated checks catch an invented flag or a broken link. They do not catch a plausible explanation that is subtly wrong. Read every lesson with that in mind: measure before you believe, check statements against the official documentation for your versions, and report anything that looks wrong.

What the course teaches

Local models are usually taught as a set of tools to install. This course teaches them as a set of claims that can be measured. You will not be told that a particular model matches a hosted one; you will be shown how to build a test set that could tell the difference, run both against it, and report the result honestly.

The central educational philosophy: teach people not only how to run and build models, but how to find out whether a claim about them is true on their own hardware.

That means every part emphasises:

• the arithmetic of memory and bandwidth that predicts what fits and how fast it runs;
• running and serving models on four kinds of machine, with the honest status of each;
• training, aligning, distilling and quantising small models, and measuring what each step changed;
• running models bigger than one machine, and splitting prompt processing from generation;
• driving agents with local models, sandboxing them, and improving the model with what they produce;
• a written report in which every number carries the setup that produced it.

The platform

The site is built with Astro and the Starlight documentation theme, as a fully static site with no server, no database and no third-party script. Search runs in the browser; progress and the platform choice live in the browser’s storage. The architecture decisions, the authoring standard and the implementation plan are in the repository.

28

Parts

184

Pages

5

Levels

126

Hours

1,896

Citations

Corrections

If you find an error, please open an issue with the official source or the measurement that contradicts the course. That is the fastest route to a fix, and it is the standard the course holds itself to. Measurements that differ on comparable hardware are as welcome as errors; they are how the benchmark tables get better.

Licence and terms

• Content, the lessons, labs, projects, quizzes, glossary, diagrams and lab files, is licensed under CC BY-SA 4.0.
• Code, the site, components, scripts and deployment tooling, is licensed under the MIT License.
• No model weights and no datasets are redistributed by this project. Labs tell you how to obtain them from their publishers, and every model named carries its licence.
• NVIDIA, AMD, Apple, GMKtec, model publishers and tool projects are the property of their respective owners. This course is an independent educational work and is not affiliated with or endorsed by any of them.

The full terms are on the disclaimer page.