#zig

Learn Zig Series (#162) - Sprite Rendering and Tile Maps What will I learn? What a sprite actually is -- a small pre-drawn image you stamp onto the screen wholesale, in stead of rebuilding it from lines

Learn Zig Series (#161) - Double Buffering and Vsync What will I learn? Why drawing straight into the memory the display reads from makes shapes flicker and tear, and why "just draw faster" does

Learn Zig Series (#160) - 2D Transform Matrices What will I learn? Why every shape we have drawn so far is nailed to fixed pixel coordinates, and why hand-editing vertices to move it is the wrong answer;

Learn Zig Series (#159) - Polygon Filling: Scanline What will I learn? Why an arbitrary polygon cannot lean on the tidy symmetry that made circles and ellipses easy to fill; The even-odd (parity) rule:

Learn Zig Series (#158) - Circle and Ellipse Rasterization What will I learn? Why a circle fights the pixel grid even harder than a line does, and why the obvious y = sqrt(r*r - x*x) approach leaves ugly

Learn Zig Series (#157) - Line Drawing: Bresenham What will I learn? Why drawing a straight line between two arbitrary points is a genuinely hard problem, and how the pixel grid quietly fights you every

Learn Zig Series (#156) - Framebuffer Basics What will I learn? What a framebuffer actually is -- why every pixel you have ever seen on a screen ultimately lives in a flat, one-dimensional slice of memory,

Learn Zig Series (#155) - Mini Project: Regex Engine - Matching Part of a multi-episode project What will I learn? How to run the NFA we built last episode -- feeding it text and getting back a yes-or-no

Learn Zig Series (#154) - Mini Project: Regex Engine - NFA Part of a multi-episode project What will I learn? Why a regular expression is really two machines stacked -- a small parser that turns a string

Learn Zig Series (#153) - Mini Project: Lisp - Standard Library Part of a multi-episode project What will I learn? Why a real language is two things -- a small core of primitives written in the host language,

Learn Zig Series (#152) - Mini Project: Lisp - Special Forms and Macros Part of a multi-episode project What will I learn? What a macro actually is -- a function that runs at expand time and returns new

Learn Zig Series (#151) - Mini Project: Lisp - Evaluator Part of a multi-episode project What will I learn? What the "eval" in Read-Eval-Print-Loop actually does, and why it is a genuinely separate

Learn Zig Series (#150) - Mini Project: Lisp - Reader Part of a multi-episode project What will I learn? What the "read" in Read-Eval-Print-Loop actually means, and why in Lisp it is a genuinely

Learn Zig Series (#149) - Mini Project: Calculator - VM with Debugger Part of a multi-episode project What will I learn? Why the "bare-bones runner" from last episode was only a preview, and

Learn Zig Series (#148) - Mini Project: Calculator - Bytecode Compiler Part of a multi-episode project What will I learn? Why a tree-walking interpreter is a lovely thing to reason about and a mediocre

Learn Zig Series (#147) - Mini Project: Calculator - Interpreter Part of a multi-episode project What will I learn? How to turn the AST we built last time into an actual answer -- a tree-walking evaluator

Learn Zig Series (#146) - Mini Project: Calculator - Lexer/Parser Part of a multi-episode project What will I learn? How to start a real mini project -- a working four-function-plus calculator -- by building

Learn Zig Series (#145) - Register Allocation What will I learn? What register allocation actually is -- the problem of mapping an unbounded number of intermediate values onto a fixed, small set of machine

Learn Zig Series (#144) - Code Generation: AST to Machine Code What will I learn? What a code generator actually is -- instruction selection, the leap from a tree to a flat stream of bytes, and why a stack

Learn Zig Series (#143) - Regex: Matching Engine What will I learn? Why a DFA answers "does this match?" but cannot tell you where each capture group landed -- and why that pushes us back to