From Logic Gates to Production Terminal Emulators

8 lessons. From electrons to main(). From fork() to framebuffers. From VT100 escape sequences to Metal shaders. Everything wired together into a working terminal emulator.

This is not a survey course. Each concept has a hands-on project. After you build it, you read how the Ghostty authors built the same thing. The gap between "I read about it" and "I understand it" is implementation.

Context #

• Assumes comfort with C and a willingness to read assembly, kernel interfaces, and GPU concepts
• Every concept is traced to its physical implementation (transistors for logic, page tables for virtual memory, Metal command buffers for rendering)
• Ghostty source is used as the reference implementation — after you build something, you study how production engineers solved the same problem
• Cross-domain bridges connect terminal emulation concepts to adjacent fields: vLLM KV-cache management, CUDA kernel programming, kernel hacking
• The voice is direct and engineering-first — no hand-waving, no "it just works," no abstraction without explanation

How to Use #

1. Lessons 1-5 build the foundation. Don't skip ahead. The terminal protocol (Lesson 6) makes no sense without understanding PTYs (Lesson 3). The GPU renderer (Lesson 7) is opaque without memory management (Lesson 4) and concurrency (Lesson 5).
2. Each lesson ends with a project. Build it. Reading about fork() and writing fork() are different activities.
3. After building each project, read the corresponding Ghostty source files listed at the end of each lesson. The contrast between your implementation and production code is where the deep learning happens.
4. Lessons 6-8 are the terminal-specific stack. They depend on everything that came before.
5. The final project, toyterm, wires every piece together. You will have built and tested each component independently before integration day.

Project Arc #

flowchart TD
    minish["minish (Lesson 2)<br/>shell with fork/exec<br/>pipes, signals, jobs"]
    ptycat["ptycat (Lesson 3)<br/>PTY inspector<br/>raw byte flow"]
    toyterm["toyterm (Lesson 8)<br/>full terminal emulator<br/>GPU rendering, fonts"]
    vtparse["vt-parse (Lesson 6)<br/>VT state machine<br/>CSI/OSC/SGR parser"]
    renderdemo["render-demo (Lesson 7)<br/>GPU text rendering<br/>FreeType + HarfBuzz"]
    minish --> vtparse
    ptycat --> vtparse
    ptycat --> renderdemo
    vtparse --> toyterm
    renderdemo --> toyterm

Each project is a component of the final toyterm. By the time you build toyterm, you have built and tested every piece independently.

Ghostty File Map #

Learning Principles #

1. Feynman test: If you can't explain it to a 5-year-old, you don't understand it yet.
2. First principles: Start from what you know and build up — never accept "it just works."
3. Implementation over reading: Every concept has a hands-on project.
4. Ghostty as reference: After you build it, read how the pros did it.
5. Cross-domain transfer: Memory allocators → vLLM KV-cache. Atomics → Ghostty mailbox. GPU pipeline → CUDA kernels.