A game developer's devlog · online, worldwide
The notebook I wish I'd read before I shipped my first engine.
Code-level deep-dives on the parts of building games that actually break.
From the notebook
Latest deep-dives
Long, code-first posts. Each one solves a problem I actually hit, with the wrong turns left in so you can skip them.
-
01
Writing a Fixed-Timestep Game Loop That Doesn't Drift
Variable delta-time feels fine until physics tunnels through walls at high frame rates. Here's the accumulator loop that keeps simulation deterministic and rendering smooth — with the interpolation step most tutorials skip.
Read → -
02
An Entity Component System From Scratch, Explained Simply
ECS gets explained with either hand-waving or 4,000 lines of template metaprogramming. This is the middle path: entities as integers, components in tight arrays, systems as plain loops — built up one runnable step at a time.
Read → -
03
Profiling Your Game: Finding the 3% of Code Eating 90% of Your Frame
Optimising by vibe wastes weeks. A short, honest workflow: measure the frame, read a flame graph, find the one hot function, and prove the fix moved the number — before touching anything else.
Read →
Index
What the notebook covers
Everything here starts from working code and stays close to it. These are the running threads.
Engine internals
The plumbing under a game: loops, timing, memory layout, allocators. The parts you write once and lean on for years.
Architecture
Keeping a codebase from collapsing under its own features. ECS, data-oriented design, and knowing when a pattern is overkill.
Performance
Measuring instead of guessing. Profilers, flame graphs, cache misses, and the discipline of proving a change actually helped.
Tools & workflow
The unglamorous scaffolding — build times, hot reload, debugging rituals — that decides whether shipping feels good or awful.
Featured deep-dive
Why your physics tunnels through walls at 240 fps2
The bug feels random: on a fast machine, a falling box clips straight through the floor. It isn't random. It's your update step scaling with frame rate — a small delta means small collision moves, and eventually the object skips past the wall in a single frame.
The fix is a fixed-timestep accumulator: run the simulation in constant slices, decouple it from rendering, and interpolate the visuals in between. The full walkthrough has the loop, the interpolation math, and a runnable sample.
Read the full loop →
Who writes this
Kajus Miškinis
I've spent about a decade building game systems — two shipped indie titles, a stint on an engine team, and a lot of small tools nobody sees. Devournal is where I write the version I'd have wanted: specific, tested, and unafraid of a code listing.
- Based in
- Online, worldwide. Long winters are good for finishing things.
- Works in
- C++ and Rust mostly, plus whatever a project drags me into. Comfortable at the engine layer.
- Writes about
- The parts that broke and how they got fixed — not the polished version where everything worked first try.
- Won't do
- Framework hype, "10x" listicles, or code you can't run. If a post ships, its sample compiles.
From the desk
The people & the work3
Devournal isn't written in the abstract. Here's where the posts come from — the desks, the monitors full of code, and the games the debugging actually ships.
Membership
Read for free. Go Pro for the workshop.
Every deep-dive stays readable without paying. Devournal Pro adds the full archive, downloadable source and project files, a private Q&A thread, and early access to work-in-progress writing.
| What you get | Free $0 forever | Devournal Pro $12 / mo |
|---|---|---|
| Read new deep-dives | Yes | Yes |
| Full back-archive of every post | — | Yes |
| Downloadable source & project files | — | Yes |
| Private Q&A thread with the author | — | Yes |
| Early access to deep-dives in progress | — | Yes |
| Cancel anytime, keep what you downloaded | — | Yes |
| Start reading | Become a member |
Annual is $110/yr — about two months freesave ~24% Payment is arranged after you send the form; no card details are entered here.
The margin note
One email when a new deep-dive lands
No digest, no drip campaign. You get a short note with the link and a line on what it's about. That's the whole plan.
Questions
Before you join
Is the writing free or paywalled?
New deep-dives are free to read in full. Pro unlocks the back-archive, the downloadable source and project files, the private Q&A thread, and early access. You never lose access to a post you could already read.
What language is the code in?
Mostly C++ and Rust, occasionally pseudocode when the idea matters more than the syntax. The concepts — timesteps, ECS layout, profiling — carry over to any language you build games in.
Can I actually run the samples?
Yes. Pro members download self-contained project files that compile and run. The article snippets are the real thing, trimmed for reading, not screenshots or paraphrases.
How often do you publish?
Roughly weekly, but honestly — a deep-dive ships when it's correct, not to hit a schedule. Members get the in-progress drafts, so you see them before they're polished.
How does payment work?
Send the membership form with your plan. I reply with a payment link or invoice and set up your access. No card numbers are collected on this site. Monthly is $12, annual is $110.
Can I expense it or get an invoice?
Yes. Mention it in the form and I'll send a proper invoice with the business details for your records.
Devournal Pro
Become a member
Send this and I'll set up your access and payment link by email — usually within one working day.
- Full archive of every deep-dive, searchable
- Downloadable source samples & project files
- Private Q&A thread — ask about your own code
- Early access to deep-dives before they're public
Prefer email? Write [email protected].