Compiler discipline
CoreOwnership, borrowing, lifetimes, enums, traits, and generics are taught as design tools, not as isolated syntax drills.
01
Rust course
Live online systems programming
Build a Game Boy emulator in Rust.
Dates to be announced / live cohort / project-first Rust
A practical Rust course for programmers who want to stop fighting the borrow checker by accident and start using Rust's type system deliberately. The course project is an emulator core with real binary data, memory maps, instruction decoding, tests, rendering, and performance constraints.
Course sheet
TBA- Format
- 10-week live online cohort / 20 sessions
- Schedule
- Dates to be announced
- Language
- English
- Project
- Game Boy emulator
- Level
- Intermediate programmers
- Lecturer
- Lukáš Hozda
02
Approach
Rust through a real machine.
The course is built around code that must parse bytes, preserve invariants, explain failure, and run fast enough to be interesting.
Low-level model
ProjectEmulator work gives a concrete reason to care about memory layout, bytes, bit flags, instruction cycles, and deterministic tests.
Portfolio result
OutcomeYou leave with a project that demonstrates systems thinking, typed error handling, testing, documentation, and maintainable Rust code.
03
Syllabus
Planned curriculum.
The final schedule will be published with dates. The current plan is a focused live cohort with practical work between sessions.
Toolchain and Rust mindset
Install Rust, Cargo, rust-analyzer, rustfmt, and clippy. Set up the emulator workspace and testing harness.
Values, ownership, and cartridge data
Use ownership and borrowing to load ROM bytes, parse headers, and model data without accidental copies.
Structs, enums, and machine state
Represent registers, flags, opcodes, and execution state with precise data types.
Pattern matching and instruction decoding
Decode instructions, avoid giant unstructured conditionals, and keep impossible cases explicit.
Memory map and bus design
Build the boundary between CPU, cartridge, RAM, IO registers, and display state.
Typed errors and diagnostics
Model invalid ROMs, unsupported features, parse failures, and emulator bugs with useful error types.
CPU loop, timing, and interrupts
Advance the emulator one instruction at a time and make timing state inspectable instead of mysterious.
Tests with traces and known ROMs
Use unit tests, golden traces, and small compatibility programs to keep the emulator honest.
Rendering and input
Expose pixels, connect keyboard input, and separate emulator logic from presentation code.
Traits, generics, and reusable boundaries
Use traits where they simplify substitution, tests, frontends, and extension points.
Performance and profiling
Measure before optimizing, remove accidental allocation, and use Rust's abstractions without hiding costs.
Packaging and portfolio polish
Document the emulator, publish a clean repository, and explain design tradeoffs like an engineer.
04
Details
Who it is for
- Backend, embedded, full-stack, or tooling programmers who already know at least one programming language.
- Engineers who want Rust to feel less magical and more explicit.
- Students who want a serious project instead of another CRUD tutorial.
What is included
- Live online sessions with direct questions and code review.
- Exercises tied to the emulator project, not detached toy snippets.
- Readable course notes and reference material for each module.
- An optional CHIP-8 style warmup if the cohort wants a gentler emulator ramp.
05
Interest
Next cohort
Dates TBAThe course is being prepared independently by Lambda Symbolics. Dates, pricing, and cohort size will be announced separately.
If you want to be notified when the cohort opens, send a short email with your background and whether you prefer evenings, weekends, or an intensive format.
Contact