Skip to content
Concept demo

A fictional brand, designed and built by Get Ranked On Top. Not a real company.

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
kernel@school:~

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

alumni now own replication layersflight software for small satellitestrading engines at sub-10µsgame engine render threadsdatabase storage enginesbrowser JIT compilerspayments clearing infrastructureembedded medical firmwareCDN edge proxieskernel schedulers

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.

~/curriculum — tree -L 236 wk
01_fundamentals/8 wk
01_c_and_memory3 wk

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

02_data_structures3 wk

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

03_unix_toolchain2 wk

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/10 wk
04_operating_systems4 wk

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

05_networking3 wk

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

06_storage_engines3 wk

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/9 wk
07_consensus4 wk

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

08_replication3 wk

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

09_observability2 wk

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/9 wk
10_compilers3 wk

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

11_performance3 wk

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

12_production_on_call3 wk

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

README.mdr--

# 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
capstone.txtr--

> 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.

cal — january 2027KS-27
day oneweek one: boot a kernel

$ 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
./cohorts --upcoming4 rows
KS-27
Mon 11 Jan 2027
Atlantic · UTC−5 → UTC+1
filling fast
applications close 14 Dec
14 of 48 seats left
KS-28
Mon 08 Mar 2027
EMEA / APAC · UTC+1 → UTC+8
open
applications close 08 Feb
31 of 48 seats left
KS-29
Mon 10 May 2027
Americas · UTC−8 → UTC−3
waitlist
applications open 04 Jan
48 of 48 seats left
KS-30
Mon 13 Sep 2027
Global · async-first, 2 live hrs/wk
waitlist
applications open 01 Apr
48 of 48 seats left

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 seat

03$ 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.

mentors — ls -latotal 8
ines.okaforstorage · 19yLed the storage-engine team at a column-store database vendor. Has opinions about fsync that she will share at length.
tomas.lindqvistkernels · 22yPorted a real-time OS to four satellite buses. Still writes his grocery lists in assembly comments.
priya.ramandistributed · 16yBuilt the consensus layer for a payments network clearing roughly two billion dollars a day. Never lost a write.
daniel.mbekicompilers · 14yWrote three register allocators, threw away two. Teaches SSA like it is a love story.
hana.satonetworking · 17yRan edge networking for a CDN across 90 cities. Has debugged BGP at 3 a.m. more often than she will admit.
marek.novakperformance · 20yFormer performance lead on a AAA game engine. Reads flame graphs upside down, for sport.
lucia.ferrazproduction · 15yIncident commander for 400+ production incidents. Her postmortem template is used by half our alumni's teams.
arjun.mehtafundamentals · 12yEmbedded firmware for infusion pumps, where undefined behaviour is not a meme. Patient. Relentless.

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:".

raft/election.go07

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)}
0 livelocks in 10,000 chaos runs✓ approved by 2 mentors
kv/btree.rs06

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)
−38% p99 write latency, 1M mixed ops✓ approved by 2 mentors
alloc/ks_malloc.c01

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));}
4,000 / 4,000 fuzz cases, zero leaks✓ approved by 2 mentors

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.

41%

median salary uplift

from $78k to $110k base

87%

in a systems role in 6 months

of job-seeking graduates

9.5wk

median time to offer

after capstone defence

94%

completion rate

cohort track, KS-14 → KS-23

outcomes.txt — plot --asciin=1412
Median base salary before and after, plus placement metrics. Bars are proportional to a $120k scale and 100% respectively.
before$78k
after$110k+41%
placed ≤ 6 mo87%
completion94%
no cs degree58%

# 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.

git show 3f9a1c2ks-22
commit 3f9a1c2 (alumni/ks-22)
Author: Renata Vélez
Date:   Tue Jun 10 2025
“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.”
— Renata Vélez, now: staff engineer, replication team
git show a07be4dks-19
commit a07be4d (alumni/ks-19)
Author: Kofi Asante
Date:   Fri Nov 22 2024
“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.”
— Kofi Asante, now: firmware engineer, satellite constellation
git show c51d0e9ks-23
commit c51d0e9 (alumni/ks-23)
Author: Mei-Lin Zhou
Date:   Mon Sep 08 2025
“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.”
— Mei-Lin Zhou, now: performance engineer, trading systems

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.

plan/self-pacedmonthly

Self-paced

for the night-owl autodidact

$39 /month
  • 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
start today
plan/cohortrecommended

Cohort most chosen

36 weeks, 48 peers, 8 mentors

$4,900 once
  • 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
apply for KS-27
plan/isadeferred

Income share

pay later, only if it worked

$0 upfront
  • 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
apply with an ISA

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.

  1. 01submit — these prompts, about 10 minutes
  2. 02read — a mentor reads it within 5 working days
  3. 03talk — a 30-minute call about your bug, not a quiz
  4. 04boot — offer, seat reserved, kernel boots on day one
guest@kernel:~/applytty1
? track:

No test, no whiteboard. A human mentor reads every application within five working days.

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.

man kernel-school — less(END)
KERNEL-SCHOOL(7)KERNEL-SCHOOL(7)
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)