A journal for developers who would rather write the renderer than import it. No frameworks hand-waved, no magic left unexplained — just the code, the profiler, and the reasoning behind both.
Long-form, follow-along walkthroughs. Every article ships the code it describes and the profiler numbers that justify it.
Start with a raw framebuffer and end with batched, textured sprites. Blitting, clipping, alpha, and why a draw-call budget matters before you draw anything.
Split your game into a reloadable shared library, keep state in a plain struct the host owns, and watch the file — iterate on gameplay while the world keeps running.
Fixed timesteps, integer or fixed-point math, and a strict update order — the recipe for a simulation that produces the same result on every machine, every time.
Series that build on each other. Read them front to back, or jump to the piece you're stuck on.
track/01
Nine parts from an empty main() to a small, shippable 2D engine: window and input, a software then hardware renderer, an entity store, the fixed-step loop, and hot-reload wired through all of it. The spine of the journal.
Asset importers, a hot-reloading resource system, a tiny custom binary format, and a build that stays under a second.
track/03
Deterministic lockstep, rollback, and the debugging habits that keep two clients in perfect sync.
track/04
Broadphase, the separating-axis test, and an impulse solver that stays stable at 240Hz without exploding on the first stacked crate.
track/05
Frame captures, a homegrown flamegraph, and the tracing hooks that turn "it feels slow" into a number you can actually chase down.
Here's an unedited excerpt from the engine track: the moment a raw pixel buffer becomes something you can actually draw into. The workshop version adds SIMD-blitting and a live debugger, but the plain C is enough to get a triangle on screen tonight.
The downloadable guide plus a hands-on online workshop. Payment is arranged after you send the form — nothing is charged on this page.
$59 / one-time
The ebook and a seat in the next live workshop. Everything you need to build the renderer end to end.
$108 / one-time
The full bundle plus the complete tutorial track and membership — every track, present and future, and time with me.
| What you get | Ship It · $59 | + Membership · $108 |
|---|---|---|
| Ship It ebook + updates | yes | yes |
| Live workshop seat | 1 session | 1 session |
| Workshop recording | yes | yes |
| All three learning tracks | no | yes |
| Future tracks included | no | yes |
| Code-review office hours | no | monthly |
One email when a new deep-dive lands, plus the occasional stray profiler screenshot. No drip funnels, unsubscribe in one click.
We store your address only to send the digest. See the privacy note.
You need to be comfortable reading it — pointers, structs, and a build system. The engine track assumes you can compile a hello-world; it does not assume you've written graphics code. If C is brand new, start with the first two parts, which move slowly on purpose.
The Ship It ebook in PDF and EPUB, the full source for the sample engine, and a seat in the next live online workshop with its recording. The Bundle + Membership tier adds every learning track and monthly code-review office hours.
Live online, roughly monthly, at a time picked to work across Europe and the Americas. You pick a date after you order. Can't attend live? The recording is yours regardless.
You don't pay on the site. Send the order form and we email you an invoice with a payment link within one working day. We never collect card details through this form.
There's a 14-day refund on the bundle, no interrogation required — details on the refund page. The articles themselves stay free to read, always.
./order --bundle
Fill this in and we'll email your invoice and workshop dates. No payment is taken here.