ARGODELTA BUILD LAB Choose a track

ARGODELTA / BUILD LAB · 18 TRACKS

Build it once.
Understand it forever.

The fastest way past surface-level knowledge is to rebuild the machine underneath it. Choose a system, make a deliberately small version, and prove you understand each layer by shipping it.

Browse all tracks How the lab works

METHOD / SMALL, REAL, FINISHED

A smaller system is still a real system.

01

Pick one layer

Do not start with “build a database.” Start with pages, indexes and a query engine. One layer at a time keeps the project finishable.

02

Make it observable

Add logs, tests or a tiny CLI. If you cannot inspect the system’s state, you are only copying code.

03

Ship a proof

Finish with a demo, benchmark, test suite or short write-up. A working artifact is more valuable than another half-read tutorial.

PROJECT CATALOG / BUILD SOMETHING SPECIFIC

Choose your next layer.

YOUR PROGRESS0 of 18 complete
18 tracks External guides open the original author’s site.
01 / DATAIntermediate

Build a tiny SQL database

Start with a file, a page and a row. End with a database that can parse, store and retrieve real records.

You will build

  • A page-based storage engine
  • A B-tree index and cursor
  • A tiny SQL parser and executor

Proof: Persist records across restarts, then run one indexed query.

C12–20 hoursSystems depth
Build guide
02 / DATAIntermediate

Build a Redis-style key-value store

Learn why an in-memory store feels simple until durability, expiry and concurrency enter the room.

You will build

  • A RESP protocol parser
  • Strings, lists and expiry
  • Append-only persistence and recovery

Proof: Restart the server and recover data written before shutdown.

Go10–16 hoursProtocols
Build guide
03 / DATAIntermediate

Build a toy blockchain

Strip away the exchange price and inspect the actual construction: blocks, hashes, proof and chain validity.

You will build

  • Block hashing and linking
  • A simple proof-of-work loop
  • Chain validation and CLI inspection

Proof: Detect a tampered block and reject the corrupted chain.

Go8–14 hoursCryptography
Build guide
04 / LANGUAGESAdvanced

Build a programming language

Turn text into a tree, give the tree meaning, then execute it. This is where syntax stops feeling magical.

You will build

  • A scanner and recursive-descent parser
  • A resolved AST and environment
  • Variables, control flow and functions

Proof: Run a small program that uses recursion and scoped variables.

Java / C14–24 hoursCompilers
Build guide
05 / LANGUAGESIntermediate

Build a regex engine

Implement matching as a tiny virtual machine and learn why some regex engines can backtrack forever.

You will build

  • A compact regular-expression parser
  • NFA-style matching without recursion
  • Tests for greedy and bounded matches

Proof: Explain and test a pattern that would make a naive matcher hang.

C6–10 hoursAutomata
Core reference
06 / SYSTEMSStarter

Build a terminal text editor

A raw terminal, a gap buffer and one decision at a time. Build the smallest editor that still feels useful.

You will build

  • Raw-mode terminal input
  • Scrolling, search and syntax hints
  • Safe save and quit commands

Proof: Edit a multi-screen file and reopen it without corrupting the text.

C6–10 hoursTerminal I/O
Build guide
07 / SYSTEMSStarter

Build a Unix shell

The prompt is a program. Learn how command parsing, process creation, pipes and redirection actually fit together.

You will build

  • Read-evaluate-print loop
  • fork, exec and wait
  • Pipes and file redirection

Proof: Run grep through a pipe and redirect its output to a file.

C5–9 hoursProcesses
Build guide
08 / SYSTEMSAdvanced

Build a Git implementation

Demystify snapshots, trees, commits and object compression by implementing the plumbing commands yourself.

You will build

  • Object and tree serialization
  • Commit history and checkout
  • A reference parser and CLI

Proof: Open your repository with real Git without errors.

Python18–30 hoursContent addressing
Build guide
09 / SYSTEMSAdvanced

Build a Docker-like container

Containers are Linux primitives arranged carefully. Build the arrangement and see what isolation really means.

You will build

  • Namespaces, chroot and mounts
  • A minimal root filesystem
  • A parent process and child command

Proof: Run an isolated process with its own hostname and filesystem view.

C8–14 hoursLinux
Build guide
10 / NETWORKAdvanced

Build a TCP/IP stack

Move packets from Ethernet frames to sockets. This track rewards patience and a packet capture tool.

You will build

  • Ethernet, ARP and IPv4 parsing
  • ICMP and a TCP handshake
  • A tiny socket API

Proof: Fetch a small HTTP response over a TUN interface.

C30–50 hoursPackets
Project guide
11 / NETWORKIntermediate

Build a DNS resolver

Read a packet, follow referrals and cache answers. DNS becomes much less mysterious after one resolver.

You will build

  • DNS header and name decoding
  • Recursive lookups from a root server
  • TTL-aware caching

Proof: Resolve a domain from scratch and print the delegation path.

Python8–14 hoursBinary protocols
Build guide
12 / NETWORKStarter

Build a web server

Before frameworks, there was a socket and an HTTP request. Build the layer your production stack hides.

You will build

  • A listening TCP socket
  • Request parsing and status codes
  • Static files and basic concurrency

Proof: Serve a real HTML page and load it from another device.

Python6–10 hoursHTTP
Build guide
13 / NETWORKAdvanced

Build a BitTorrent client

Learn peer discovery, piece verification and distributed transfer by downloading one legal test file.

You will build

  • A bencode decoder
  • Tracker requests and peer handshakes
  • Piece scheduling and verification

Proof: Download and verify a public-domain test payload.

Go18–28 hoursDistributed systems
Build guide
14 / GRAPHICSIntermediate

Build a ray tracer

One weekend, one image. Follow rays into a scene and learn where lighting, materials and cameras fit.

You will build

  • Ray-sphere intersections
  • Materials, reflection and shadows
  • A progressive image renderer

Proof: Render a 1920×1080 scene with two reflective materials.

C++8–14 hoursRendering
Build guide
15 / GRAPHICSAdvanced

Build a software 3D renderer

Write the geometry pipeline by hand: triangles, buffers, shading and perspective without a graphics API.

You will build

  • A wireframe OBJ renderer
  • Triangle rasterization and depth
  • Simple lighting and camera controls

Proof: Render and rotate an OBJ model from your own rasterizer.

C++16–26 hoursGeometry
Build guide
16 / AIStarter

Build a neural network

Implement forward passes, gradients and gradient descent before reaching for another abstraction.

You will build

  • Matrix operations from scratch
  • Backpropagation for a small network
  • Training on a handwritten-digit dataset

Proof: Plot a loss curve that materially improves over training.

Python10–18 hoursLearning fundamentals
Build guide
17 / AIAdvanced

Build a small language model

Tokenization, attention, training and sampling—implement each stage in a model small enough to inspect.

You will build

  • A tokenizer and embedding pipeline
  • A self-attention block
  • Training loop and text sampling

Proof: Train a tiny model and generate a reproducible sample.

Python30–50 hoursTransformers
Build guide
18 / GAMESIntermediate

Build a CHIP-8 emulator

A tiny instruction set, a display and a clock. This is a complete emulator you can finish and show.

You will build

  • Memory, registers and stack
  • Instruction decoding and timers
  • A 64×32 pixel display and keypad

Proof: Run a public-domain CHIP-8 ROM at the correct speed.

Any language8–14 hoursEmulation
Build guide

CURATED FOR PRACTICE · NOT A CERTIFICATE

You do not need permission
to build the small version.

Pick the smallest track you can finish this week. The goal is not to clone a production system; it is to make each hidden mechanism visible in something you built yourself.

Pick a track