KS-27next cohort · mon 11 jan 2027 · 14 seats left
Learn the machine,
not the framework.
Kernel School is a 36-week online academy for working developers who want to understand what actually happens below their code — memory, kernels, storage engines, consensus and compilers. Taught by engineers who have shipped them, reviewed line by line.
- median salary uplift
- +41%
- median salary uplift
- alumni, 38 countries
- 2,140
- alumni, 38 countries
- median mentor tenure
- 16.5y
- median mentor tenure
it is a real prompt. try outcomes, curriculum or sudo su.
$ grep -h "role:" alumni/*/profile | sort | uniq -c
2,140 graduates · 31 cohorts · since 2017
01$ tree ~/curriculum
Twelve modules.
From malloc to Raft.
Each module ends in something that runs, and something that breaks it. You build a shell, a kernel feature, a storage engine, a consensus protocol and a compiler — then defend them to people who have shipped the real thing.
01_fundamentals/
Pointers without fear, the stack vs. the heap, alignment, undefined behaviour and how to read what the compiler actually emitted.
→ you ship: a malloc that passes valgrind and our 4,000-case fuzzer
Hash tables with open addressing, B-trees, skip lists and tries — measured with cache-miss counters, not Big-O alone.
→ you ship: an LRU cache that beats the stdlib map on your own benchmark
Processes, file descriptors, signals, pipes. Make, linkers and gdb until they stop being scary.
→ you ship: a job-control shell with pipes, redirects and ctrl-z
02_systems/
Virtual memory, page tables, context switches, schedulers and syscalls — on a teaching kernel you boot in QEMU on day one.
→ you ship: copy-on-write fork() in a 6,000-line kernel
From the NIC up: Ethernet frames, TCP state machines, congestion control, epoll and why your HTTP client hangs.
→ you ship: a userspace TCP stack that survives 10% packet loss
Write-ahead logs, B+ trees vs. LSM trees, fsync semantics and crash recovery. We pull the power cord. Figuratively.
→ you ship: a crash-safe key-value store with compaction
03_distributed/
Raft from the paper, leader election, log replication and membership change — tested under simulated partitions.
→ you ship: a Raft implementation that survives 10,000 chaos runs
Consistency models you can explain to a product manager, vector clocks, CRDTs and the honest cost of linearizability.
→ you ship: a replicated KV store with tunable consistency
Structured logs, metrics that mean something, distributed tracing and the art of asking a system why.
→ you ship: a tracing layer for your own cluster, with dashboards
04_craft/
Lexing, parsing, SSA, register allocation and a peephole optimiser — for a small language you will grow attached to.
→ you ship: a compiler that targets x86-64 and runs its own test suite
Flame graphs, perf counters, SIMD, false sharing and lock-free queues. Measure first, then be clever.
→ you ship: a 10× speedup on a real open codebase of your choosing
Deploys, rollbacks, incident command and blameless postmortems. Then a capstone, defended live to two mentors.
→ you ship: your capstone, a pager rotation and a postmortem worth reading
# program.spec
- duration
- 36 weeks + 1 capstone
- load
- ~20 hrs/week
- live
- 2 × 90 min lectures
- pairing
- weekly, mentor-led
- review
- every PR, by a human
- languages
- C · Rust · Go
- ratio
- 1 mentor : 6 students
> Weeks 33–36. Pick a system you use every day and build a smaller, honest version of it: a database, a container runtime, a message queue, a language.
Defended live, 60 minutes, two mentors, one chaos button. Past capstones include a 9,000-line embedded SQL database and a Wasm runtime that runs its own compiler.
02$ cal --cohorts 2027
Pick a timezone. Then pick a fight with the machine.
Four cohorts a year, 48 students each, grouped by timezone so live sessions land in your evening, not your 3 a.m. Self-paced starts the minute you sign up.
$ crontab -l # a typical week, cohort-local
# m h dow command 0 18 mon lecture --live # 90 min 30 18 wed pair --rotate # mentor-led 0 18 thu lecture --live # 90 min 0 17 fri review --cohort # demos 59 23 sun ship --deliverable * * * chat --async # always awake
Can't commit to a cohort? Start self-paced today and transfer your progress into any cohort later — we credit every month paid.
reserve a seat03$ ls -la /home/mentors
Your code reviewers have paged themselves at 3 a.m.
Eight mentors, a median of 16.5 years in production systems, and a strict rule: everyone still writes code every week. They review every pull request you open. Not a TA. Not a bot. Them.
04$ git log --merges --author=students -p
Real diffs from real students. Merged after review.
Every deliverable goes through a pull request and a mentor review before it counts. Here are three that made the mentors say something other than "nit:".
fix: livelock from symmetric split votes under partition
@c.okwu · KS-24 · 07_consensus
@@ -88,7 +88,10 @@ func (n *Node) resetElectionTimer() { n.mu.Lock() defer n.mu.Unlock()- n.timeout = 150 * time.Millisecond+ // randomise so two followers never time out in lockstep+ jitter := time.Duration(n.rng.Int63n(150)) * time.Millisecond+ n.timeout = 150*time.Millisecond + jitter n.timer.Reset(n.timeout)}
perf: split pages by bytes, not by key count
@m.ferreira · KS-21 · 06_storage_engines
@@ -212,8 +212,9 @@ impl BTree { fn split(&mut self, page: PageId) -> Result<PageId> {- let mid = self.keys(page).len() / 2;+ // variable-length keys: balance bytes, not entries+ let mid = self.byte_midpoint(page)?; let right = self.alloc_page()?; self.move_tail(page, right, mid)?; Ok(right)
feat: segregated free lists with boundary-tag coalescing
@s.haddad · KS-25 · 01_c_and_memory
@@ -41,6 +41,10 @@ void *ks_malloc(size_t n)void *ks_malloc(size_t n) { if (n == 0) return NULL;- return sbrk(n);+ n = ALIGN_UP(n + HDR, 16);+ block_t *b = find_fit(class_of(n), n);+ if (!b) b = extend_heap(MAX(n, CHUNK));+ return payload(split_and_mark(b, n));}
05$ cat outcomes.txt | plot
The numbers, with the methodology attached.
1,412 graduates of cohorts KS-14 through KS-23, self-reported and then checked against offer letters. Non-responders are counted as not placed. We publish the full table every January, warts included.
median salary uplift
from $78k to $110k base
in a systems role in 6 months
of job-seeking graduates
median time to offer
after capstone defence
completion rate
cohort track, KS-14 → KS-23
# salaries in USD, adjusted to purchasing-power parity for graduates outside the US. figures are for this demo and are fictional.
06$ git log alumni/ --format=testimonial
Commit messages from the other side.
“I spent six years gluing APIs together and calling it engineering. Thirty-six weeks later I own the replication layer at a database company. The Raft module alone was worth the tuition — I still have the failing test I stared at for four days framed on my desk.”
“Every pull request got a review from someone who has shipped real kernels. Not 'LGTM' — forty comments, each one correct. It was humbling, then it was addictive.”
“I took the ISA because I could not afford the upfront price. I paid it off in eleven months. The performance module is the reason I got the offer — I walked into the interview with a flame graph.”
07$ cat pricing.md
Three ways in. None of them predatory.
Same twelve modules on every plan. You are paying for how much human attention you want on your code — and you can switch plans between any two modules.
Self-paced
for the night-owl autodidact
- All 12 modules, lectures and labs
- Autograded test suites and fuzzers
- Community chat and weekly office hours
- Credit every paid month toward a cohort
- Cancel any time, from your account
Cohort most chosen
36 weeks, 48 peers, 8 mentors
- Everything in self-paced
- Mentor code review on every pull request
- Two live lectures and one pairing block a week
- Capstone, defended live to two mentors
- Career sprint: mock systems-design loops
- Or 4 payments of $1,275, interest-free
Income share
pay later, only if it worked
- The full cohort experience
- 10% of income for 24 months
- Only once you earn $65k or more
- Hard cap of $7,900 in total
- Expires after five years, owed or not
Prices in USD. Regional pricing available in 41 countries — the application asks, and we apply it automatically.
08$ ./apply --interactive
Seven prompts.
No whiteboard.
We do not run a leetcode gate. We want to know how you think about a bug, and whether you will enjoy 36 weeks of finding more of them.
- 01submit — these prompts, about 10 minutes
- 02read — a mentor reads it within 5 working days
- 03talk — a 30-minute call about your bug, not a quiz
- 04boot — offer, seat reserved, kernel boots on day one
09$ man kernel-school
RTFM. We wrote it nicely.
The questions every applicant asks, formatted the way the gods intended. Still stuck? Email a human at hello@kernel-school.example.
KERNEL(1)Do I need a CS degree?
NAME
degree — optional, never checked
DESCRIPTION
About 58% of graduates have no computer science degree. You need roughly a year of writing code in any language and the stubbornness to sit with a segfault. Module 01 assumes you have never touched a pointer.
SEE ALSO
apply(1), curriculum(7)
KERNEL(1)How many hours a week does it really take?
NAME
time — 18 to 22 hours, honestly
DESCRIPTION
Cohort students average 20 hours a week: two live sessions of 90 minutes, one pairing block, and the rest on the weekly deliverable. Most of our students work full-time jobs. Sessions are recorded, but the pairing is where the learning happens.
SEE ALSO
cohorts(5), crontab(5)
KERNEL(7)How does the ISA work, exactly?
NAME
isa — pay later, only if it worked
DESCRIPTION
You pay nothing upfront. Once you earn at least $65,000 a year, you pay 10% of gross income for 24 monthly payments. Total payments are capped at $7,900. If you never cross the threshold within five years, the agreement expires and you owe nothing.
SEE ALSO
pricing(7)
KERNEL(7)Which languages do you teach?
NAME
languages — C, Rust and Go, mostly
DESCRIPTION
Fundamentals and OS work are in C, because the machine speaks C. Storage and compilers are in Rust; distributed modules are in Go. You can submit in any of the three after module 03. We teach concepts; the language is the chalk.
SEE ALSO
curriculum(7)
KERNEL(8)What if I fall behind?
NAME
recovery — no one gets garbage-collected
DESCRIPTION
Every module has a buffer week built into the cohort calendar. If life happens, you can pause once and rejoin the next cohort at the same module, free. Self-paced has no deadlines at all.
SEE ALSO
pause(8), self-paced(7)
KERNEL(8)Is there a refund policy?
NAME
refund — 14 days, no questions
DESCRIPTION
Cohort tuition is fully refundable until the end of week two. After that, refunds are pro-rated by module completed. Self-paced can be cancelled any time from your account; you keep access until the end of the billing month.
SEE ALSO
pricing(7), terms(5)