Projects
Every project you can build a course around
98 curated projects across 7 languages. Each one links to a real course map preview built by the same engine that generates your own course.
Python
Escape Engine: A Text Adventure
Type a command, move between rooms, and break out. You build the state machine that secretly runs every game, menu, and checkout flow.BeginnerWordle: Build It, Then Beat It
Build Wordle's exact green, yellow, and grey logic, then write a solver that cracks the hidden word in a handful of guesses.BeginnerDungeon Crawler: A Grid Roguelike
Move a hero through an ascii dungeon, grab the loot, and survive the walls. This is the grid logic and game loop inside every roguelike.BeginnerLaunch: A Physics Engine from Scratch
Step gravity through time and watch a launched object arc, peak, and fall. You build the numerical engine behind every simulation, one line at a time.BeginnerCrypt: A Cipher & Code-Breaking Toolkit
Write your own encryptor and decryptor, then build the frequency attack that cracks a secret message with no key, exactly how real codebreakers do it.IntermediateMarket Desk: Data Analytics with pandas
Load a table of holdings, rank every position, and surface the biggest mover of the day. This is the exact data loop analysts live in.IntermediateData Pipeline: A Mini ETL
Read messy CSV and JSON records, clean and reshape them, and emit a tidy summary report. The exact pipeline every data engineer builds on day one.IntermediateLogwatch: Catch the Intruder
Parse a flood of raw server logs, tally the status codes, and catch a brute-force attack in the act. The daily work of security and data engineers.IntermediateMaze Solver: Breadth-First Pathfinding
Generate a maze, then watch breadth-first search flood it and trace the shortest way out. The graph algorithm interviewers actually ask about.IntermediateRecall: The Engine Behind Anki
Build the real SM-2 algorithm that powers Anki and Duolingo. Schedule every flashcard by how well you know it, and watch the intervals stretch as you master them.IntermediateConway: The Game of Life
Four tiny rules, an ascii grid, and life that breeds, moves, and dies on its own. Build the most famous simulation in computing and watch order emerge from chaos.IntermediateMarkov: Build a Text Generator
Feed it a book and it writes new sentences in the same voice. You build the great-grandparent of every language model, in about fifteen lines.AdvancedSudoku Solver: Backtracking from Scratch
Solve any Sudoku, even the evil ones, with a backtracking search you build yourself. The core technique behind every constraint solver.AdvancedForge: A Tiny Calculator Language
Turn text like '3 4 + 5 *' into real answers by building your own interpreter. By the end, the word 'parsing' will never feel like magic again.AdvancedJavaScript
Live Dashboard: A UI Without a Screen
Build a text dashboard that refreshes like a real app, using nothing but data turned into strings. This is the actual skill hiding under React.Beginner2048: The Game Logic
Build the slide-and-merge brain behind 2048: tiles spawning, merging, and the win and lose checks, all as pure, testable functions.BeginnerText Adventure: A World You Can Walk
Build a world of rooms, items, and an inventory you explore by typing. A scriptable adventure engine you can replay from a list of commands.BeginnerCSV Parser: Harder Than It Looks
Write a CSV parser that survives quotes, commas, and newlines hiding inside fields. The deceptively tricky problem every backend dev has hit.IntermediateMarkdown Renderer: Build a Real Parser
Turn bold text and headers into styled terminal output by building the same tokenize-then-render pipeline that every compiler and code editor uses.IntermediateJSON Diff: Spot Every Change
Build a deep diff that reports exactly what was added, removed, or changed between two objects, the engine behind every 'review changes' screen.IntermediateWorld Engine: A Simulation That Replays
Build Life, a predator-prey world, or a market on a grid with seeded randomness, so every single run is identical, reproducible, and testable.IntermediateMoney Engine: The Bug That Costs Millions
0.1 plus 0.2 is not 0.3, and that bug has cost real companies real money. Build a money library that does the math correctly, splits bills, and never lies.IntermediateReactive Store: Redux From Scratch
Build the state engine behind Redux and Vue signals, with subscribe, dispatch, and reducers, then watch a single change ripple out to everything that cares.IntermediateSpreadsheet Engine: Make =SUM() Work
Build a spreadsheet that understands =SUM(A1:B2), tracks which cells depend on which, and recalculates instantly. A real tour of parsing and graphs.AdvancedTemplate Engine: Build Your Own Handlebars
Build a template engine with variables, loops, and conditionals, the rendering core behind every web framework you have ever used.AdvancedAsync, Demystified: Build Your Own Promise
Stop fearing async. Build a tiny scheduler and your own Promise, then watch JavaScript's exact running order print itself, step by step.AdvancedQuery Engine: Your Own where + groupBy
Build a chainable query API over plain arrays so you finally understand the tools, lodash, SQL, LINQ, that you will lean on for the rest of your career.AdvancedSchema Validator: Build Your Own Zod
Build a validation library that checks messy data and returns precise, path-aware errors. The quiet art of never trusting input you did not create.AdvancedSQL
Sales Explorer: Ask the Data Anything
Slice a real sales table to answer the questions a founder actually asks: best sellers, daily revenue, and who is buying.BeginnerMission Control: The Anomaly Hunt
Load a stream of thousands of raw readings, then write the queries that hunt down the one anomaly hiding in all the noise.BeginnerText Finder: Search a Messy Table
Build the search and filter layer that finds anything in a table full of inconsistent text, the query behind every search box.BeginnerThe Relationship Detective
Three tables that do not talk to each other. Your job: wire them together with joins and answer the questions no single table can.BeginnerData Janitor: The Cleanup Crew
Inherit a filthy table full of duplicates, NULLs, and typos, then write the queries that find and fix every data-quality crime.IntermediateRecommendations: 'Also Bought'
Build the 'customers who bought X also bought Y' engine with self-joins and co-occurrence counts, real recommender logic in pure SQL.IntermediateInventory Ledger: Stock Over Time
Turn a stream of stock-in and stock-out events into a running inventory level for every product, the backbone of any operations dashboard.IntermediateBuild a Database: Design the Schema
Stop just asking questions and start designing. Create tables, enforce the rules, run transactions, and watch the database reject bad data on sight.IntermediateThe Pivot Studio
Reshape data the way a spreadsheet never could: turn tall, skinny tables into wide cross-tab reports with conditional aggregation.IntermediateLeaderboard Engine
Build the ranking machine behind every leaderboard: ranks, ties, percentiles, and exactly who is one spot ahead of you, all with window functions.AdvancedFunnel Analysis: Where Users Drop Off
Measure a real conversion funnel from signup to purchase, count who survives each step, and pinpoint exactly where people leave.AdvancedThe Cohort Time Machine
Turn a pile of dated events into a story: bucket by month, measure growth and retention, and smooth the noise with rolling averages over time.AdvancedQuery Optimizer's Workshop
One answer, five ways to get it. Learn to refactor tangled subqueries into clean CTEs and read what the database actually does under the hood.AdvancedThe Graph Crawler
Model followers, prerequisites, and supply chains as a network, then walk it with recursive queries to find every path and connection.AdvancedLua
Text Adventure Engine
Build a dungeon crawler where every room, exit, and command is a plain Lua table you can extend forever. Data-driven worlds, no engine required.BeginnerQuest & Dialogue System
Build a branching dialogue and quest engine with flags, conditions, and choices, the storytelling core of every RPG.BeginnerInventory & Crafting: An RPG Backpack
Model an inventory and crafting recipes as tables, consume materials to craft new gear, and print a clean, sorted, aligned inventory report.BeginnerDice Engine: Roll 2d6+1, Repeatably
Write a parser for dice notation like 2d6+1 and a seeded roller, so every tabletop roll is repeatable, testable, and provably fair.IntermediateParticle Playground: Falling Sand
Simulate falling sand, water, or fireworks as ascii particles with gravity and velocity, a tiny physics toy that prints frame by frame.IntermediateLog Forensics: Patterns Without Regex
Parse raw log lines with Lua's own pattern matching to pull out structured fields and count errors per user, no regex library anywhere in sight.IntermediateJSON Codec in Pure Lua
Encode and decode JSON with no library at all, the serializer every game save, config file, and embedded device depends on.IntermediateGame of Life: Watch an Ecosystem Evolve
Run a cellular automaton on a 2D grid and watch it breed, spread, and die as crisp ascii frames printed tick by tick.IntermediateSave-Game Serializer
Recursively turn any Lua table into readable, reloadable text. The foundation under every save system and config file you will ever write.IntermediateCombat Engine: Speed-Ordered Showdown
Build object-oriented fighters that trade blows in speed order until one falls. A full mini combat engine, rounds, turns, and all.IntermediateA* Pathfinding: Give Enemies a Brain
Implement A* so your game's enemies find the smartest route across a tile map, dodging walls. The algorithm behind real game AI.AdvancedNPC Brain: A Coroutine State Machine
Give an enemy a memory that survives between game ticks using coroutines, so its patrol-and-chase brain pauses and resumes like a tiny thread.AdvancedRules Engine: A Mini Language Inside Lua
Use metatables to build a fluent rule language, so business logic reads like rule('vip'):when(...):when(...). Lua's metaprogramming, unlocked.AdvancedBuild a Virtual Machine in Lua
Build a tiny machine that runs programs like '3 4 + 5 *' off a stack, the same core idea that powers Lua's own interpreter.AdvancedR
Stat Engine: The Math Behind Every Dashboard
Build mean, median, spread, and outlier detection by hand, then again with R's vectorized core. The statistics engine under every report you have ever read.BeginnerWord Counter: What Is This Text Really About?
Feed in raw text and rank the words that actually matter. A tokenizer and frequency report that shows off R's string and table superpowers.BeginnerASCII Charts: Visualize Anywhere
No plotting window, no problem. Render data as crisp ascii bar charts straight to the console, visualization that works anywhere R runs.BeginnerLeaderboard Builder: The Data-Frame Workout
Take a messy table of records and produce a clean, ranked leaderboard. Filter, group, aggregate, sort: the daily verb set of every R data job.IntermediateCorrelation Explorer: What Moves Together?
Build and read a correlation matrix to find which variables actually rise and fall together, the first move in any real data investigation.IntermediateBuild a Calculator That Thinks in Stacks
Write a tiny language: a calculator that evaluates '3 4 + 2 *' off a stack. The gateway drug to understanding how every interpreter works.IntermediateMonte Carlo Simulator
Answer hard probability questions with brute-force luck. Roll ten thousand dice, count what happens, and watch the simulation settle on the true odds.IntermediateSurvey Lab: From Responses to Insight
Turn raw survey rows into cross-tabs, proportions, and a summary table that answers 'who thinks what', applied stats that actually ship.IntermediateForecast Engine: Predict Next Month
Fit a real regression line to six months of data, read the trend, and forecast what comes next, using the modeling R data scientists actually ship.IntermediateBootstrap Lab: Confidence Without Formulas
Estimate a confidence interval by resampling your data thousands of times, bootstrapping, the trick that frees you from scary statistics formulas.IntermediateData Cleaner: Rescue a Real-World Mess
Take a dirty table full of missing values and text where numbers belong, and produce clean, analysis-ready data with imputation you can defend.IntermediateK-Means from Scratch
Cluster data into natural groups by implementing k-means yourself: assign, recompute, repeat. The workhorse of unsupervised machine learning.AdvancedThe Account That Remembers: Closures in R
Build a bank account that quietly tracks its own balance and history using closures, R's elegant, object-like way to bundle state with behavior.AdvancedA/B Test Lab: Did It Really Win?
Did the new version win, or did you just get lucky? Run a real t-test on two groups and let the p-value settle the argument once and for all.AdvancedRuby
Text Adventure: A World You Can Walk
Build a world of rooms, items, and an inventory you explore by typing. A scriptable adventure engine you can replay from a list of commands.BeginnerWordle: Build It, Then Beat It
Build Wordle's exact green, yellow, and grey logic, then write a solver that narrows the hidden word in a handful of guesses.BeginnerDice Notation: Roll Like a Tabletop
Parse '3d6+2' the way every tabletop app does, roll it, and report the total and each die. Your first real parser, in a dozen lines.BeginnerBank Account: Your First Real Class
Model a bank account that deposits, withdraws, and refuses to overdraw. The object-oriented foundation under every app you will build.BeginnerSales Report: Aggregate a CSV
Read a table of sales rows, group them by region, and surface the top performer. The exact data loop every backend and analyst lives in.IntermediateMarkdown Renderer: Build a Real Parser
Turn bold text and headers into styled terminal output with the same tokenize-then-render pipeline every editor and compiler uses.IntermediateConfig Loader: Deep-Merge JSON
Load a base config and an override and deep-merge them the way every framework loads settings. Recursion over real nested data.IntermediateLogwatch: Catch the Intruder
Parse a flood of raw server logs, tally the status codes, and catch a brute-force attack in the act. The daily work of security engineers.IntermediateInventory Manager: Mixins in Action
Build an inventory of items that sort and compare themselves by including Ruby's own modules. The duck-typing power that makes Ruby feel magic.IntermediateRecall: The Engine Behind Anki
Build the real SM-2 algorithm that powers Anki and Duolingo. Schedule every flashcard by how well you know it and watch the intervals stretch.IntermediateMaze Solver: Breadth-First Pathfinding
Build a maze, then watch breadth-first search flood it and trace the shortest way out. The graph algorithm interviewers actually ask about.IntermediateCrypt: A Cipher and Code-Breaker
Write your own encryptor and decryptor, then build the frequency attack that cracks a message with no key, exactly how real codebreakers do it.IntermediateMarkov: Build a Text Generator
Feed it a book and it writes new sentences in the same voice. You build the great-grandparent of every language model, in about fifteen lines.AdvancedForge: A Tiny Calculator Language
Turn text like '3 4 + 5 *' into real answers by building your own interpreter. By the end the word parsing will never feel like magic again.AdvancedPHP
Text Adventure: A World You Can Walk
Build a world of rooms, items, and an inventory you explore by typing. A scriptable adventure engine you can replay from a list of commands.BeginnerWordle: Build It, Then Beat It
Build Wordle's exact green, yellow, and grey logic, then write a solver that narrows the hidden word in a handful of guesses.BeginnerBank Account: Your First Real Class
Model a bank account that deposits, withdraws, and refuses to overdraw. The object-oriented foundation under every backend you will build.BeginnerUnit Converter: A Tiny CLI Tool
Build a converter that turns Celsius to Fahrenheit, miles to km, and more, dispatching on a unit name. Your first real command-style tool.BeginnerSales Report: Aggregate a CSV
Read a table of sales rows, group them by region, and surface the top performer. The exact data loop every PHP backend lives in.IntermediateMarkdown Renderer: Build a Real Parser
Turn bold text and headers into HTML by building the same tokenize-then-render pipeline every template engine and CMS uses.IntermediateMini Router: The Heart of a Framework
Build the request router that maps a path like /users/42 to the right handler, the core idea inside Laravel and every web framework.IntermediateLogwatch: Catch the Intruder
Parse a flood of raw server logs, tally the status codes, and catch a brute-force attack in the act. The daily work of backend and security engineers.IntermediateTemplate Engine: Build Your Own Blade
Render '{{ name }}' against your data the way every templating system does. The string-substitution engine behind every web page you have seen.IntermediateForm Validator: Rules as Functions
Build the validation library that powers every signup form: required, email, min-length, composed as small functions you can reuse.IntermediateCrypt: A Cipher and Code-Breaker
Write your own encryptor and decryptor, then build the frequency attack that cracks a message with no key, exactly how real codebreakers do it.IntermediateShopping Cart: Totals, Tax, and Discounts
Build the cart engine behind every checkout: line items, quantities, a discount rule, and a tax calc, all as testable objects.IntermediateMarkov: Build a Text Generator
Feed it a book and it writes new sentences in the same voice. You build the great-grandparent of every language model, in about twenty lines.AdvancedForge: A Tiny Calculator Language
Turn text like '3 4 + 5 *' into real answers by building your own interpreter. By the end the word parsing will never feel like magic again.Advanced