Gain insight into how simple, fundamental electronic circuits can be combined to form computers:

You are going to build a computer starting from basic components. […] In each level, you are tasked with building a component that […] can then be used as a building block in the next level.

The game does not require any previous knowledge about computer architecture or software, and does not require math skills beyond addition and subtraction.

From the about page, “The Nand Game is inspired by the amazing course From NAND to Tetris - Building a Modern Computer From First Principles which is highly recommended.”

(via Laurent Bercot)

A series of tutorial articles building up to a software renderer, not using a GPU at all, that can produce remarkably sophisticated renders of textured 3D objects. Great for building up intuition about the modern graphics stack; nothing more than high-school mathematics required.

In this series of articles, I aim to demonstrate how OpenGL, Vulkan, Metal, and DirectX work by writing a simplified clone from scratch. […] The task is as follows: using no third-party libraries (especially graphics-related ones), we will generate an image like this: […]

SIMD has a reputation for being complex. […] I think that’s wrong. SIMD can be simple to understand, and common “process N values at a time” SIMD code to speed up a naive for loop almost always follows the same general shape. Once you learn the basics, writing SIMD is just about as easy as a for loop.

Exercise for PL people: Why is the level of discourse so low here? What prevents the language (here, Zig) from including loops like this in their standard libraries? How does APL do it? (Hint: end←(codepoints>15)⍳0. How does the APL solution differ in terms of vectorizability? In terms of big-O complexity? How could that be addressed?)

Low-level implementation details on how Fil-C, a memory-safe, capability-oriented C compiler and runtime, is able to implement function calls efficiently while maintaining strong, well-defined memory-safety invariants:

Fil-C achieves memory safety even for programs that behave adversarially. That includes casting function pointers to the wrong signature and then calling them, exporting a function with one signature in one module and then importing it with a different signature in another, or even exporting a symbol as a function in one module and importing it as data in another (and vice-versa). Passing too few arguments, arguments of the wrong type, misusing va_list (including escaping it), expecting too many values to be returned - these are all things that the Fil-C calling convention either catches with a panic or ascribes safe behavior to.

An interesting trick for increasing instruction-level parallelism by introducing a spurious-seeming conditional to break a dependency chain:

If we could tell the CPU to predict that j stays intact, the loop would become throughput-bound rather than latency-bound. While we don’t have direct control over address prediction, we can simulate this with branch prediction: […]

See also Matt Godbolt’s talk about the fundamental performance features of modern CPUs.

An interactive tool for seeing how various compilers (GCC, Clang, MSVC, rustc, etc.) produce machine code for various architectures at various optimisation levels.

A very good talk about the fundamentals of high-performance CPUs, plus tooling for experimenting with and measuring low-level performance characteristics, from Matt Godbolt, who also runs the Compiler Explorer.

Presented at GOTO Chicago 2024.

• Talk summary page
• Slides