Internals for Interns

Over the last two articles we went through everything needed to run a model: an SDK that runs inference, and a management layer that downloads models, sizes them for your hardware and loads them.

In the previous article we followed a packet all the way in from the wire and all the way back out.

The previous article went through the Kronk SDK: a batching engine, a conversation cache, and a pile of workarounds behind a very small public API.

If you’ve used Testcontainers in any language (Go, Java, .NET, Python, Node, Rust), you’ve probably noticed an extra container hanging around in your docker ps output while your tests run.

At the end of the previous article we watched a module fill in a struct net_device_ops (include/linux/netdevice.h:1436), hand it to register_netdev() (net/core/dev.c:11531), and walk away.

In the previous article we took yzma apart and found a very disciplined bridge: purego finds the functions inside libllama.so, libffi makes the calls, and no C compiler is involved anywhere.

At the end of the previous article we handed a request to “the driver” and let it disappear into the hardware.

In the previous article we looked at what inference actually is — how a model takes a prompt and builds a response one token at a time.

The first time I reached for testing/synctest, I assumed it was a sleep helper with better manners.

In the previous article we followed a read() all the way down through the VFS: from the syscall, to the struct file, to ext4, and into the page cache.

Welcome to a new series!

In the previous article we saw how the scheduler decides which task gets the CPU — so at this point we know how programs get to run.

When you build a storage engine in Go, sooner or later you need to answer a very plain question: “How should the code read bytes from files?”

In the previous article we took apart the reflect package and found that its magic is mostly the compiler leaving very good notes — type descriptors frozen into read-only data at build time, and a package that knows how to walk them.

In the previous article we looked at how the kernel gives every process its own private view of memory.

In the previous article we watched the runtime rebuild an entire stack trace out of metadata the compiler and linker had frozen into the binary at build time.

In the previous article we looked at how a user program crosses the ring 3 → ring 0 boundary to ask the kernel for help.

In the previous article we took apart the select statement and saw how it’s really two features in one, with the compiler rewriting the easy shapes away and only the hard cases falling through to the runtime’s selectgo .

In the previous article we followed the kernel from the very first instruction the bootloader handed us all the way to the moment kernel_init called execve() on /sbin/init.

In the previous article we walked through slices, maps, and channels, and how each of them is structured under the hood.

Have you ever wondered what really happens between the moment you press the power button and the moment your login screen shows up?

So far in this series we’ve looked at the parts of the Go runtime that orchestrate execution — the memory allocator, the scheduler, the garbage collector, sysmon, the netpoller.

In the previous article , we explored Btrfs—a copy-on-write filesystem built around a single kind of B-tree, where every file, extent, checksum and chunk mapping lives as a tagged item in some tree, and snapshots fall out of the reference-counted extent d…

In the previous article we saw how sysmon steps in every 10ms to call netpoll(0) on behalf of busy Ps, making sure network I/O doesn’t stall when the scheduler is too busy to poll on its own.

In the previous article , we explored XFS—a filesystem built for extreme scale that divides the disk into independent Allocation Groups, each with its own B+ trees for free space, inodes, and extent tracking.

In the previous articles we explored the scheduler — how goroutines get multiplexed onto OS threads through the GMP model — and the garbage collector — how Go tracks and reclaims memory using a concurrent, tri-color mark-and-sweep approach.

In the previous article , we explored NTFS—a filesystem where everything is a file, from your documents to the Master File Table itself.

In the previous article we explored the Go scheduler — how goroutines get multiplexed onto OS threads, the GMP model, and all the tricks the runtime uses to keep your cores busy.

In the previous article , we explored ext4—a filesystem that divides the disk into block groups and separates metadata from data, with inodes in one place and file content in another.

In the previous article we explored how Go’s memory allocator manages heap memory — grabbing large arenas from the OS, dividing them into spans and size classes, and using a three-level hierarchy (mcache, mcentral, mheap) to make most allocations lock-fre…

In the previous article , we explored FAT32—a filesystem that conquered the world through simplicity.

In the previous article we explored how the Go runtime bootstraps itself — how a Go binary goes from the operating system handing it control to your func main() running.

In the introduction to this series , we covered the foundational concepts every filesystem needs: sectors, blocks, partitions, and the four essential services—naming, allocation, metadata, and crash recovery.

When you write Go, a lot happens behind the scenes.

Every time you save a document, download a photo, or install an application, you’re trusting a filesystem to keep your data safe.

In the previous post , we watched the compiler transform optimized SSA into machine code bytes and package them into object files.

When you create an index in PostgreSQL, you might think there’s just one type of index structure working behind the scenes.

In the previous post , we explored how the compiler transforms IR into SSA—a representation where every variable is assigned exactly once.

In the previous article , we explored how PostgreSQL’s planner chooses the optimal execution strategy.

In the previous post , we explored the IR—the compiler’s working format where devirtualization, inlining, and escape analysis happen.

In the previous article , we explored how PostgreSQL’s rewriter transforms queries—expanding views, applying security policies, and executing custom rules.

In the previous posts , we’ve explored how the Go compiler processes your code: the scanner breaks it into tokens, the parser builds an Abstract Syntax Tree, the type checker validates everything, and the Unified IR format serializes the type-checked AST…

In the previous article , we explored how PostgreSQL transforms SQL text into a validated Query tree through parsing and semantic analysis.

In the previous post , we explored how the Go compiler’s type checker analyzes your code.

In the previous article , we explored how PostgreSQL establishes connections and communicates using its wire protocol.

In the previous posts , we explored the scanner—which converts source code into tokens—and the parser —which takes those tokens and builds an Abstract Syntax Tree.

In the previous article , we explored the complete journey a SQL query takes through PostgreSQL—from parsing to execution.

In the previous blog post , we explored the scanner—the component that converts your source code from a stream of characters into a stream of tokens.

Ever wonder what happens when you type SELECT * FROM users WHERE id = 42; and hit Enter?

This is part of a series where I’ll walk you through the entire Go compiler, covering each phase from source code to executable.