Seven language courses, ~138,000 words, and the honest problem: reading a language course teaches you its syntax, not its grain. Every project here is chosen because it forces you into the thing that language is for — and is awkward in the others.
Difficulty: 🟢 starter (hours–days) · 🟡 intermediate (a week or two) · 🔴 ambitious / portfolio-grade. ⭐ = highest signal.
The meta-rep: build the same small program in three languages — a concurrent web scraper, or a line-oriented log parser. Nothing teaches you what a language is like watching the same problem get easy in one and painful in another.
Java — see the dedicated ladder
Java has the deepest project list in the vault, aimed at the low-latency target: the order-book matching engine, a lock-free ring buffer, JMH + GC tuning. Those live in project-ideas under Java / JVM & Systems — start there, not here.
Go
- 🟢 A CLI with real ergonomics — flags, subcommands,
contextcancellation on Ctrl-C, and useful--help. Done when: Ctrl-C during work exits cleanly, mid-operation. Exercises: Go. - 🟡 ⭐ A concurrent worker pool with backpressure — bounded channels,
errgroup, graceful shutdown, and a rate limit. Done when: you can kill it mid-flight and no goroutine leaks (verify withgoleak). This is Go’s whole thesis — CSP concurrency as a first-class tool. - 🟡 A load-testing tool — concurrent HTTP requests, latency histogram, p50/p95/p99 output. Done when: your numbers agree with
heyork6on the same target. - 🔴 Build your own container — the guide in Go. Namespaces, cgroups, pivot_root.
Rust
- 🟢 Fight the borrow checker on purpose — implement a doubly-linked list. Done when: you’ve hit the wall, then done it properly with
Rc<RefCell<>>and understood why the naive version can’t compile. Exercises: ownership, smart pointers. - 🟡 ⭐ A parser, with real error messages — JSON or a config format, with
Resultall the way and errors that point at the line and column. Done when: the errors are ones you’d want to receive. Rust’sResult/?is at its best here. - 🟡 An async TCP service on Tokio — a small protocol server with graceful shutdown. Done when: you understand why one
.awaitin a lock guard deadlocks everything. Exercises: async. - 🔴 Build your own memory allocator — the guide in Rust with
unsafe. Rust fights you productively here, and it’s the fastest way to internalise what ownership is preventing.
C
- 🟢 ⭐ Build your own shell — the guide.
fork/exec/dup2/pipes, in the language where the syscall is the lesson. The best C project there is. - 🟡 A memory allocator — the guide. Done when:
LD_PRELOAD=./myalloc.so lsworks. - 🟡 Find your own UB — write something with a deliberate off-by-one, then find it with ASan, Valgrind and UBSan. Done when: you’ve seen the same bug reported three different ways. Exercises: C.
C++
- 🟡 RAII everything — take a C program that leaks and rewrite it with smart pointers and containers. Done when: Valgrind is clean and you deleted every
free. - 🟡 ⭐ Build your own physics engine — the guide. C++‘s natural home: performance plus abstraction, and bugs that report themselves visually.
- 🔴 A template-heavy container — implement a
small_vectorwith move semantics, allocator awareness, and correct exception safety. Done when: it passes a test suite that throws at every allocation point.
Python
- 🟢 Solve the exercises you have — 18-practice-exercises is already written. Do it.
- 🟢 ⭐ Break the data model on purpose — mutable default arguments, late-binding closures in loops,
isvs==, shared class attributes. Done when: you can predict each gotcha’s output before running it. Exercises: the data model. - 🟡 Prove the GIL to yourself — the same CPU-bound work with threads,
multiprocessing, andasyncio. Done when: you can explain from your own timings why threads didn’t help. Exercises: the GIL. - 🟡 A decorator library — retry with backoff, caching, and timing, all preserving signatures with
functools.wraps. Done when:help()on a decorated function still shows the right signature.
C#
- 🟡 An async pipeline with
IAsyncEnumerable— stream, transform, cancel. Done when: cancellation propagates end to end. Exercises: C#. - 🟡 ⭐ A Unity game jam entry — the reason C# is in this vault. Ship something in 48 hours → game development.
- 🟡 Zero-allocation parsing with
Span<T>— parse a large file with no heap allocations on the hot path. Done when: a profiler shows zero Gen0 collections during parsing.
If you only do one
The same program in three languages. It’s a weekend, and it converts seven separate courses into one comparative understanding — which is the thing that actually makes you good at picking tools.
Related
- the languages index
- build-your-own-shit — most guides name the right language for the lesson
- Project Ideas — the vault-wide index
Software engineering
Infrastructure & security
Computer science
Hardware & engineering