Programming

01: How to Read This Book
How Can Tiny Rules Build Complex Worlds?
02: What Would Digital Life Mean?
02: What Would Digital Life Mean?
Build Your First Automaton
03: Look at This Thing
Encode All 256 Elementary Rules
04: Now There Are Two
Rule 30 and the Surprise of Complexity
05: So We Built the Wrong Thing on Purpose
Rule 110 and Computation in a Grid
06: It Looked Like Flocking
Conway's Game of Life
07: The Digital Crystal
Patterns as Data — Oscillators, Spaceships and Gliders
08: The Crystal Gets a Past
Beyond Conway — Life-like and Multi-State Rules
09: Can Experience Change the Material?
Add Randomness Without Losing the Model
10: What Survives Material Loss?
Build a Forest Fire Simulation
11: What Does It Cost to Stay?
Simulate Traffic with Rule 184
12: Is There Actually One Thing Here?
Diffusion as Local Exchange
13: What Does One Attachment Cause?
Reaction-Diffusion and Pattern Formation
14: Can Finite Computation Couple Distant Events?
Build a Predator-Prey Ecosystem
15: Can the Past Redirect the Future?
Generate Caves from Noise
16: We Found an Individual. Then We Didn't.
Grow Terrain from Local Height Rules
17: How to Fail Correctly
Generate Textures with Local Rules
18: What Is Digital Life?
Measure a Cellular Automaton
Activity, Density and Change
Entropy and Information
Periodicity and Attractors
Sensitivity to Initial Conditions
Classify Rule Behavior
Search All 256 Elementary Rules
Search Larger Rule Spaces
Evolve Rules for Desired Behavior
Cellular Automata as Computation
From Discrete Cells to Continuous State
Neighborhoods as Convolution Kernels
Growth Functions
Build Lenia From First Principles
Discover Your First Lenia Organisms
Search Lenia Parameter Space
Multi-Kernel and Multi-Channel Lenia
Damage, Robustness and Persistence
Flow-Lenia and Mass-Conserving Artificial Life
Make the Automaton Differentiable
Learn the Local Update Rule
Hidden Cell Channels and Local Memory
Grow a Target From One Seed
Randomize the Update Schedule
Train for Persistence
Regenerate After Damage
Test Generalization Beyond Training
Neural Cellular Automata for Pathfinding
Learn to Solve Mazes
Generalize to Harder and Larger Mazes
Inspect Hidden-State Propagation
What Did the Neural CA Actually Learn?
Profile Before You Optimize
Vectorize the Update Loop
Run Cellular Automata on the GPU
Use FFTs for Large Neighborhoods
Build a Reusable Cellular Automata Engine
Make Experiments Reproducible
Run Parameter Sweeps and Benchmarks
Generate Figures and Animations
Build a Cellular Automata Laboratory
Capstone — Discover, Measure and Explain a New System
Advanced Agents From First Principles 08: Is Your Agent Spending the Same Compute on Every Task? Build Adaptive Agents That Escalate Only When Needed
Advanced Agents From First Principles 26: Why Did the Agent Fail? Build an Incident Forensics Pipeline
Advanced Agents From First Principles 27: How Reliable Does an Agent Need to Be? Define SLOs and Error Budgets
Advanced Agents From First Principles 28: Where Should You Spend the Next Engineering Hour? Prioritize Reliability by Risk and Expected Return
Advanced Agents From First Principles 29: When Should an Agent Stop and Ask a Human? Design Authority Boundaries and Escalation
Advanced Agents From First Principles 30: Is This Task Outside Your Agent’s Competence? Build Competence Envelopes and OOD Detection
Advanced Agents From First Principles 31: How Can an Agent Learn New Capabilities Without Expanding Its Own Authority? Use Sandboxed Capability Acquisition
Advanced Agents From First Principles 32: Which Capabilities Are Actually Worth Building? Design a Capability Portfolio
Advanced Agents From First Principles 33: Which Shared Components Actually Unlock More Capability? Build a Capability Dependency Graph
Advanced Agents From First Principles 34: Where Should This Task Actually Run? Build Capability-Aware Placement Across Models, Providers and Resource Pools
Advanced Agents From First Principles 35: How Do You Move a Running Agent Between Workers Without Losing Meaning? Build Portable Execution State and Safe Handoff
Advanced Agents From First Principles 36: Is Your Agent Acting on Stale State? Build Temporal Consistency, Freshness Budgets and Conflict Detection
Advanced Agents From First Principles 37: Is Your Agent Still Solving the Right Task? Build Intent Versioning, Supersession and Cancellation
Advanced Agents From First Principles 38: A Plan Is Not a Commitment — Model Goals, Commitments and Executable Work
Advanced Agents From First Principles 39: How Do You Make an Agent Survive for Days? Build Durable Long-Running Workflows
Advanced Agents From First Principles 40: Your Agent Changed the World. What Happens When Step Two Fails? Build Transactions, Compensation and Reconciliation
Advanced Agents From First Principles 41: What Should Your Agent Trust? Build Explicit Security and Trust Boundaries
Advanced Agents From First Principles 42: How Do Multiple Agents Coordinate Without Becoming a Distributed Argument?
Advanced Agents From First Principles 43: Who Controls the Agent? Build an Explicit Agent Control Plane
What Does a Preference Know About the Future?
The Preference Was Only the Beginning
Codex Manager: Building a Prompt-State Runtime for Hackathon-Grade Code Optimization
AI as an Amplifier, Not a Utility
SQLite: the small database that packs a big punch
Debugging Jupyter Notebooks in VS Code
Project 6: Validator
Project 5: Dictator
Project 4: Meth
Project 3: Site Shot
An android SharedPreferences wrapper class
Project 2: File Explorer for android
Project 1: Catcher